crypto_hkdf.c File Reference

#include "sodium/utils.h"
#include <stdio.h>
#include "platform.h"
#include "gnunet_common.h"
#include "gnunet_util_lib.h"
#include "sodium/crypto_auth_hmacsha256.h"

Include dependency graph for crypto_hkdf.c:

Go to the source code of this file.

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

Functions
static enum GNUNET_GenericReturnValue	hkdf_expand (void *result, size_t out_len, const unsigned char *prk, size_t prk_len, va_list argp)
enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_hkdf_expand_v (void *result, size_t out_len, const struct GNUNET_ShortHashCode *prk, va_list argp)
	HKDF-Expand using SHA256.
enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_hkdf_expand (void *result, size_t out_len, const struct GNUNET_ShortHashCode *prk,...)
	HKDF-Expand using SHA256.
enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_hkdf_gnunet_v (void *result, size_t out_len, const void *xts, size_t xts_len, const void *skm, size_t skm_len, va_list argp)
	Derive key.
enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_hkdf_gnunet (void *result, size_t out_len, const void *xts, size_t xts_len, const void *skm, size_t skm_len,...)
	A peculiar HKDF instantiation that tried to mimic Truncated NMAC.
enum GNUNET_GenericReturnValue	GNUNET_CRYPTO_hkdf_extract (struct GNUNET_ShortHashCode *prk, const void *xts, size_t xts_len, const void *skm, size_t skm_len)
	HKDF-Extract using SHA256.

Macro Definition Documentation

LOG

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

Definition at line 41 of file crypto_hkdf.c.

Function Documentation

hkdf_expand()

static enum GNUNET_GenericReturnValue hkdf_expand ( void *  result, size_t  out_len, const unsigned char *  prk, size_t  prk_len, va_list  argp  )

static

Definition at line 49 of file crypto_hkdf.c.

{
  unsigned char *outbuf = (unsigned char*) result;
  size_t i;
  size_t ctx_len;
  va_list args;
 
  if (out_len > (0xff * crypto_auth_hmacsha256_BYTES))
    return GNUNET_SYSERR;
 
  va_copy (args, argp);
 
  ctx_len = 0;
  while (NULL != va_arg (args, void *))
  {
    size_t nxt = va_arg (args, size_t);
    if (nxt + ctx_len < nxt)
    {
      /* integer overflow */
      GNUNET_break (0);
      va_end (args);
      return GNUNET_SYSERR;
    }
    ctx_len += nxt;
  }
 
  va_end (args);
 
  if ( (crypto_auth_hmacsha256_BYTES + ctx_len < ctx_len) ||
       (crypto_auth_hmacsha256_BYTES + ctx_len + 1 < ctx_len) )
  {
    /* integer overflow */
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
 
  memset (result, 0, out_len);
 
  {
    size_t left = out_len;
    const void *ctx_arg;
    unsigned char tmp[crypto_auth_hmacsha256_BYTES];
    unsigned char ctx[ctx_len];
    unsigned char *dst = ctx;
    crypto_auth_hmacsha256_state st;
    unsigned char counter = 1U;
 
    sodium_memzero (ctx, sizeof ctx);
    va_copy (args, argp);
    while ((ctx_arg = va_arg (args, void *)))
    {
      size_t len;
 
      len = va_arg (args, size_t);
      GNUNET_memcpy (dst, ctx_arg, len);
      dst += len;
    }
    va_end (args);
 
    for (i = 0; left > 0; i += crypto_auth_hmacsha256_BYTES)
    {
      crypto_auth_hmacsha256_init(&st, prk, prk_len);
      if (0 != i)
      {
        crypto_auth_hmacsha256_update(&st,
                                      &outbuf[i - crypto_auth_hmacsha256_BYTES],
                                      crypto_auth_hmacsha256_BYTES);
      }
      crypto_auth_hmacsha256_update(&st, ctx, ctx_len);
      crypto_auth_hmacsha256_update(&st, &counter, 1);
      if (left >= crypto_auth_hmacsha256_BYTES)
      {
        crypto_auth_hmacsha256_final(&st, &outbuf[i]);
        left -= crypto_auth_hmacsha256_BYTES;
      }
      else
      {
        crypto_auth_hmacsha256_final(&st, tmp);
        memcpy (&outbuf[i], tmp, left);
        sodium_memzero(tmp, sizeof tmp);
        left = 0;
      }
      counter++;
    }
    sodium_memzero(&st, sizeof st);
  }
  return GNUNET_YES;
}

References ctx, GNUNET_break, GNUNET_memcpy, GNUNET_SYSERR, GNUNET_YES, result, and st.

Referenced by GNUNET_CRYPTO_hkdf_expand_v(), and GNUNET_CRYPTO_hkdf_gnunet_v().

Here is the caller graph for this function: