Beispiel #1
0
	hasher512& hasher512::operator=(hasher512 const& h) &
	{
		if (this == &h) return *this;
		gcry_md_close(m_context);
		gcry_md_copy(&m_context, h.m_context);
		return *this;
	}
Beispiel #2
0
	hasher& hasher::operator=(hasher const& h)
	{
		if (this == &h) return;
		gcry_md_close(m_context);
		gcry_md_copy(&m_context, h.m_context);
		return *this;
	}
Beispiel #3
0
/* deterministically generate from seed/idx a string of buflen pseudorandom bytes */
static void det_randomize(void *buf, size_t buflen, const void *seed, size_t seedlen, uint32_t idx) {
        gcry_md_hd_t hd, hd2;
        size_t olen, cpylen;
        uint32_t ctr;

        olen = gcry_md_get_algo_dlen(RND_HASH);
        gcry_md_open(&hd, RND_HASH, 0);
        gcry_md_write(hd, seed, seedlen);
        gcry_md_putc(hd, (idx >> 24) & 0xff);
        gcry_md_putc(hd, (idx >> 16) & 0xff);
        gcry_md_putc(hd, (idx >>  8) & 0xff);
        gcry_md_putc(hd, (idx >>  0) & 0xff);

        for (ctr = 0; buflen; ctr++) {
                gcry_md_copy(&hd2, hd);
                gcry_md_putc(hd2, (ctr >> 24) & 0xff);
                gcry_md_putc(hd2, (ctr >> 16) & 0xff);
                gcry_md_putc(hd2, (ctr >>  8) & 0xff);
                gcry_md_putc(hd2, (ctr >>  0) & 0xff);
                gcry_md_final(hd2);
                cpylen = (buflen < olen) ? buflen : olen;
                memcpy(buf, gcry_md_read(hd2, RND_HASH), cpylen);
                gcry_md_close(hd2);
                buf += cpylen;
                buflen -= cpylen;
        }
        gcry_md_close(hd);
}
Beispiel #4
0
static void
check_one_md (int algo, char *data, int len, char *expect)
{
  gcry_md_hd_t hd, hd2;
  unsigned char *p;
  int mdlen;
  int i;
  gcry_error_t err = 0;

  err = gcry_md_open (&hd, algo, 0);
  if (err)
    {
      fail ("algo %d, grcy_md_open failed: %s\n", algo, gpg_strerror (err));
      return;
    }

  mdlen = gcry_md_get_algo_dlen (algo);
  if (mdlen < 1 || mdlen > 500)
    {
      fail ("algo %d, grcy_md_get_algo_dlen failed: %d\n", algo, mdlen);
      return;
    }

  if (*data == '!' && !data[1])
    {				/* hash one million times a "a" */
      char aaa[1000];

      memset (aaa, 'a', 1000);
      for (i = 0; i < 1000; i++)
	gcry_md_write (hd, aaa, 1000);
    }
  else
    gcry_md_write (hd, data, len);

  err = gcry_md_copy (&hd2, hd);
  if (err)
    {
      fail ("algo %d, gcry_md_copy failed: %s\n", algo, gpg_strerror (err));
    }

  gcry_md_close (hd);

  p = gcry_md_read (hd2, algo);

  if (memcmp (p, expect, mdlen))
    {
      printf ("computed: ");
      for (i = 0; i < mdlen; i++)
	printf ("%02x ", p[i] & 0xFF);
      printf ("\nexpected: ");
      for (i = 0; i < mdlen; i++)
	printf ("%02x ", expect[i] & 0xFF);
      printf ("\n");

      fail ("algo %d, digest mismatch\n", algo);
    }

  gcry_md_close (hd2);
}
Beispiel #5
0
Datei: md.c Projekt: dun/munge
static int
_md_copy (md_ctx *xdst, md_ctx *xsrc)
{
    gcry_error_t e;

    if ((e = gcry_md_copy (&(xdst->ctx), xsrc->ctx)) != 0) {
        log_msg (LOG_DEBUG, "gcry_md_copy failed: %s", gcry_strerror (e));
        return (-1);
    }
    return (0);
}
Beispiel #6
0
Datei: kex.c Projekt: gpg/gsti
/* Hmm. We need to have a new_kex structure so that the old
   kex data can be used until we have send the NEWKEYs msg
   Well, doesn't matter for now. */
