X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Futil%2Fcrypto_hash.c;h=9faa213ae5f6072fdaade63ad4593f01cbb74391;hb=705966df17b43ca8f1481834a80d19cd7cad874b;hp=72dc48399bf7b922337241fa41495e6b865ea44d;hpb=c03a8dc85818b7c22d14a19f6b50fd93b526edbb;p=oweals%2Fgnunet.git diff --git a/src/util/crypto_hash.c b/src/util/crypto_hash.c index 72dc48399..9faa213ae 100644 --- a/src/util/crypto_hash.c +++ b/src/util/crypto_hash.c @@ -36,6 +36,9 @@ #include "gnunet_disk_lib.h" #include +#define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__) + +#define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util", syscall, filename) /** * Hash block of given size. @@ -82,11 +85,6 @@ struct GNUNET_CRYPTO_FileHashContext */ struct GNUNET_DISK_FileHandle *fh; - /** - * Our scheduler. - */ - struct GNUNET_SCHEDULER_Handle *sched; - /** * Cummulated hash. */ @@ -107,6 +105,11 @@ struct GNUNET_CRYPTO_FileHashContext */ GNUNET_SCHEDULER_TaskIdentifier task; + /** + * Priority we use. + */ + enum GNUNET_SCHEDULER_Priority priority; + /** * Blocksize. */ @@ -120,13 +123,14 @@ struct GNUNET_CRYPTO_FileHashContext * and free associated resources. */ static void -file_hash_finish (struct GNUNET_CRYPTO_FileHashContext *fhc, - const GNUNET_HashCode * res) +file_hash_finish (struct GNUNET_CRYPTO_FileHashContext *fhc, + const GNUNET_HashCode * res) { fhc->callback (fhc->callback_cls, res); GNUNET_free (fhc->filename); if (!GNUNET_DISK_handle_invalid (fhc->fh)) GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (fhc->fh)); + gcry_md_close (fhc->md); GNUNET_free (fhc); /* also frees fhc->buffer */ } @@ -145,37 +149,32 @@ file_hash_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) size_t delta; fhc->task = GNUNET_SCHEDULER_NO_TASK; - GNUNET_assert (fhc->offset < fhc->fsize); + GNUNET_assert (fhc->offset <= fhc->fsize); delta = fhc->bsize; if (fhc->fsize - fhc->offset < delta) delta = fhc->fsize - fhc->offset; if (delta != GNUNET_DISK_file_read (fhc->fh, fhc->buffer, delta)) - { - GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, - "read", fhc->filename); - file_hash_finish (fhc, NULL); - return; - } + { + LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "read", fhc->filename); + file_hash_finish (fhc, NULL); + return; + } gcry_md_write (fhc->md, fhc->buffer, delta); fhc->offset += delta; if (fhc->offset == fhc->fsize) - { - res = (GNUNET_HashCode *) gcry_md_read (fhc->md, GCRY_MD_SHA512); - file_hash_finish (fhc, &res); - gcry_md_close (fhc->md); - return; - } - fhc->task - = GNUNET_SCHEDULER_add_after (tc->sched, - GNUNET_SCHEDULER_NO_TASK, - &file_hash_task, fhc); + { + res = (GNUNET_HashCode *) gcry_md_read (fhc->md, GCRY_MD_SHA512); + file_hash_finish (fhc, res); + return; + } + fhc->task = GNUNET_SCHEDULER_add_with_priority (fhc->priority, + &file_hash_task, fhc); } /** * Compute the hash of an entire file. * - * @param sched scheduler to use * @param priority scheduling priority to use * @param filename name of file to hash * @param blocksize number of bytes to process in one task @@ -184,42 +183,45 @@ file_hash_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) * @return NULL on (immediate) errror */ struct GNUNET_CRYPTO_FileHashContext * -GNUNET_CRYPTO_hash_file (struct GNUNET_SCHEDULER_Handle *sched, - enum GNUNET_SCHEDULER_Priority priority, - const char *filename, - size_t blocksize, +GNUNET_CRYPTO_hash_file (enum GNUNET_SCHEDULER_Priority priority, + const char *filename, size_t blocksize, GNUNET_CRYPTO_HashCompletedCallback callback, void *callback_cls) { struct GNUNET_CRYPTO_FileHashContext *fhc; GNUNET_assert (blocksize > 0); - fhc = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_FileHashContext) + blocksize); + fhc = + GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_FileHashContext) + blocksize); fhc->callback = callback; fhc->callback_cls = callback_cls; - fhc->sched = sched; fhc->buffer = (unsigned char *) &fhc[1]; fhc->filename = GNUNET_strdup (filename); - fhc->md = gcry_md_open (&fhc->md, GCRY_MD_SHA512, 0); + if (GPG_ERR_NO_ERROR != gcry_md_open (&fhc->md, GCRY_MD_SHA512, 0)) + { + GNUNET_break (0); + GNUNET_free (fhc); + return NULL; + } fhc->bsize = blocksize; if (GNUNET_OK != GNUNET_DISK_file_size (filename, &fhc->fsize, GNUNET_NO)) - { - GNUNET_free (fhc->filename); - GNUNET_free (fhc); - return NULL; - } - fhc->fh = GNUNET_DISK_file_open (filename, - GNUNET_DISK_OPEN_READ, - GNUNET_DISK_PERM_NONE); + { + GNUNET_free (fhc->filename); + GNUNET_free (fhc); + return NULL; + } + fhc->fh = + GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ, + GNUNET_DISK_PERM_NONE); if (!fhc->fh) - { - GNUNET_free (fhc->filename); - GNUNET_free (fhc); - return NULL; - } - fhc->task - = GNUNET_SCHEDULER_add_with_priority (sched, priority, - &file_hash_task, fhc); + { + GNUNET_free (fhc->filename); + GNUNET_free (fhc); + return NULL; + } + fhc->priority = priority; + fhc->task = + GNUNET_SCHEDULER_add_with_priority (priority, &file_hash_task, fhc); return fhc; } @@ -232,8 +234,7 @@ GNUNET_CRYPTO_hash_file (struct GNUNET_SCHEDULER_Handle *sched, void GNUNET_CRYPTO_hash_file_cancel (struct GNUNET_CRYPTO_FileHashContext *fhc) { - GNUNET_SCHEDULER_cancel (fhc->sched, - fhc->task); + GNUNET_SCHEDULER_cancel (fhc->task); GNUNET_free (fhc->filename); GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (fhc->fh)); GNUNET_free (fhc); @@ -257,7 +258,7 @@ getValue__ (unsigned char a) * Convert GNUNET_CRYPTO_hash to ASCII encoding. The ASCII encoding is rather * GNUnet specific. It was chosen such that it only uses characters * in [0-9A-V], can be produced without complex arithmetics and uses a - * small number of characters. The GNUnet encoding uses 102 + * small number of characters. The GNUnet encoding uses 103 * characters plus a null terminator. * * @param block the hash code @@ -284,23 +285,22 @@ GNUNET_CRYPTO_hash_to_enc (const GNUNET_HashCode * block, rpos = 0; bits = 0; while ((rpos < sizeof (GNUNET_HashCode)) || (vbit > 0)) + { + if ((rpos < sizeof (GNUNET_HashCode)) && (vbit < 5)) { - if ((rpos < sizeof (GNUNET_HashCode)) && (vbit < 5)) - { - bits = (bits << 8) | ((unsigned char *) block)[rpos++]; /* eat 8 more bits */ - vbit += 8; - } - if (vbit < 5) - { - bits <<= (5 - vbit); /* zero-padding */ - GNUNET_assert (vbit == 2); /* padding by 3: 512+3 mod 5 == 0 */ - vbit = 5; - } - GNUNET_assert (wpos < - sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1); - result->encoding[wpos++] = encTable__[(bits >> (vbit - 5)) & 31]; - vbit -= 5; + bits = (bits << 8) | ((unsigned char *) block)[rpos++]; /* eat 8 more bits */ + vbit += 8; } + if (vbit < 5) + { + bits <<= (5 - vbit); /* zero-padding */ + GNUNET_assert (vbit == 2); /* padding by 3: 512+3 mod 5 == 0 */ + vbit = 5; + } + GNUNET_assert (wpos < sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1); + result->encoding[wpos++] = encTable__[(bits >> (vbit - 5)) & 31]; + vbit -= 5; + } GNUNET_assert (wpos == sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1); GNUNET_assert (vbit == 0); result->encoding[wpos] = '\0'; @@ -329,17 +329,17 @@ GNUNET_CRYPTO_hash_from_string (const char *enc, GNUNET_HashCode * result) rpos = sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1; bits = getValue__ (enc[--rpos]) >> 3; while (wpos > 0) + { + GNUNET_assert (rpos > 0); + bits = (getValue__ (enc[--rpos]) << vbit) | bits; + vbit += 5; + if (vbit >= 8) { - GNUNET_assert (rpos > 0); - bits = (getValue__ (enc[--rpos]) << vbit) | bits; - vbit += 5; - if (vbit >= 8) - { - ((unsigned char *) result)[--wpos] = (unsigned char) bits; - bits >>= 8; - vbit -= 8; - } + ((unsigned char *) result)[--wpos] = (unsigned char) bits; + bits >>= 8; + vbit -= 8; } + } GNUNET_assert (rpos == 0); GNUNET_assert (vbit == 0); return GNUNET_OK; @@ -350,7 +350,7 @@ GNUNET_CRYPTO_hash_from_string (const char *enc, GNUNET_HashCode * result) * fast, not involve bits[0] or bits[4] (they're used elsewhere), and be * somewhat consistent. And of course, the result should be a positive * number. - * + * * @param a some hash code * @param b some hash code * @return a positive number which is a measure for @@ -362,6 +362,7 @@ GNUNET_CRYPTO_hash_distance_u32 (const GNUNET_HashCode * a, { unsigned int x1 = (a->bits[1] - b->bits[1]) >> 16; unsigned int x2 = (b->bits[1] - a->bits[1]) >> 16; + return (x1 * x2); } @@ -370,6 +371,7 @@ GNUNET_CRYPTO_hash_create_random (enum GNUNET_CRYPTO_Quality mode, GNUNET_HashCode * result) { int i; + for (i = (sizeof (GNUNET_HashCode) / sizeof (uint32_t)) - 1; i >= 0; i--) result->bits[i] = GNUNET_CRYPTO_random_u32 (mode, UINT32_MAX); } @@ -380,51 +382,52 @@ GNUNET_CRYPTO_hash_difference (const GNUNET_HashCode * a, GNUNET_HashCode * result) { int i; - for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; - i--) + + for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; i--) result->bits[i] = b->bits[i] - a->bits[i]; } void GNUNET_CRYPTO_hash_sum (const GNUNET_HashCode * a, - const GNUNET_HashCode * delta, - GNUNET_HashCode * result) + const GNUNET_HashCode * delta, GNUNET_HashCode * result) { int i; - for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; - i--) + + for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; i--) result->bits[i] = delta->bits[i] + a->bits[i]; } + void -GNUNET_CRYPTO_hash_xor (const GNUNET_HashCode * a, - const GNUNET_HashCode * b, GNUNET_HashCode * result) +GNUNET_CRYPTO_hash_xor (const GNUNET_HashCode * a, const GNUNET_HashCode * b, + GNUNET_HashCode * result) { int i; - for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; - i--) + + for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; i--) result->bits[i] = a->bits[i] ^ b->bits[i]; } + /** * Convert a hashcode into a key. */ void GNUNET_CRYPTO_hash_to_aes_key (const GNUNET_HashCode * hc, struct GNUNET_CRYPTO_AesSessionKey *skey, - struct GNUNET_CRYPTO_AesInitializationVector - *iv) + struct GNUNET_CRYPTO_AesInitializationVector *iv) { GNUNET_assert (sizeof (GNUNET_HashCode) >= GNUNET_CRYPTO_AES_KEY_LENGTH + sizeof (struct GNUNET_CRYPTO_AesInitializationVector)); memcpy (skey, hc, GNUNET_CRYPTO_AES_KEY_LENGTH); skey->crc32 = - htonl (GNUNET_CRYPTO_crc32_n (skey, GNUNET_CRYPTO_AES_KEY_LENGTH)); + htonl (GNUNET_CRYPTO_crc32_n (skey, GNUNET_CRYPTO_AES_KEY_LENGTH)); memcpy (iv, &((char *) hc)[GNUNET_CRYPTO_AES_KEY_LENGTH], sizeof (struct GNUNET_CRYPTO_AesInitializationVector)); } + /** * Obtain a bit from a hashcode. * @param code the GNUNET_CRYPTO_hash to index bit-wise @@ -450,24 +453,27 @@ GNUNET_CRYPTO_hash_get_bit (const GNUNET_HashCode * code, unsigned int bit) * * @return the number of bits that match */ -unsigned int GNUNET_CRYPTO_hash_matching_bits(const GNUNET_HashCode *first, const GNUNET_HashCode *second) +unsigned int +GNUNET_CRYPTO_hash_matching_bits (const GNUNET_HashCode * first, + const GNUNET_HashCode * second) { unsigned int i; for (i = 0; i < sizeof (GNUNET_HashCode) * 8; i++) - if (GNUNET_CRYPTO_hash_get_bit (first, i) != GNUNET_CRYPTO_hash_get_bit (second, i)) + if (GNUNET_CRYPTO_hash_get_bit (first, i) != + GNUNET_CRYPTO_hash_get_bit (second, i)) return i; return sizeof (GNUNET_HashCode) * 8; } + /** * Compare function for HashCodes, producing a total ordering * of all hashcodes. * @return 1 if h1 > h2, -1 if h1 < h2 and 0 if h1 == h2. */ int -GNUNET_CRYPTO_hash_cmp (const GNUNET_HashCode * h1, - const GNUNET_HashCode * h2) +GNUNET_CRYPTO_hash_cmp (const GNUNET_HashCode * h1, const GNUNET_HashCode * h2) { unsigned int *i1; unsigned int *i2; @@ -475,17 +481,17 @@ GNUNET_CRYPTO_hash_cmp (const GNUNET_HashCode * h1, i1 = (unsigned int *) h1; i2 = (unsigned int *) h2; - for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; - i--) - { - if (i1[i] > i2[i]) - return 1; - if (i1[i] < i2[i]) - return -1; - } + for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; i--) + { + if (i1[i] > i2[i]) + return 1; + if (i1[i] < i2[i]) + return -1; + } return 0; } + /** * Find out which of the two GNUNET_CRYPTO_hash codes is closer to target * in the XOR metric (Kademlia). @@ -501,14 +507,14 @@ GNUNET_CRYPTO_hash_xorcmp (const GNUNET_HashCode * h1, unsigned int d2; for (i = sizeof (GNUNET_HashCode) / sizeof (unsigned int) - 1; i >= 0; i--) - { - d1 = ((unsigned int *) h1)[i] ^ ((unsigned int *) target)[i]; - d2 = ((unsigned int *) h2)[i] ^ ((unsigned int *) target)[i]; - if (d1 > d2) - return 1; - else if (d1 < d2) - return -1; - } + { + d1 = ((unsigned int *) h1)[i] ^ ((unsigned int *) target)[i]; + d2 = ((unsigned int *) h2)[i] ^ ((unsigned int *) target)[i]; + if (d1 > d2) + return 1; + else if (d1 < d2) + return -1; + } return 0; } @@ -522,11 +528,9 @@ GNUNET_CRYPTO_hash_xorcmp (const GNUNET_HashCode * h1, * @param ... pair of void * & size_t for context chunks, terminated by NULL */ void -GNUNET_CRYPTO_hmac_derive_key(struct GNUNET_CRYPTO_AuthKey *key, - const struct GNUNET_CRYPTO_AesSessionKey *rkey, - const void *salt, - const size_t salt_len, - ...) +GNUNET_CRYPTO_hmac_derive_key (struct GNUNET_CRYPTO_AuthKey *key, + const struct GNUNET_CRYPTO_AesSessionKey *rkey, + const void *salt, size_t salt_len, ...) { va_list argp; @@ -545,16 +549,16 @@ GNUNET_CRYPTO_hmac_derive_key(struct GNUNET_CRYPTO_AuthKey *key, * @param argp pair of void * & size_t for context chunks, terminated by NULL */ void -GNUNET_CRYPTO_hmac_derive_key_v(struct GNUNET_CRYPTO_AuthKey *key, - const struct GNUNET_CRYPTO_AesSessionKey *rkey, - const void *salt, - const size_t salt_len, - va_list argp) +GNUNET_CRYPTO_hmac_derive_key_v (struct GNUNET_CRYPTO_AuthKey *key, + const struct GNUNET_CRYPTO_AesSessionKey *rkey, + const void *salt, size_t salt_len, + va_list argp) { - GNUNET_CRYPTO_kdf_v (key->key, sizeof(key->key), salt, salt_len, rkey->key, - sizeof(rkey->key), argp); + GNUNET_CRYPTO_kdf_v (key->key, sizeof (key->key), salt, salt_len, rkey->key, + sizeof (rkey->key), argp); } + /** * Calculate HMAC of a message (RFC 2104) * @@ -563,21 +567,21 @@ GNUNET_CRYPTO_hmac_derive_key_v(struct GNUNET_CRYPTO_AuthKey *key, * @param plaintext_len length of plaintext * @param hmac where to store the hmac */ -void +void GNUNET_CRYPTO_hmac (const struct GNUNET_CRYPTO_AuthKey *key, - const void *plaintext, - size_t plaintext_len, - GNUNET_HashCode *hmac) + const void *plaintext, size_t plaintext_len, + GNUNET_HashCode * hmac) { gcry_md_hd_t md; - unsigned char *mc; + const unsigned char *mc; - md = gcry_md_open (&md, GCRY_MD_SHA512, GCRY_MD_FLAG_HMAC); - gcry_md_setkey (md, key->key, sizeof(key->key)); + GNUNET_assert (GPG_ERR_NO_ERROR == + gcry_md_open (&md, GCRY_MD_SHA512, GCRY_MD_FLAG_HMAC)); + gcry_md_setkey (md, key->key, sizeof (key->key)); gcry_md_write (md, plaintext, plaintext_len); mc = gcry_md_read (md, GCRY_MD_SHA512); if (mc != NULL) - memcpy (hmac->bits, mc, sizeof(hmac->bits)); + memcpy (hmac->bits, mc, sizeof (hmac->bits)); gcry_md_close (md); }