src/util/crypto_hash.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2001-2013 GNUnet e.V.
   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., 51 Franklin Street, Fifth Floor,
  18      Boston, MA 02110-1301, USA.
  19
  20 */
  21 /**
  22  * @file util/crypto_hash.c
  23  * @brief SHA-512 #GNUNET_CRYPTO_hash() related functions
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet_crypto_lib.h"
  28 #include "gnunet_strings_lib.h"
  29 #include <gcrypt.h>
  30
  31 #define LOG(kind,...) GNUNET_log_from (kind, "util-crypto-hash", __VA_ARGS__)
  32
  33 #define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util-crypto-hash", syscall, filename)
  34
  35 /**
  36  * Hash block of given size.
  37  *
  38  * @param block the data to #GNUNET_CRYPTO_hash, length is given as a second argument
  39  * @param size the length of the data to #GNUNET_CRYPTO_hash in @a block
  40  * @param ret pointer to where to write the hashcode
  41  */
  42 void
  43 GNUNET_CRYPTO_hash (const void *block,
  44                     size_t size,
  45                     struct GNUNET_HashCode *ret)
  46 {
  47   gcry_md_hash_buffer (GCRY_MD_SHA512, ret, block, size);
  48 }
  49
  50
  51 /* ***************** binary-ASCII encoding *************** */
  52
  53
  54 /**
  55  * Convert GNUNET_CRYPTO_hash to ASCII encoding.  The ASCII encoding is rather
  56  * GNUnet specific.  It was chosen such that it only uses characters
  57  * in [0-9A-V], can be produced without complex arithmetics and uses a
  58  * small number of characters.  The GNUnet encoding uses 103
  59  * characters plus a null terminator.
  60  *
  61  * @param block the hash code
  62  * @param result where to store the encoding (struct GNUNET_CRYPTO_HashAsciiEncoded can be
  63  *  safely cast to char*, a '\\0' termination is set).
  64  */
  65 void
  66 GNUNET_CRYPTO_hash_to_enc (const struct GNUNET_HashCode *block,
  67                            struct GNUNET_CRYPTO_HashAsciiEncoded *result)
  68 {
  69   char *np;
  70
  71   np = GNUNET_STRINGS_data_to_string ((const unsigned char *) block,
  72                                       sizeof (struct GNUNET_HashCode),
  73                                       (char*) result,
  74                                       sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1);
  75   GNUNET_assert (NULL != np);
  76   *np = '\0';
  77 }
  78
  79
  80 /**
  81  * Convert ASCII encoding back to hash code.
  82  *
  83  * @param enc the encoding
  84  * @param enclen number of characters in @a enc (without 0-terminator, which can be missing)
  85  * @param result where to store the hash code
  86  * @return #GNUNET_OK on success, #GNUNET_SYSERR if result has the wrong encoding
  87  */
  88 int
  89 GNUNET_CRYPTO_hash_from_string2 (const char *enc,
  90                                  size_t enclen,
  91                                  struct GNUNET_HashCode *result)
  92 {
  93   char upper_enc[enclen];
  94   char *up_ptr = upper_enc;
  95
  96   GNUNET_STRINGS_utf8_toupper (enc, up_ptr);
  97
  98   return GNUNET_STRINGS_string_to_data (upper_enc, enclen,
  99                                         (unsigned char*) result,
 100                                         sizeof (struct GNUNET_HashCode));
 101 }
 102
 103
 104 /**
 105  * @ingroup hash
 106  *
 107  * Compute the distance between 2 hashcodes.  The computation must be
 108  * fast, not involve bits[0] or bits[4] (they're used elsewhere), and be
 109  * somewhat consistent. And of course, the result should be a positive
 110  * number.
 111  *
 112  * @param a some hash code
 113  * @param b some hash code
 114  * @return a positive number which is a measure for
 115  *  hashcode proximity.
 116  */
 117 unsigned int
 118 GNUNET_CRYPTO_hash_distance_u32 (const struct GNUNET_HashCode *a,
 119                                  const struct GNUNET_HashCode *b)
 120 {
 121   unsigned int x1 = (a->bits[1] - b->bits[1]) >> 16;
 122   unsigned int x2 = (b->bits[1] - a->bits[1]) >> 16;
 123
 124   return (x1 * x2);
 125 }
 126
 127
 128 /**
 129  * Create a random hash code.
 130  *
 131  * @param mode desired quality level
 132  * @param result hash code that is randomized
 133  */
 134 void
 135 GNUNET_CRYPTO_hash_create_random (enum GNUNET_CRYPTO_Quality mode,
 136                                   struct GNUNET_HashCode *result)
 137 {
 138   int i;
 139
 140   for (i = (sizeof (struct GNUNET_HashCode) / sizeof (uint32_t)) - 1; i >= 0; i--)
 141     result->bits[i] = GNUNET_CRYPTO_random_u32 (mode, UINT32_MAX);
 142 }
 143
 144
 145 /**
 146  * compute result(delta) = b - a
 147  *
 148  * @param a some hash code
 149  * @param b some hash code
 150  * @param result set to b - a
 151  */
 152 void
 153 GNUNET_CRYPTO_hash_difference (const struct GNUNET_HashCode *a,
 154                                const struct GNUNET_HashCode *b,
 155                                struct GNUNET_HashCode *result)
 156 {
 157   int i;
 158
 159   for (i = (sizeof (struct GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; i--)
 160     result->bits[i] = b->bits[i] - a->bits[i];
 161 }
 162
 163
 164 /**
 165  * compute result(b) = a + delta
 166  *
 167  * @param a some hash code
 168  * @param delta some hash code
 169  * @param result set to a + delta
 170  */
 171 void
 172 GNUNET_CRYPTO_hash_sum (const struct GNUNET_HashCode * a,
 173                         const struct GNUNET_HashCode * delta, struct GNUNET_HashCode * result)
 174 {
 175   int i;
 176
 177   for (i = (sizeof (struct GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; i--)
 178     result->bits[i] = delta->bits[i] + a->bits[i];
 179 }
 180
 181
 182 /**
 183  * compute result = a ^ b
 184  *
 185  * @param a some hash code
 186  * @param b some hash code
 187  * @param result set to a ^ b
 188  */
 189 void
 190 GNUNET_CRYPTO_hash_xor (const struct GNUNET_HashCode *a,
 191                         const struct GNUNET_HashCode *b,
 192                         struct GNUNET_HashCode *result)
 193 {
 194   int i;
 195
 196   for (i = (sizeof (struct GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; i--)
 197     result->bits[i] = a->bits[i] ^ b->bits[i];
 198 }
 199
 200
 201 /**
 202  * Convert a hashcode into a key.
 203  *
 204  * @param hc hash code that serves to generate the key
 205  * @param skey set to a valid session key
 206  * @param iv set to a valid initialization vector
 207  */
 208 void
 209 GNUNET_CRYPTO_hash_to_aes_key (const struct GNUNET_HashCode *hc,
 210                                struct GNUNET_CRYPTO_SymmetricSessionKey *skey,
 211                                struct GNUNET_CRYPTO_SymmetricInitializationVector *iv)
 212 {
 213   GNUNET_assert (GNUNET_YES ==
 214                  GNUNET_CRYPTO_kdf (skey, sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey),
 215                                     "Hash key derivation", strlen ("Hash key derivation"),
 216                                     hc, sizeof (struct GNUNET_HashCode),
 217                                     NULL, 0));
 218   GNUNET_assert (GNUNET_YES ==
 219                  GNUNET_CRYPTO_kdf (iv, sizeof (struct GNUNET_CRYPTO_SymmetricInitializationVector),
 220                                     "Initialization vector derivation", strlen ("Initialization vector derivation"),
 221                                     hc, sizeof (struct GNUNET_HashCode),
 222                                     NULL, 0));
 223 }
 224
 225
 226 /**
 227  * Obtain a bit from a hashcode.
 228  * @param code the GNUNET_CRYPTO_hash to index bit-wise
 229  * @param bit index into the hashcode, [0...511]
 230  * @return Bit \a bit from hashcode \a code, -1 for invalid index
 231  */
 232 int
 233 GNUNET_CRYPTO_hash_get_bit (const struct GNUNET_HashCode * code, unsigned int bit)
 234 {
 235   GNUNET_assert (bit < 8 * sizeof (struct GNUNET_HashCode));
 236   return (((unsigned char *) code)[bit >> 3] & (1 << (bit & 7))) > 0;
 237 }
 238
 239
 240 /**
 241  * Determine how many low order bits match in two
 242  * `struct GNUNET_HashCode`s.  i.e. - 010011 and 011111 share
 243  * the first two lowest order bits, and therefore the
 244  * return value is two (NOT XOR distance, nor how many
 245  * bits match absolutely!).
 246  *
 247  * @param first the first hashcode
 248  * @param second the hashcode to compare first to
 249  *
 250  * @return the number of bits that match
 251  */
 252 unsigned int
 253 GNUNET_CRYPTO_hash_matching_bits (const struct GNUNET_HashCode * first,
 254                                   const struct GNUNET_HashCode * second)
 255 {
 256   unsigned int i;
 257
 258   for (i = 0; i < sizeof (struct GNUNET_HashCode) * 8; i++)
 259     if (GNUNET_CRYPTO_hash_get_bit (first, i) !=
 260         GNUNET_CRYPTO_hash_get_bit (second, i))
 261       return i;
 262   return sizeof (struct GNUNET_HashCode) * 8;
 263 }
 264
 265
 266 /**
 267  * Compare function for HashCodes, producing a total ordering
 268  * of all hashcodes.
 269  *
 270  * @param h1 some hash code
 271  * @param h2 some hash code
 272  * @return 1 if h1 > h2, -1 if h1 < h2 and 0 if h1 == h2.
 273  */
 274 int
 275 GNUNET_CRYPTO_hash_cmp (const struct GNUNET_HashCode *h1,
 276                         const struct GNUNET_HashCode *h2)
 277 {
 278   unsigned int *i1;
 279   unsigned int *i2;
 280   int i;
 281
 282   i1 = (unsigned int *) h1;
 283   i2 = (unsigned int *) h2;
 284   for (i = (sizeof (struct GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; i--)
 285   {
 286     if (i1[i] > i2[i])
 287       return 1;
 288     if (i1[i] < i2[i])
 289       return -1;
 290   }
 291   return 0;
 292 }
 293
 294
 295 /**
 296  * Find out which of the two `struct GNUNET_HashCode`s is closer to target
 297  * in the XOR metric (Kademlia).
 298  *
 299  * @param h1 some hash code
 300  * @param h2 some hash code
 301  * @param target some hash code
 302  * @return -1 if h1 is closer, 1 if h2 is closer and 0 if h1==h2.
 303  */
 304 int
 305 GNUNET_CRYPTO_hash_xorcmp (const struct GNUNET_HashCode *h1,
 306                            const struct GNUNET_HashCode *h2,
 307                            const struct GNUNET_HashCode *target)
 308 {
 309   int i;
 310   unsigned int d1;
 311   unsigned int d2;
 312
 313   for (i = sizeof (struct GNUNET_HashCode) / sizeof (unsigned int) - 1; i >= 0; i--)
 314   {
 315     d1 = ((unsigned int *) h1)[i] ^ ((unsigned int *) target)[i];
 316     d2 = ((unsigned int *) h2)[i] ^ ((unsigned int *) target)[i];
 317     if (d1 > d2)
 318       return 1;
 319     else if (d1 < d2)
 320       return -1;
 321   }
 322   return 0;
 323 }
 324
 325
 326 /**
 327  * @brief Derive an authentication key
 328  * @param key authentication key
 329  * @param rkey root key
 330  * @param salt salt
 331  * @param salt_len size of the @a salt
 332  * @param ... pair of void * & size_t for context chunks, terminated by NULL
 333  */
 334 void
 335 GNUNET_CRYPTO_hmac_derive_key (struct GNUNET_CRYPTO_AuthKey *key,
 336                                const struct GNUNET_CRYPTO_SymmetricSessionKey *rkey,
 337                                const void *salt, size_t salt_len, ...)
 338 {
 339   va_list argp;
 340
 341   va_start (argp, salt_len);
 342   GNUNET_CRYPTO_hmac_derive_key_v (key, rkey, salt, salt_len, argp);
 343   va_end (argp);
 344 }
 345
 346
 347 /**
 348  * @brief Derive an authentication key
 349  * @param key authentication key
 350  * @param rkey root key
 351  * @param salt salt
 352  * @param salt_len size of the @a salt
 353  * @param argp pair of void * & size_t for context chunks, terminated by NULL
 354  */
 355 void
 356 GNUNET_CRYPTO_hmac_derive_key_v (struct GNUNET_CRYPTO_AuthKey *key,
 357                                  const struct GNUNET_CRYPTO_SymmetricSessionKey *rkey,
 358                                  const void *salt, size_t salt_len,
 359                                  va_list argp)
 360 {
 361   GNUNET_CRYPTO_kdf_v (key->key, sizeof (key->key),
 362                        salt, salt_len,
 363                        rkey, sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey),
 364                        argp);
 365 }
 366
 367
 368 /**
 369  * Calculate HMAC of a message (RFC 2104)
 370  *
 371  * @param key secret key
 372  * @param plaintext input plaintext
 373  * @param plaintext_len length of @a plaintext
 374  * @param hmac where to store the hmac
 375  */
 376 void
 377 GNUNET_CRYPTO_hmac (const struct GNUNET_CRYPTO_AuthKey *key,
 378                     const void *plaintext, size_t plaintext_len,
 379                     struct GNUNET_HashCode *hmac)
 380 {
 381   static int once;
 382   static gcry_md_hd_t md;
 383   const unsigned char *mc;
 384
 385   if (! once)
 386   {
 387     once = 1;
 388     GNUNET_assert (GPG_ERR_NO_ERROR ==
 389                    gcry_md_open (&md, GCRY_MD_SHA512, GCRY_MD_FLAG_HMAC));
 390   }
 391   else
 392   {
 393     gcry_md_reset (md);
 394   }
 395   gcry_md_setkey (md, key->key, sizeof (key->key));
 396   gcry_md_write (md, plaintext, plaintext_len);
 397   mc = gcry_md_read (md, GCRY_MD_SHA512);
 398   GNUNET_assert (NULL != mc);
 399   GNUNET_memcpy (hmac->bits, mc, sizeof (hmac->bits));
 400 }
 401
 402
 403 /**
 404  * Context for cummulative hashing.
 405  */
 406 struct GNUNET_HashContext
 407 {
 408   /**
 409    * Internal state of the hash function.
 410    */
 411   gcry_md_hd_t hd;
 412 };
 413
 414
 415 /**
 416  * Start incremental hashing operation.
 417  *
 418  * @return context for incremental hash computation
 419  */
 420 struct GNUNET_HashContext *
 421 GNUNET_CRYPTO_hash_context_start ()
 422 {
 423   struct GNUNET_HashContext *hc;
 424
 425   hc = GNUNET_new (struct GNUNET_HashContext);
 426   GNUNET_assert (0 ==
 427                  gcry_md_open (&hc->hd,
 428                                GCRY_MD_SHA512,
 429                                0));
 430   return hc;
 431 }
 432
 433
 434 /**
 435  * Add data to be hashed.
 436  *
 437  * @param hc cummulative hash context
 438  * @param buf data to add
 439  * @param size number of bytes in @a buf
 440  */
 441 void
 442 GNUNET_CRYPTO_hash_context_read (struct GNUNET_HashContext *hc,
 443                          const void *buf,
 444                          size_t size)
 445 {
 446   gcry_md_write (hc->hd, buf, size);
 447 }
 448
 449
 450 /**
 451  * Finish the hash computation.
 452  *
 453  * @param hc hash context to use
 454  * @param r_hash where to write the latest / final hash code
 455  */
 456 void
 457 GNUNET_CRYPTO_hash_context_finish (struct GNUNET_HashContext *hc,
 458                            struct GNUNET_HashCode *r_hash)
 459 {
 460   const void *res = gcry_md_read (hc->hd, 0);
 461
 462   GNUNET_assert (NULL != res);
 463   if (NULL != r_hash)
 464     GNUNET_memcpy (r_hash,
 465             res,
 466             sizeof (struct GNUNET_HashCode));
 467   GNUNET_CRYPTO_hash_context_abort (hc);
 468 }
 469
 470
 471 /**
 472  * Abort hashing, do not bother calculating final result.
 473  *
 474  * @param hc hash context to destroy
 475  */
 476 void
 477 GNUNET_CRYPTO_hash_context_abort (struct GNUNET_HashContext *hc)
 478 {
 479   gcry_md_close (hc->hd);
 480   GNUNET_free (hc);
 481 }
 482
 483
 484 /* end of crypto_hash.c */