crypto_hash.c

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2001-2013 GNUnet e.V.

     GNUnet is free software: you can redistribute it and/or modify it
     under the terms of the GNU Affero General Public License as published
     by the Free Software Foundation, either version 3 of the License,
     or (at your option) any later version.

     GNUnet is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Affero General Public License for more details.

     You should have received a copy of the GNU Affero General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.

     SPDX-License-Identifier: AGPL3.0-or-later

 */
#include "platform.h"
#include "gnunet_crypto_lib.h"
#include "gnunet_strings_lib.h"
#include "benchmark.h"
#include <gcrypt.h>

#define LOG(kind, ...) GNUNET_log_from(kind, "util-crypto-hash", __VA_ARGS__)

#define LOG_STRERROR_FILE(kind, syscall, filename) GNUNET_log_from_strerror_file(kind, "util-crypto-hash", syscall, filename)

void
GNUNET_CRYPTO_hash(const void *block,
                   size_t size,
                   struct GNUNET_HashCode *ret)
{
  BENCHMARK_START(hash);
  gcry_md_hash_buffer(GCRY_MD_SHA512, ret, block, size);
  BENCHMARK_END(hash);
}


/* ***************** binary-ASCII encoding *************** */


void
GNUNET_CRYPTO_hash_to_enc(const struct GNUNET_HashCode *block,
                          struct GNUNET_CRYPTO_HashAsciiEncoded *result)
{
  char *np;

  np = GNUNET_STRINGS_data_to_string((const unsigned char *)block,
                                     sizeof(struct GNUNET_HashCode),
                                     (char *)result,
                                     sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) - 1);
  GNUNET_assert(NULL != np);
  *np = '\0';
}


int
GNUNET_CRYPTO_hash_from_string2(const char *enc,
                                size_t enclen,
                                struct GNUNET_HashCode *result)
{
  char upper_enc[enclen];
  char *up_ptr = upper_enc;

  GNUNET_STRINGS_utf8_toupper(enc, up_ptr);

  return GNUNET_STRINGS_string_to_data(upper_enc, enclen,
                                       (unsigned char*)result,
                                       sizeof(struct GNUNET_HashCode));
}


unsigned int
GNUNET_CRYPTO_hash_distance_u32(const struct GNUNET_HashCode *a,
                                const struct GNUNET_HashCode *b)
{
  unsigned int x1 = (a->bits[1] - b->bits[1]) >> 16;
  unsigned int x2 = (b->bits[1] - a->bits[1]) >> 16;

  return(x1 * x2);
}


void
GNUNET_CRYPTO_hash_create_random(enum GNUNET_CRYPTO_Quality mode,
                                 struct GNUNET_HashCode *result)
{
  int i;

  for (i = (sizeof(struct GNUNET_HashCode) / sizeof(uint32_t)) - 1; i >= 0; i--)
    result->bits[i] = GNUNET_CRYPTO_random_u32(mode, UINT32_MAX);
}


void
GNUNET_CRYPTO_hash_difference(const struct GNUNET_HashCode *a,
                              const struct GNUNET_HashCode *b,
                              struct GNUNET_HashCode *result)
{
  int i;

  for (i = (sizeof(struct GNUNET_HashCode) / sizeof(unsigned int)) - 1; i >= 0; i--)
    result->bits[i] = b->bits[i] - a->bits[i];
}


void
GNUNET_CRYPTO_hash_sum(const struct GNUNET_HashCode * a,
                       const struct GNUNET_HashCode * delta, struct GNUNET_HashCode * result)
{
  int i;

  for (i = (sizeof(struct GNUNET_HashCode) / sizeof(unsigned int)) - 1; i >= 0; i--)
    result->bits[i] = delta->bits[i] + a->bits[i];
}


void
GNUNET_CRYPTO_hash_xor(const struct GNUNET_HashCode *a,
                       const struct GNUNET_HashCode *b,
                       struct GNUNET_HashCode *result)
{
  int i;

  for (i = (sizeof(struct GNUNET_HashCode) / sizeof(unsigned int)) - 1; i >= 0; i--)
    result->bits[i] = a->bits[i] ^ b->bits[i];
}


void
GNUNET_CRYPTO_hash_to_aes_key(const struct GNUNET_HashCode *hc,
                              struct GNUNET_CRYPTO_SymmetricSessionKey *skey,
                              struct GNUNET_CRYPTO_SymmetricInitializationVector *iv)
{
  GNUNET_assert(GNUNET_YES ==
                GNUNET_CRYPTO_kdf(skey, sizeof(struct GNUNET_CRYPTO_SymmetricSessionKey),
                                  "Hash key derivation", strlen("Hash key derivation"),
                                  hc, sizeof(struct GNUNET_HashCode),
                                  NULL, 0));
  GNUNET_assert(GNUNET_YES ==
                GNUNET_CRYPTO_kdf(iv, sizeof(struct GNUNET_CRYPTO_SymmetricInitializationVector),
                                  "Initialization vector derivation", strlen("Initialization vector derivation"),
                                  hc, sizeof(struct GNUNET_HashCode),
                                  NULL, 0));
}


