-unindex needs to decrypt KBlock

diff --git a/src/fs/fs_api.c b/src/fs/fs_api.c
index 9acec5be45c7d2d729eab7f3e928f557177d7028..669b8cc39fdde85ae60f0c7a296f25b661cef4bd 100644 (file)
--- a/src/fs/fs_api.c
+++ b/src/fs/fs_api.c
@@ -1991,7 +1991,7 @@ deserialize_unindex_file (void *cls, const char *filename)
       (GNUNET_OK != read_start_time (rh, &uc->start_time)) ||
       (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &state)) ||
       (GNUNET_OK != GNUNET_BIO_read (rh, "uri", &uc->chk, sizeof (struct ContentHashKey))) ||
-      (GNUNET_BIO_read_string (rh, "unindex-kskuri", &uris, 10 * 1024)) ||
+      (GNUNET_OK != GNUNET_BIO_read_string (rh, "unindex-kskuri", &uris, 10 * 1024)) ||
       (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &uc->ksk_offset)) )
   {
     GNUNET_break (0);

diff --git a/src/fs/fs_api.h b/src/fs/fs_api.h
index 924911b636ae51d9252fea2f091ce36dcf2701f1..e75b75f417fb0d959665189bbbf338a102143e7b 100644 (file)
--- a/src/fs/fs_api.h
+++ b/src/fs/fs_api.h
@@ -1382,10 +1382,15 @@ struct GNUNET_FS_UnindexContext
   struct GNUNET_DATASTORE_QueueEntry *dqe;
 
   /**
-   * Current query key of 'get_key' operation.
+   * Current key for decrypting KBLocks from 'get_key' operation.
    */
   GNUNET_HashCode key;
 
+  /**
+   * Current query of 'get_key' operation.
+   */
+  GNUNET_HashCode query;
+
   /**
    * First content UID, 0 for none.
    */

diff --git a/src/fs/fs_unindex.c b/src/fs/fs_unindex.c
index 07b9cccd3f688c3ad95b6398a7987bf098bbea6f..9e477c1111518055e8a7263729ab41bd560e0002 100644 (file)
--- a/src/fs/fs_unindex.c
+++ b/src/fs/fs_unindex.c
@@ -446,7 +446,6 @@ process_kblock_for_unindex (void *cls,
 {
   struct GNUNET_FS_UnindexContext *uc = cls;
   const struct KBlock *kb;
-  const char *uris;
   struct GNUNET_FS_Uri *chk_uri;
 
   uc->dqe = NULL;
@@ -476,17 +475,33 @@ process_kblock_for_unindex (void *cls,
     goto get_next;
   }
   kb = data;
-  uris = (const char*) &kb[1];
-  if (NULL == memchr (uris, 0, size - sizeof (struct KBlock)))
   {
-    GNUNET_break (0);
-    goto get_next;
-  }
-  chk_uri = GNUNET_FS_uri_parse (uris, NULL);
-  if (NULL == chk_uri)
-  {
-    GNUNET_break (0);
-    goto get_next;
+    char pt[size - sizeof (struct KBlock)];  
+    struct GNUNET_CRYPTO_AesSessionKey skey;
+    struct GNUNET_CRYPTO_AesInitializationVector iv;
+ 
+    GNUNET_CRYPTO_hash_to_aes_key (&uc->key, &skey, &iv);
+    if (-1 ==
+       GNUNET_CRYPTO_aes_decrypt (&kb[1], size - sizeof (struct KBlock), &skey,
+                                  &iv, pt))
+    {
+      GNUNET_break (0);
+      goto get_next;
+    }       
+    if (NULL == memchr (pt, 0, sizeof (pt)))
+    {
+      GNUNET_break (0);
+      goto get_next;
+    }
+    chk_uri = GNUNET_FS_uri_parse (pt, NULL);
+    if (NULL == chk_uri)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                 _("Failed to parse URI `%s' from KBlock!\n"),
+                 pt);
+      GNUNET_break (0);
+      goto get_next;
+    }
   }
   if (0 != memcmp (&uc->chk,
                   &chk_uri->data.chk.chk,
@@ -507,7 +522,7 @@ process_kblock_for_unindex (void *cls,
  get_next:
   uc->dqe = GNUNET_DATASTORE_get_key (uc->dsh,
                                      uc->roff++,
-                                     &uc->key,
+                                     &uc->query,
                                      GNUNET_BLOCK_TYPE_FS_KBLOCK,
                                      0 /* priority */, 1 /* queue size */,
                                      GNUNET_TIME_UNIT_FOREVER_REL,
@@ -525,7 +540,6 @@ void
 GNUNET_FS_unindex_do_remove_kblocks_ (struct GNUNET_FS_UnindexContext *uc)
 {
   const char *keyword;
-  GNUNET_HashCode hc;
   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub;
   struct GNUNET_CRYPTO_RsaPrivateKey *pk;
 
@@ -547,19 +561,19 @@ GNUNET_FS_unindex_do_remove_kblocks_ (struct GNUNET_FS_UnindexContext *uc)
   }
   /* FIXME: code duplication with fs_search.c here... */
   keyword = &uc->ksk_uri->data.ksk.keywords[uc->ksk_offset][1];
-  GNUNET_CRYPTO_hash (keyword, strlen (keyword), &hc);
-  pk = GNUNET_CRYPTO_rsa_key_create_from_hash (&hc);
+  GNUNET_CRYPTO_hash (keyword, strlen (keyword), &uc->key);
+  pk = GNUNET_CRYPTO_rsa_key_create_from_hash (&uc->key);
   GNUNET_assert (pk != NULL);
   GNUNET_CRYPTO_rsa_key_get_public (pk, &pub);
   GNUNET_CRYPTO_rsa_key_free (pk);
   GNUNET_CRYPTO_hash (&pub,
                      sizeof (struct
                              GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
-                     &uc->key);
+                     &uc->query);
   uc->first_uid = 0;
   uc->dqe = GNUNET_DATASTORE_get_key (uc->dsh,
                                      uc->roff++,
-                                     &uc->key,
+                                     &uc->query,
                                      GNUNET_BLOCK_TYPE_FS_KBLOCK,
                                      0 /* priority */, 1 /* queue size */,
                                      GNUNET_TIME_UNIT_FOREVER_REL,