static int
wrap_padlock_hmac_fast (gnutls_mac_algorithm_t algo,
                        const void *key, size_t key_size, const void *text,
                        size_t text_size, void *digest)
{
    if (algo == GNUTLS_MAC_SHA1 || algo == GNUTLS_MAC_SHA256)
      {
          unsigned char *pad;
          unsigned char pad2[SHA1_DATA_SIZE + MAX_SHA_DIGEST_SIZE];
          unsigned char hkey[MAX_SHA_DIGEST_SIZE];
          unsigned int digest_size = _gnutls_hmac_get_algo_len (algo);

          if (key_size > SHA1_DATA_SIZE)
            {
                wrap_padlock_hash_fast (algo, key, key_size, hkey);
                key = hkey;
                key_size = digest_size;
            }

          pad = gnutls_malloc (text_size + SHA1_DATA_SIZE);
          if (pad == NULL)
              return gnutls_assert_val (GNUTLS_E_MEMORY_ERROR);

          memset (pad, IPAD, SHA1_DATA_SIZE);
          memxor (pad, key, key_size);

          memcpy (&pad[SHA1_DATA_SIZE], text, text_size);

          wrap_padlock_hash_fast (algo, pad, text_size + SHA1_DATA_SIZE,
                                  &pad2[SHA1_DATA_SIZE]);

          gnutls_free (pad);

          memset (pad2, OPAD, SHA1_DATA_SIZE);
          memxor (pad2, key, key_size);

          wrap_padlock_hash_fast (algo, pad2, digest_size + SHA1_DATA_SIZE,
                                  digest);

      }
    else
      {
          struct padlock_hmac_ctx ctx;
          int ret;

          ret = _hmac_ctx_init (algo, &ctx);
          if (ret < 0)
              return gnutls_assert_val (ret);
          ctx.algo = algo;

          wrap_padlock_hmac_setkey (&ctx, key, key_size);

          wrap_padlock_hmac_update (&ctx, text, text_size);

          wrap_padlock_hmac_output (&ctx, digest, ctx.length);
      }

    return 0;
}
Exemple #2
0
static int wrap_x86_hmac_fast(gnutls_mac_algorithm_t algo,
				const void *nonce, size_t nonce_size,
				const void *key, size_t key_size,
				const void *text, size_t text_size,
				void *digest)
{
	struct x86_hmac_ctx ctx;
	int ret;

	ret = _hmac_ctx_init(algo, &ctx);
	if (ret < 0)
		return gnutls_assert_val(ret);

	ctx.setkey(&ctx, key_size, key);
	ctx.update(&ctx, text_size, text);
	ctx.digest(&ctx, ctx.length, digest);
	
	return 0;
}
Exemple #3
0
static int wrap_x86_hmac_init(gnutls_mac_algorithm_t algo, void **_ctx)
{
	struct x86_hmac_ctx *ctx;
	int ret;

	ctx = gnutls_calloc(1, sizeof(struct x86_hmac_ctx));
	if (ctx == NULL) {
		gnutls_assert();
		return GNUTLS_E_MEMORY_ERROR;
	}

	ctx->algo = algo;

	ret = _hmac_ctx_init(algo, ctx);
	if (ret < 0)
		return gnutls_assert_val(ret);

	*_ctx = ctx;

	return 0;
}