src/gns/plugin_block_gns.c

   1 /*
   2      This file is part of GNUnet
   3      (C) 2010 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file gns/plugin_block_gns.c
  23  * @brief blocks used for GNS records
  24  * @author Martin Schanzenbach
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_block_plugin.h"
  29 #include "gnunet_namestore_service.h"
  30 #include "block_gns.h"
  31 #include "gnunet_signatures.h"
  32
  33 /**
  34  * Number of bits we set per entry in the bloomfilter.
  35  * Do not change! -from fs
  36  */
  37 #define BLOOMFILTER_K 16
  38
  39 /**
  40  * Function called to validate a reply or a request.  For
  41  * request evaluation, simply pass "NULL" for the reply_block.
  42  * Note that it is assumed that the reply has already been
  43  * matched to the key (and signatures checked) as it would
  44  * be done with the "get_key" function.
  45  *
  46  * @param cls closure
  47  * @param type block type
  48  * @param query original query (hash)
  49  * @param bf pointer to bloom filter associated with query; possibly updated (!)
  50  * @param bf_mutator mutation value for bf
  51  * @param xquery extrended query data (can be NULL, depending on type)
  52  * @param xquery_size number of bytes in xquery
  53  * @param reply_block response to validate
  54  * @param reply_block_size number of bytes in reply block
  55  * @return characterization of result
  56  */
  57 static enum GNUNET_BLOCK_EvaluationResult
  58 block_plugin_gns_evaluate (void *cls, enum GNUNET_BLOCK_Type type,
  59                           const GNUNET_HashCode * query,
  60                           struct GNUNET_CONTAINER_BloomFilter **bf,
  61                           int32_t bf_mutator, const void *xquery,
  62                           size_t xquery_size, const void *reply_block,
  63                           size_t reply_block_size)
  64 {
  65   if (type != GNUNET_BLOCK_TYPE_GNS_NAMERECORD)
  66     return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
  67   if (reply_block_size == 0)
  68     return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
  69
  70   char* name;
  71   GNUNET_HashCode pkey_hash;
  72   GNUNET_HashCode query_key;
  73   GNUNET_HashCode name_hash;
  74   GNUNET_HashCode mhash;
  75   GNUNET_HashCode chash;
  76   struct GNSNameRecordBlock *nrb;
  77   struct GNSRecordBlock *rb;
  78   uint32_t rd_count;
  79
  80   nrb = (struct GNSNameRecordBlock *)reply_block;
  81   name = (char*)&nrb[1];
  82   GNUNET_CRYPTO_hash(&nrb->public_key,
  83                      sizeof(nrb->public_key),
  84                      &pkey_hash);
  85
  86   GNUNET_CRYPTO_hash(name, strlen(name), &name_hash);
  87
  88   GNUNET_CRYPTO_hash_xor(&pkey_hash, &name_hash, &query_key);
  89   struct GNUNET_CRYPTO_HashAsciiEncoded hstr;
  90   GNUNET_CRYPTO_hash_to_enc (query, &hstr);
  91   GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Query key: %s\n", (char*)&hstr);
  92   GNUNET_CRYPTO_hash_to_enc (&pkey_hash, &hstr);
  93   GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Pub key: %s\n", (char*)&hstr);
  94   GNUNET_CRYPTO_hash_to_enc (&name_hash, &hstr);
  95   GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Name: %s\n", (char*)&hstr);
  96   GNUNET_CRYPTO_hash_to_enc (&query_key, &hstr);
  97   GNUNET_log(GNUNET_ERROR_TYPE_INFO, "XOR: %s\n", (char*)&hstr);
  98
  99
 100   //Check query key against public key
 101   if (0 != GNUNET_CRYPTO_hash_cmp(query, &query_key))
 102     return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
 103
 104   GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Checking payload\n");
 105   rd_count = ntohl(nrb->rd_count);
 106
 107   struct GNUNET_NAMESTORE_RecordData rd[rd_count];
 108   int i = 0;
 109   int record_match = 0;
 110   rb = (struct GNSRecordBlock*)(&name[strlen(name) + 1]);
 111
 112   for (i=0; i<rd_count; i++)
 113   {
 114     rd[i].record_type = ntohl(rb->type);
 115     rd[i].expiration =
 116       GNUNET_TIME_absolute_ntoh(rb->expiration);
 117     rd[i].data_size = ntohl(rb->data_length);
 118     rd[i].flags = ntohl(rb->flags);
 119     rd[i].data = (char*)&rb[1];
 120     rb = (struct GNSRecordBlock *)((char*)&rb[1] + rd[i].data_size);
 121     if (xquery_size > 0 && (rd[i].record_type == *((uint32_t*)xquery)))
 122       record_match++;
 123   }
 124   GNUNET_log(GNUNET_ERROR_TYPE_INFO, "done\n");
 125
 126
 127   /*if (GNUNET_OK != GNUNET_NAMESTORE_verify_signature (&nrb->public_key,
 128                                                       name,
 129                                                       rd_count,
 130                                                       rd,
 131                                                       NULL))
 132   {
 133     GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Signature invalid\n");
 134     return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
 135   }*/
 136   GNUNET_log(GNUNET_ERROR_TYPE_INFO, "done\n");
 137   //No record matches query
 138   if ((xquery_size > 0) && (record_match == 0))
 139     return GNUNET_BLOCK_EVALUATION_OK_MORE;
 140   GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Records match\n");
 141   //FIXME do bf check before or after crypto??
 142   if (NULL != bf)
 143   {
 144     GNUNET_CRYPTO_hash(reply_block, reply_block_size, &chash);
 145     GNUNET_BLOCK_mingle_hash(&chash, bf_mutator, &mhash);
 146     if (NULL != *bf)
 147     {
 148       GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Check BF\n");
 149       if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test(*bf, &mhash))
 150         return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;
 151     }
 152     else
 153     {
 154       *bf = GNUNET_CONTAINER_bloomfilter_init(NULL, 8, BLOOMFILTER_K);
 155     }
 156     GNUNET_CONTAINER_bloomfilter_add(*bf, &mhash);
 157   }
 158   GNUNET_log(GNUNET_ERROR_TYPE_INFO, "No dup\n");
 159   return GNUNET_BLOCK_EVALUATION_OK_MORE;
 160 }
 161
 162
 163 /**
 164  * Function called to obtain the key for a block.
 165  *
 166  * @param cls closure
 167  * @param type block type
 168  * @param block block to get the key for
 169  * @param block_size number of bytes in block
 170  * @param key set to the key (query) for the given block
 171  * @return GNUNET_OK on success, GNUNET_SYSERR if type not supported
 172  *         (or if extracting a key from a block of this type does not work)
 173  */
 174 static int
 175 block_plugin_gns_get_key (void *cls, enum GNUNET_BLOCK_Type type,
 176                          const void *block, size_t block_size,
 177                          GNUNET_HashCode * key)
 178 {
 179   if (type != GNUNET_BLOCK_TYPE_GNS_NAMERECORD)
 180     return GNUNET_SYSERR;
 181   GNUNET_HashCode name_hash;
 182   GNUNET_HashCode pkey_hash;
 183   struct GNSNameRecordBlock *nrb = (struct GNSNameRecordBlock *)block;
 184
 185   GNUNET_CRYPTO_hash(&nrb[1], strlen((char*)&nrb[1]), &name_hash);
 186   GNUNET_CRYPTO_hash(&nrb->public_key,
 187                      sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
 188                      &pkey_hash);
 189
 190   GNUNET_CRYPTO_hash_xor(&name_hash, &pkey_hash, key);
 191
 192   //FIXME calculate key from name and hash(pkey) here
 193   return GNUNET_OK;
 194 }
 195
 196
 197 /**
 198  * Entry point for the plugin.
 199  */
 200 void *
 201 libgnunet_plugin_block_gns_init (void *cls)
 202 {
 203   static enum GNUNET_BLOCK_Type types[] =
 204   {
 205     GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
 206     GNUNET_BLOCK_TYPE_ANY       /* end of list */
 207   };
 208   struct GNUNET_BLOCK_PluginFunctions *api;
 209
 210   api = GNUNET_malloc (sizeof (struct GNUNET_BLOCK_PluginFunctions));
 211   api->evaluate = &block_plugin_gns_evaluate;
 212   api->get_key = &block_plugin_gns_get_key;
 213   api->types = types;
 214   return api;
 215 }
 216
 217
 218 /**
 219  * Exit point from the plugin.
 220  */
 221 void *
 222 libgnunet_plugin_block_gns_done (void *cls)
 223 {
 224   struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
 225
 226   GNUNET_free (api);
 227   return NULL;
 228 }
 229
 230 /* end of plugin_block_gns.c */