static gsti_bstr_t
construct_one_key (gsti_ctx_t ctx, gcry_md_hd_t md1, int algo,
		   const byte * letter, size_t size)
{
  gsti_error_t err;
  gsti_bstr_t hash;
  gcry_md_hd_t md;
  size_t n, n1;

  if (gcry_md_copy (&md, md1))
    abort ();
  err = gsti_bstr_make (&hash, NULL, size);
  if (err)
    {
      gcry_md_close (md);
      return NULL;
    }
  gcry_md_write (md, letter, 1);
  gcry_md_write (md, gsti_bstr_data (ctx->session_id),
		 gsti_bstr_length (ctx->session_id));
  n = gcry_md_get_algo_dlen (algo);
  if (n > size)
    n = size;
  memcpy (gsti_bstr_data (hash), gcry_md_read (md, algo), n);
  while (n < size)
    {
      gcry_md_close (md);
      if (gcry_md_copy (&md, md1))
	abort ();	/* Fixme: add an error return to this fucntion. */
      gcry_md_write (md, gsti_bstr_data (hash), n);
      n1 = gcry_md_get_algo_dlen (algo);
      if (n1 > size - n)
	n1 = size - n;
      memcpy (gsti_bstr_data (hash) + n, gcry_md_read (md, algo), n1);
      n += n1;
    }
  gcry_md_close (md);

  return hash;
}
Beispiel #7
0
static int hmac_clone(lua_State *L)
{
  HANDLER_HMAC *c = hmac_pget(L, 1);
  HANDLER_HMAC *d = hmac_pnew(L);
  
#if CRYPTO_OPENSSL 
  *d = *c;
#elif CRYPTO_GCRYPT
  gcry_md_copy(d, *c);
#endif
  
  return 1;
}
Beispiel #8
0
static int evp_clone(lua_State *L)
{
  HANDLER_EVP *c = evp_pget(L, 1);
  HANDLER_EVP *d = evp_pnew(L);

#if CRYPTO_OPENSSL
  EVP_MD_CTX_init(d);
  EVP_MD_CTX_copy_ex(d, c);
#elif CRYPTO_GCRYPT
  gcry_md_copy(d, *c);
#endif

  return 1;
}
Beispiel #9
0
static int evp_digest(lua_State *L) 
{
  HANDLER_EVP *c = evp_pget(L, 1);
#if CRYPTO_OPENSSL
  HANDLER_EVP *d = NULL;
  unsigned char digest[EVP_MAX_MD_SIZE];
#elif CRYPTO_GCRYPT
  HANDLER_EVP d = NULL;
  unsigned char *digest;
  int algo;
#endif
  size_t written = 0;
  
  if (lua_isstring(L, 2))
  {  
    size_t s_len;
    const char *s = luaL_checklstring(L, 2, &s_len);
    EVP_UPDATE(c, s, s_len);
  }

#if CRYPTO_OPENSSL  
  d = EVP_MD_CTX_create();
  EVP_MD_CTX_copy_ex(d, c);
  EVP_DigestFinal_ex(d, digest, &written);
  EVP_MD_CTX_destroy(d);
#elif CRYPTO_GCRYPT
  algo = gcry_md_get_algo(*c);
  gcry_md_copy(&d, *c);
  gcry_md_final(d);
  digest = gcry_md_read(d, algo);
  written = gcry_md_get_algo_dlen(algo);
#endif
  
  if (lua_toboolean(L, 3))
    lua_pushlstring(L, (char *)digest, written);
  else
  {
    char *hex = bin2hex(digest, written);
    lua_pushlstring(L, hex, written*2);
    free(hex);
  }

#if CRYPTO_GCRYPT
  gcry_md_close(d);
#endif
  
  return 1;
}
Beispiel #10
0
static int hmac_digest(lua_State *L)
{
  HANDLER_HMAC *c = hmac_pget(L, 1);
  size_t written = 0;
#if CRYPTO_OPENSSL
  unsigned char digest[EVP_MAX_MD_SIZE];
#elif CRYPTO_GCRYPT
  HANDLER_HMAC d;
  unsigned char *digest;
  int algo;
#endif

  if (lua_isstring(L, 2))
  {
    size_t s_len;
    const char *s = luaL_checklstring(L, 2, &s_len);
    HMAC_UPDATE(c, s, s_len);
  }

#if CRYPTO_OPENSSL
  HMAC_Final(c, digest, &written);
#elif CRYPTO_GCRYPT
  algo = gcry_md_get_algo(*c);
  gcry_md_copy(&d, *c);
  gcry_md_final(d);
  digest = gcry_md_read(d, algo);
  written = gcry_md_get_algo_dlen(algo);
#endif

  if (lua_toboolean(L, 3))
    lua_pushlstring(L, (char *)digest, written);
  else
  {
    char *hex = bin2hex(digest, written);
    lua_pushlstring(L, hex, written*2);
    free(hex);
  }

#if CRYPTO_GCRYPT
  gcry_md_close(d);
#endif

  return 1;
}
Beispiel #11
0
Gc_rc
gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle)
{
    _gc_hash_ctx *in = handle;
    _gc_hash_ctx *out;
    int err;

    *outhandle = out = calloc (sizeof (*out), 1);
    if (!out)
        return GC_MALLOC_ERROR;

    memcpy (out, in, sizeof (*out));

    err = gcry_md_copy (&out->gch, in->gch);
    if (err)
    {
        free (out);
        return GC_INVALID_HASH;
    }

    return GC_OK;
}
Beispiel #12
0
/**
 * ntfs_desx_key_expand - expand a 128-bit desx key to the needed 192-bit key
 * @src:	source buffer containing 128-bit key
 *
 * Expands the on-disk 128-bit desx key to the needed des key, the in-, and the
 * out-whitening keys required to perform desx {de,en}cryption.
 */
