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_util_lib.h"
#include "benchmark.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);
  crypto_hash_sha512 ((unsigned char*) 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';
}
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hash_from_string2 (const char *enc,
                                 size_t enclen,
                                 struct GNUNET_HashCode *result)
{
  enum GNUNET_GenericReturnValue ret;
  char *up_ptr;
 
  up_ptr = GNUNET_STRINGS_utf8_toupper (enc);
  if (NULL == up_ptr)
    return GNUNET_SYSERR;
  ret = GNUNET_STRINGS_string_to_data (up_ptr,
                                       strlen (up_ptr),
                                       (unsigned char *) result,
                                       sizeof(struct GNUNET_HashCode));
  GNUNET_free (up_ptr);
  return ret;
}
 
 
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_difference (const struct GNUNET_HashCode *a,
                               const struct GNUNET_HashCode *b,
                               struct GNUNET_HashCode *result)
{
  for (ssize_t 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)
{
  for (ssize_t 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)
{
  const unsigned long long *lla = (const unsigned long long *) a;
  const unsigned long long *llb = (const unsigned long long *) b;
  unsigned long long *llr = (unsigned long long *) result;
 
  GNUNET_static_assert (8 == sizeof (unsigned long long));
  GNUNET_static_assert (0 == sizeof (*a) % sizeof (unsigned long long));
 
  for (int i = sizeof (*result) / sizeof (*llr) - 1; i>=0; i--)
    llr[i] = lla[i] ^ llb[i];
}
 
 
unsigned int
GNUNET_CRYPTO_hash_count_leading_zeros (const struct GNUNET_HashCode *h)
{
  const unsigned long long *llp = (const unsigned long long *) h;
  unsigned int ret = 0;
  unsigned int i;
 
  GNUNET_static_assert (8 == sizeof (unsigned long long));
  GNUNET_static_assert (0 == sizeof (*h) % sizeof (unsigned long long));
  for (i = 0; i<sizeof (*h) / sizeof (*llp); i++)
  {
    if (0LLU != llp[i])
      break;
    ret += sizeof (*llp) * 8;
  }
  if (ret == 8 * sizeof (*h))
    return ret;
  ret += __builtin_clzll (GNUNET_ntohll ((uint64_t) llp[i]));
  return ret;
}
 
 
unsigned int
GNUNET_CRYPTO_hash_count_tailing_zeros (const struct GNUNET_HashCode *h)
{
  const unsigned long long *llp = (const unsigned long long *) h;
  unsigned int ret = 0;
  int i;
 
  GNUNET_static_assert (8 == sizeof (unsigned long long));
  GNUNET_static_assert (0 == sizeof (*h) % sizeof (unsigned long long));
  for (i = sizeof (*h) / sizeof (*llp) - 1; i>=0; i--)
  {
    if (0LLU != llp[i])
      break;
    ret += sizeof (*llp) * 8;
  }
  if (ret == 8 * sizeof (*h))
    return ret;
  ret += __builtin_ctzll (GNUNET_ntohll ((uint64_t) llp[i]));
  return ret;
}
 
 
int
GNUNET_CRYPTO_hash_cmp (const struct GNUNET_HashCode *h1,
                        const struct GNUNET_HashCode *h2)
{
  unsigned int *i1;
  unsigned int *i2;
 
  i1 = (unsigned int *) h1;
  i2 = (unsigned int *) h2;
  for (ssize_t 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)
{
  const unsigned long long *l1 = (const unsigned long long *) h1;
  const unsigned long long *l2 = (const unsigned long long *) h2;
  const unsigned long long *t = (const unsigned long long *) target;
 
  GNUNET_static_assert (0 == sizeof (*h1) % sizeof (*l1));
  for (size_t i = 0; i < sizeof(*h1) / sizeof(*l1); i++)
  {
    unsigned long long x1 = l1[i] ^ t[i];
    unsigned long long x2 = l2[i] ^ t[i];
 
    if (x1 > x2)
      return 1;
    if (x1 < x2)
      return -1;
  }
  return 0;
}
 
 
void
GNUNET_CRYPTO_hmac_raw (const unsigned char *key,
                        unsigned int keylen,
                        const void *plaintext,
                        size_t plaintext_len,
                        struct GNUNET_HashCode *hmac)
{
  crypto_auth_hmacsha512_state state;
  crypto_auth_hmacsha512_init (&state,
                               key,
                               keylen);
  crypto_auth_hmacsha512_update (&state,
                                 plaintext,
                                 plaintext_len);
  crypto_auth_hmacsha512_final (&state,
                                (unsigned char*) hmac);
}
 
 
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 ((unsigned char*) key,
                          sizeof *key,
                          plaintext,
                          plaintext_len,
                          hmac);
}
 
 
struct GNUNET_HashContext
{
  crypto_hash_sha512_state hd;
};
 
 
struct GNUNET_HashContext *
GNUNET_CRYPTO_hash_context_start ()
{
  struct GNUNET_HashContext *hc;
 
  BENCHMARK_START (hash_context_start);
  hc = GNUNET_new (struct GNUNET_HashContext);
  crypto_hash_sha512_init (&hc->hd);
  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);
  crypto_hash_sha512_update (&hc->hd,
                             buf,
                             size);
  BENCHMARK_END (hash_context_read);
}
 
 
struct GNUNET_HashContext *
GNUNET_CRYPTO_hash_context_copy (const struct GNUNET_HashContext *hc)
{
  struct GNUNET_HashContext *cp;
 
  cp = GNUNET_new (struct GNUNET_HashContext);
  GNUNET_memcpy (cp, hc, sizeof *hc);
  return cp;
}
 
 
void
GNUNET_CRYPTO_hash_context_finish (struct GNUNET_HashContext *hc,
                                   struct GNUNET_HashCode *r_hash)
{
  BENCHMARK_START (hash_context_finish);
 
  crypto_hash_sha512_final (&hc->hd,
                            (unsigned char*) r_hash);
  GNUNET_CRYPTO_hash_context_abort (hc);
  BENCHMARK_END (hash_context_finish);
}
 
 
void
GNUNET_CRYPTO_hash_context_abort (struct GNUNET_HashContext *hc)
{
  GNUNET_free (hc);
}
 
 
/* end of crypto_hash.c */