int
GNUNET_CRYPTO_hash_get_bit(const struct GNUNET_HashCode * code, unsigned int bit)
{
  GNUNET_assert(bit < 8 * sizeof(struct GNUNET_HashCode));
  return (((unsigned char *)code)[bit >> 3] & (1 << (bit & 7))) > 0;
}


unsigned int
GNUNET_CRYPTO_hash_matching_bits(const struct GNUNET_HashCode * first,
                                 const struct GNUNET_HashCode * second)
{
  unsigned int i;

  for (i = 0; i < sizeof(struct GNUNET_HashCode) * 8; i++)
    if (GNUNET_CRYPTO_hash_get_bit(first, i) !=
        GNUNET_CRYPTO_hash_get_bit(second, i))
      return i;
  return sizeof(struct GNUNET_HashCode) * 8;
}


int
GNUNET_CRYPTO_hash_cmp(const struct GNUNET_HashCode *h1,
                       const struct GNUNET_HashCode *h2)
{
  unsigned int *i1;
  unsigned int *i2;
  int i;

  i1 = (unsigned int *)h1;
  i2 = (unsigned int *)h2;
  for (i = (sizeof(struct 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;
}


int
GNUNET_CRYPTO_hash_xorcmp(const struct GNUNET_HashCode *h1,
                          const struct GNUNET_HashCode *h2,
                          const struct GNUNET_HashCode *target)
{
  int i;
  unsigned int d1;
  unsigned int d2;

  for (i = sizeof(struct 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;
    }
  return 0;
}


void
GNUNET_CRYPTO_hmac_derive_key(struct GNUNET_CRYPTO_AuthKey *key,
                              const struct GNUNET_CRYPTO_SymmetricSessionKey *rkey,
                              const void *salt, size_t salt_len, ...)
{
  va_list argp;

  va_start(argp, salt_len);
  GNUNET_CRYPTO_hmac_derive_key_v(key, rkey, salt, salt_len, argp);
  va_end(argp);
}


void
GNUNET_CRYPTO_hmac_derive_key_v(struct GNUNET_CRYPTO_AuthKey *key,
                                const struct GNUNET_CRYPTO_SymmetricSessionKey *rkey,
                                const void *salt, size_t salt_len,
                                va_list argp)
{
  GNUNET_CRYPTO_kdf_v(key->key, sizeof(key->key),
                      salt, salt_len,
                      rkey, sizeof(struct GNUNET_CRYPTO_SymmetricSessionKey),
                      argp);
}


void
GNUNET_CRYPTO_hmac_raw(const void *key, size_t key_len,
                       const void *plaintext, size_t plaintext_len,
                       struct GNUNET_HashCode *hmac)
{
  static int once;
  static gcry_md_hd_t md;
  const unsigned char *mc;

  if (!once)
    {
      once = 1;
      GNUNET_assert(GPG_ERR_NO_ERROR ==
                    gcry_md_open(&md, GCRY_MD_SHA512, GCRY_MD_FLAG_HMAC));
    }
  else
    {
      gcry_md_reset(md);
    }
  gcry_md_setkey(md, key, key_len);
  gcry_md_write(md, plaintext, plaintext_len);
  mc = gcry_md_read(md, GCRY_MD_SHA512);
  GNUNET_assert(NULL != mc);
  GNUNET_memcpy(hmac->bits, mc, sizeof(hmac->bits));
}


void
GNUNET_CRYPTO_hmac(const struct GNUNET_CRYPTO_AuthKey *key,
                   const void *plaintext, size_t plaintext_len,
                   struct GNUNET_HashCode *hmac)
{
  GNUNET_CRYPTO_hmac_raw((void*)key->key, sizeof(key->key),
                         plaintext, plaintext_len,
                         hmac);
}


struct GNUNET_HashContext {
  gcry_md_hd_t hd;
};


struct GNUNET_HashContext *
GNUNET_CRYPTO_hash_context_start()
{
  struct GNUNET_HashContext *hc;

  BENCHMARK_START(hash_context_start);

  hc = GNUNET_new(struct GNUNET_HashContext);
  GNUNET_assert(0 ==
                gcry_md_open(&hc->hd,
                             GCRY_MD_SHA512,
                             0));

  BENCHMARK_END(hash_context_start);

  return hc;
}


void
GNUNET_CRYPTO_hash_context_read(struct GNUNET_HashContext *hc,
                                const void *buf,
                                size_t size)
{
  BENCHMARK_START(hash_context_read);
  gcry_md_write(hc->hd, buf, size);
  BENCHMARK_END(hash_context_read);
}


void
GNUNET_CRYPTO_hash_context_finish(struct GNUNET_HashContext *hc,
                                  struct GNUNET_HashCode *r_hash)
{
  const void *res = gcry_md_read(hc->hd, 0);

  BENCHMARK_START(hash_context_finish);

  GNUNET_assert(NULL != res);
  if (NULL != r_hash)
    GNUNET_memcpy(r_hash,
                  res,
                  sizeof(struct GNUNET_HashCode));
  GNUNET_CRYPTO_hash_context_abort(hc);
  BENCHMARK_END(hash_context_finish);
}


void
GNUNET_CRYPTO_hash_context_abort(struct GNUNET_HashContext *hc)
{
  gcry_md_close(hc->hd);
  GNUNET_free(hc);
}


/* end of crypto_hash.c */