static gcry_error_t ntfs_desx_key_expand(const u8 *src, u32 *des_key,
        u64 *out_whitening, u64 *in_whitening)
{
    static const u8 *salt1 = (const u8*)"Dan Simon  ";
    static const u8 *salt2 = (const u8*)"Scott Field";
    static const int salt_len = 12;
    gcry_md_hd_t hd1, hd2;
    u32 *md;
    gcry_error_t err;

    err = gcry_md_open(&hd1, GCRY_MD_MD5, 0);
    if (err != GPG_ERR_NO_ERROR) {
        ntfs_log_error("Failed to open MD5 digest.\n");
        return err;
    }
    /* Hash the on-disk key. */
    gcry_md_write(hd1, src, 128 / 8);
    /* Copy the current hash for efficiency. */
    err = gcry_md_copy(&hd2, hd1);
    if (err != GPG_ERR_NO_ERROR) {
        ntfs_log_error("Failed to copy MD5 digest object.\n");
        goto out;
    }
    /* Hash with the first salt and store the result. */
    gcry_md_write(hd1, salt1, salt_len);
    md = (u32*)gcry_md_read(hd1, 0);
    des_key[0] = md[0] ^ md[1];
    des_key[1] = md[2] ^ md[3];
    /* Hash with the second salt and store the result. */
    gcry_md_write(hd2, salt2, salt_len);
    md = (u32*)gcry_md_read(hd2, 0);
    *out_whitening = *(u64*)md;
    *in_whitening = *(u64*)(md + 2);
    gcry_md_close(hd2);
out:
    gcry_md_close(hd1);
    return err;
}
Beispiel #13
0
static int
wrap_gcry_md_copy (void **bhd, void *ahd)
{
  return gcry_md_copy ((gcry_md_hd_t *) bhd, (gcry_md_hd_t) ahd);
}
Beispiel #14
0
	hasher512::hasher512(hasher512 const& h)
	{
		gcry_md_copy(&m_context, h.m_context);
	}
