src/util/crypto_hkdf.c

   1 /*
   2     Copyright (c) 2010 Nils Durner
   3
   4     Permission is hereby granted, free of charge, to any person obtaining a copy
   5     of this software and associated documentation files (the "Software"), to deal
   6     in the Software without restriction, including without limitation the rights
   7     to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8     copies of the Software, and to permit persons to whom the Software is
   9     furnished to do so, subject to the following conditions:
  10
  11     The above copyright notice and this permission notice shall be included in
  12     all copies or substantial portions of the Software.
  13
  14     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15     IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17     AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18     LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  20     THE SOFTWARE.
  21 */
  22
  23 /**
  24  * @file src/util/crypto_hkdf.c
  25  * @brief Hash-based KDF as defined in RFC 5869
  26  * @see http://www.rfc-editor.org/rfc/rfc5869.txt
  27  * @todo remove GNUNET references
  28  * @author Nils Durner
  29  *
  30  * The following list of people have reviewed this code and considered
  31  * it correct on the date given (if you reviewed it, please
  32  * have your name added to the list):
  33  *
  34  * - Christian Grothoff (08.10.2010)
  35  * - Nathan Evans (08.10.2010)
  36  * - Matthias Wachs (08.10.2010)
  37  */
  38
  39 #define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__)
  40
  41 /**
  42  * Set this to 0 if you compile this code outside of GNUnet.
  43  */
  44 #define GNUNET_BUILD 1
  45
  46 /**
  47  * Enable debugging.
  48  */
  49 #define DEBUG_HKDF 0
  50
  51
  52
  53 #if GNUNET_BUILD
  54 #include "platform.h"
  55 #include "gnunet_crypto_lib.h"
  56 #else
  57 #define GNUNET_NO 0
  58 #define GNUNET_YES 1
  59 #define GNUNET_SYSERR -1
  60 #include <stdlib.h>
  61 #endif
  62
  63 #include <gcrypt.h>
  64
  65
  66 /**
  67  * @brief Compute the HMAC
  68  * @todo use chunked buffers
  69  * @param mac gcrypt MAC handle
  70  * @param key HMAC key
  71  * @param key_len length of key
  72  * @param buf message to be processed
  73  * @param buf_len length of buf
  74  * @return HMAC, freed by caller via gcry_md_close/_reset
  75  */
  76 static const void *
  77 doHMAC (gcry_md_hd_t mac, const void *key, size_t key_len, const void *buf,
  78         size_t buf_len)
  79 {
  80   gcry_md_setkey (mac, key, key_len);
  81   gcry_md_write (mac, buf, buf_len);
  82
  83   return (const void *) gcry_md_read (mac, 0);
  84 }
  85
  86 /**
  87  * @brief Generate pseudo-random key
  88  * @param mac gcrypt HMAC handle
  89  * @param xts salt
  90  * @param xts_len length of the salt
  91  * @param skm source key material
  92  * @param skm_len length of skm
  93  * @param prk result buffer (allocated by caller; at least gcry_md_dlen() bytes)
  94  * @return GNUNET_YES on success
  95  */
  96 static int
  97 getPRK (gcry_md_hd_t mac, const void *xts, size_t xts_len, const void *skm,
  98         size_t skm_len, void *prk)
  99 {
 100   const void *ret;
 101
 102   ret = doHMAC (mac, xts, xts_len, skm, skm_len);
 103   if (ret == NULL)
 104     return GNUNET_SYSERR;
 105   memcpy (prk, ret, gcry_md_get_algo_dlen (gcry_md_get_algo (mac)));
 106
 107   return GNUNET_YES;
 108 }
 109
 110
 111 #if DEBUG_HKDF
 112 static void
 113 dump (const char *src, const void *p, unsigned int l)
 114 {
 115   unsigned int i;
 116
 117   printf ("\n%s: ", src);
 118   for (i = 0; i < l; i++)
 119   {
 120     printf ("%2x", (int) ((const unsigned char *) p)[i]);
 121   }
 122   printf ("\n");
 123 }
 124 #endif
 125
 126
 127 /**
 128  * @brief Derive key
 129  * @param result buffer for the derived key, allocated by caller
 130  * @param out_len desired length of the derived key
 131  * @param xtr_algo hash algorithm for the extraction phase, GCRY_MD_...
 132  * @param prf_algo hash algorithm for the expansion phase, GCRY_MD_...
 133  * @param xts salt
 134  * @param xts_len length of xts
 135  * @param skm source key material
 136  * @param skm_len length of skm
 137  * @param argp va_list of void * & size_t pairs for context chunks
 138  * @return #GNUNET_YES on success
 139  */
 140 int
 141 GNUNET_CRYPTO_hkdf_v (void *result, size_t out_len, int xtr_algo, int prf_algo,
 142                       const void *xts, size_t xts_len, const void *skm,
 143                       size_t skm_len, va_list argp)
 144 {
 145   static int once;
 146   static gcry_md_hd_t xtr;
 147   static gcry_md_hd_t prf;
 148   const void *hc;
 149   unsigned long i;
 150   unsigned long t;
 151   unsigned long d;
 152   unsigned int k = gcry_md_get_algo_dlen (prf_algo);
 153   unsigned int xtr_len = gcry_md_get_algo_dlen (xtr_algo);
 154   char prk[xtr_len];
 155   int ret;
 156   size_t ctx_len;
 157   va_list args;
 158
 159   if (0 == k)
 160     return GNUNET_SYSERR;
 161   if (! once)
 162   {
 163     if (GPG_ERR_NO_ERROR !=
 164         gcry_md_open (&xtr, xtr_algo, GCRY_MD_FLAG_HMAC))
 165       return GNUNET_SYSERR;
 166
 167     if (GPG_ERR_NO_ERROR !=
 168         gcry_md_open (&prf, prf_algo, GCRY_MD_FLAG_HMAC))
 169     {
 170       gcry_md_close (xtr);
 171       return GNUNET_SYSERR;
 172     }
 173     once = 1;
 174   }
 175   else
 176   {
 177     gcry_md_reset (xtr);
 178     gcry_md_reset (prf);
 179   }
 180
 181   va_copy (args, argp);
 182
 183   ctx_len = 0;
 184   while (NULL != va_arg (args, void *))
 185          ctx_len += va_arg (args, size_t);
 186
 187   va_end (args);
 188
 189   memset (result, 0, out_len);
 190   if (getPRK (xtr, xts, xts_len, skm, skm_len, prk) != GNUNET_YES)
 191     goto hkdf_error;
 192 #if DEBUG_HKDF
 193   dump ("PRK", prk, xtr_len);
 194 #endif
 195
 196   t = out_len / k;
 197   d = out_len % k;
 198
 199   /* K(1) */
 200   {
 201     size_t plain_len = k + ctx_len + 1;
 202     char plain[plain_len];
 203     const void *ctx;
 204     char *dst;
 205
 206     dst = plain + k;
 207     va_copy (args, argp);
 208     while ((ctx = va_arg (args, void *)))
 209     {
 210       size_t len;
 211
 212       len = va_arg (args, size_t);
 213       memcpy (dst, ctx, len);
 214       dst += len;
 215     }
 216     va_end (args);
 217
 218     if (t > 0)
 219     {
 220       memset (plain + k + ctx_len, 1, 1);
 221 #if DEBUG_HKDF
 222       dump ("K(1)", plain, plain_len);
 223 #endif
 224       hc = doHMAC (prf, prk, xtr_len, &plain[k], ctx_len + 1);
 225       if (hc == NULL)
 226         goto hkdf_error;
 227       memcpy (result, hc, k);
 228       result += k;
 229     }
 230
 231     /* K(i+1) */
 232     for (i = 1; i < t; i++)
 233     {
 234       memcpy (plain, result - k, k);
 235       memset (plain + k + ctx_len, i + 1, 1);
 236       gcry_md_reset (prf);
 237 #if DEBUG_HKDF
 238       dump ("K(i+1)", plain, plain_len);
 239 #endif
 240       hc = doHMAC (prf, prk, xtr_len, plain, plain_len);
 241       if (hc == NULL)
 242         goto hkdf_error;
 243       memcpy (result, hc, k);
 244       result += k;
 245     }
 246
 247     /* K(t):d */
 248     if (d > 0)
 249     {
 250       if (t > 0)
 251       {
 252         memcpy (plain, result - k, k);
 253         i++;
 254       }
 255       memset (plain + k + ctx_len, i, 1);
 256       gcry_md_reset (prf);
 257 #if DEBUG_HKDF
 258       dump ("K(t):d", plain, plain_len);
 259 #endif
 260       if (t > 0)
 261         hc = doHMAC (prf, prk, xtr_len, plain, plain_len);
 262       else
 263         hc = doHMAC (prf, prk, xtr_len, plain + k, plain_len - k);
 264       if (hc == NULL)
 265         goto hkdf_error;
 266       memcpy (result, hc, d);
 267     }
 268 #if DEBUG_HKDF
 269     dump ("result", result - k, out_len);
 270 #endif
 271
 272     ret = GNUNET_YES;
 273     goto hkdf_ok;
 274   }
 275 hkdf_error:
 276   ret = GNUNET_SYSERR;
 277 hkdf_ok:
 278   return ret;
 279 }
 280
 281
 282 /**
 283  * @brief Derive key
 284  * @param result buffer for the derived key, allocated by caller
 285  * @param out_len desired length of the derived key
 286  * @param xtr_algo hash algorithm for the extraction phase, GCRY_MD_...
 287  * @param prf_algo hash algorithm for the expansion phase, GCRY_MD_...
 288  * @param xts salt
 289  * @param xts_len length of @a xts
 290  * @param skm source key material
 291  * @param skm_len length of @a skm
 292  * @return #GNUNET_YES on success
 293  */
 294 int
 295 GNUNET_CRYPTO_hkdf (void *result, size_t out_len, int xtr_algo, int prf_algo,
 296                     const void *xts, size_t xts_len, const void *skm,
 297                     size_t skm_len, ...)
 298 {
 299   va_list argp;
 300   int ret;
 301
 302   va_start (argp, skm_len);
 303   ret =
 304       GNUNET_CRYPTO_hkdf_v (result, out_len, xtr_algo, prf_algo, xts, xts_len,
 305                             skm, skm_len, argp);
 306   va_end (argp);
 307
 308   return ret;
 309 }
 310
 311 /* end of crypto_hkdf.c */