Beispiel #15
0
static void
run_longtest (int algo, int gigs)
{
  gpg_error_t err;
  gcry_md_hd_t hd;
  gcry_md_hd_t hd_pre = NULL;
  gcry_md_hd_t hd_pre2 = NULL;
  gcry_md_hd_t hd_post = NULL;
  gcry_md_hd_t hd_post2 = NULL;
  char pattern[1024];
  int i, g;
  const unsigned char *digest;
  unsigned int digestlen;

  memset (pattern, 'a', sizeof pattern);

  err = gcry_md_open (&hd, algo, 0);
  if (err)
    {
      fail ("gcry_md_open failed for %s (%d): %s",
            gcry_md_algo_name (algo), algo, gpg_strerror (err));
      return;
    }

  digestlen = gcry_md_get_algo_dlen (algo);


  for (g=0; g < gigs; g++)
    {
      if (g == gigs - 1)
        {
          for (i = 0; i < 1024*1023; i++)
            gcry_md_write (hd, pattern, sizeof pattern);
          for (i = 0; i < 1023; i++)
            gcry_md_write (hd, pattern, sizeof pattern);
          err = gcry_md_copy (&hd_pre, hd);
          if (!err)
            err = gcry_md_copy (&hd_pre2, hd);
          if (err)
            die ("gcry_md_copy failed for %s (%d): %s",
                 gcry_md_algo_name (algo), algo, gpg_strerror (err));
          gcry_md_write (hd, pattern, sizeof pattern);
        }
      else
        {
          for (i = 0; i < 1024*1024; i++)
            gcry_md_write (hd, pattern, sizeof pattern);
        }
      if (g && !(g % 16))
        show_note ("%d GiB so far hashed with %s", g, gcry_md_algo_name (algo));
    }
  if (g >= 16)
    show_note ("%d GiB hashed with %s", g, gcry_md_algo_name (algo));

  err = gcry_md_copy (&hd_post, hd);
  if (err)
    die ("gcry_md_copy failed for %s (%d): %s",
         gcry_md_algo_name (algo), algo, gpg_strerror (err));
  err = gcry_md_copy (&hd_post2, hd);
  if (err)
    die ("gcry_md_copy failed for %s (%d): %s",
         gcry_md_algo_name (algo), algo, gpg_strerror (err));

  gcry_md_write (hd_pre2, pattern, sizeof pattern - 64);
  gcry_md_write (hd_pre, pattern, sizeof pattern - 1);
  gcry_md_write (hd_post, pattern, 1);
  gcry_md_write (hd_post2, pattern, 64);

  digest = gcry_md_read (hd_pre2, algo);
  if (cmp_digest (digest, digestlen, algo, gigs, -64) || verbose)
    showhex (digest, digestlen, "%d GiB %+3d %-10s ",
             gigs, -64, gcry_md_algo_name (algo));
  digest = gcry_md_read (hd_pre, algo);
  if (cmp_digest (digest, digestlen, algo, gigs, -1) || verbose)
    showhex (digest, digestlen, "%d GiB %+3d %-10s ",
             gigs, -1, gcry_md_algo_name (algo));
  digest = gcry_md_read (hd, algo);
  if (cmp_digest (digest, digestlen, algo, gigs, 0) || verbose)
    showhex (digest, digestlen, "%d GiB %+3d %-10s ",
             gigs, 0, gcry_md_algo_name (algo));
  digest = gcry_md_read (hd_post, algo);
  if (cmp_digest (digest, digestlen, algo, gigs, 1) || verbose)
    showhex (digest, digestlen, "%d GiB %+3d %-10s ",
             gigs, 1, gcry_md_algo_name (algo));
  digest = gcry_md_read (hd_post2, algo);
  if (cmp_digest (digest, digestlen, algo, gigs, 64) || verbose)
    showhex (digest, digestlen, "%d GiB %+3d %-10s ",
             gigs, 64, gcry_md_algo_name (algo));

  gcry_md_close (hd);
  gcry_md_close (hd_pre);
  gcry_md_close (hd_pre2);
  gcry_md_close (hd_post);
  gcry_md_close (hd_post2);
}
Beispiel #16
0
		hasher& operator=(hasher const& h)
		{
			gcry_md_close(m_context);
			gcry_md_copy(&m_context, h.m_context);
			return *this;
		}
Beispiel #17
0
		hasher(hasher const& h)
		{
			gcry_md_copy(&m_context, h.m_context);
		}