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 /**
  40  * Set this to 0 if you compile this code outside of GNUnet.
  41  */
  42 #define GNUNET_BUILD 1
  43
  44 /**
  45  * Enable debugging.
  46  */
  47 #define DEBUG_HKDF 0
  48
  49
  50 #if GNUNET_BUILD
  51 #include "platform.h"
  52 #include "gnunet_crypto_lib.h"
  53 #else
  54 #define GNUNET_NO 0
  55 #define GNUNET_YES 1
  56 #define GNUNET_SYSERR -1
  57 #include <stdlib.h>
  58 #endif
  59
  60 #include <gcrypt.h>
  61
  62
  63 /**
  64  * @brief Compute the HMAC
  65  * @todo use chunked buffers
  66  * @param mac gcrypt MAC handle
  67  * @param key HMAC key
  68  * @param key_len length of key
  69  * @param buf message to be processed
  70  * @param buf_len length of buf
  71  * @return HMAC, freed by caller via gcry_md_close/_reset
  72  */
  73 static const void *
  74 doHMAC (gcry_md_hd_t mac,
  75         const void *key, size_t key_len,
  76         const void *buf, size_t buf_len)
  77 {
  78   gcry_md_setkey (mac, key, key_len);
  79   gcry_md_write (mac, buf, buf_len);
  80
  81   return (const void *) gcry_md_read (mac, 0);
  82 }
  83
  84 /**
  85  * @brief Generate pseudo-random key
  86  * @param mac gcrypt HMAC handle
  87  * @param xts salt
  88  * @param xts_len length of the salt
  89  * @param skm source key material
  90  * @param skm_len length of skm
  91  * @param prk result buffer (allocated by caller; at least gcry_md_dlen() bytes)
  92  * @return GNUNET_YES on success
  93  */
  94 static int
  95 getPRK (gcry_md_hd_t mac,
  96         const void *xts, size_t xts_len,
  97         const void *skm, size_t skm_len,
  98         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,
 106           ret,
 107           gcry_md_get_algo_dlen (gcry_md_get_algo (mac)));
 108
 109   return GNUNET_YES;
 110 }
 111
 112
 113 #if DEBUG_HKDF
 114 static void
 115 dump(const char *src,
 116      const void *p,
 117      unsigned int l)
 118 {
 119   unsigned int i;
 120
 121   printf("\n%s: ", src);
 122   for (i = 0; i < l; i++)
 123     {
 124       printf("%2x", (int) ((const unsigned char *) p)[i]);
 125     }
 126   printf("\n");
 127 }
 128 #endif
 129
 130
 131 /**
 132  * @brief Derive key
 133  * @param result buffer for the derived key, allocated by caller
 134  * @param out_len desired length of the derived key
 135  * @param xtr_algo hash algorithm for the extraction phase, GCRY_MD_...
 136  * @param prf_algo hash algorithm for the expansion phase, GCRY_MD_...
 137  * @param xts salt
 138  * @param xts_len length of xts
 139  * @param skm source key material
 140  * @param skm_len length of skm
 141  * @param argp va_list of void * & size_t pairs for context chunks
 142  * @return GNUNET_YES on success
 143  */
 144 int
 145 GNUNET_CRYPTO_hkdf_v (void *result, size_t out_len,
 146                       int xtr_algo, int prf_algo,
 147                       const void *xts, size_t xts_len,
 148                       const void *skm, size_t skm_len,
 149                       va_list argp)
 150 {
 151   const void *hc;
 152   unsigned long i, t, d;
 153   unsigned int k = gcry_md_get_algo_dlen (prf_algo);
 154   unsigned int xtr_len = gcry_md_get_algo_dlen (xtr_algo);
 155   char prk[xtr_len];
 156   int ret;
 157   gcry_md_hd_t xtr, prf;
 158   size_t ctx_len;
 159   va_list args;
 160
 161   if (k == 0)
 162     return GNUNET_SYSERR;
 163
 164   if (gcry_md_open(&xtr, xtr_algo, GCRY_MD_FLAG_HMAC) != GPG_ERR_NO_ERROR)
 165     return GNUNET_SYSERR;
 166
 167   if (gcry_md_open(&prf, prf_algo, GCRY_MD_FLAG_HMAC) != GPG_ERR_NO_ERROR)
 168   {
 169     gcry_md_close (xtr);
 170     return GNUNET_SYSERR;
 171   }
 172
 173   va_copy (args, argp);
 174
 175   ctx_len = 0;
 176   while (NULL != va_arg (args, void *))
 177     ctx_len += va_arg (args, size_t);
 178   va_end(args);
 179
 180   memset (result, 0, out_len);
 181   if (getPRK (xtr, xts, xts_len, skm, skm_len, prk)
 182       != GNUNET_YES)
 183     goto hkdf_error;
 184 #if DEBUG_HKDF
 185   dump("PRK", prk, xtr_len);
 186 #endif
 187
 188   t = out_len / k;
 189   d = out_len % k;
 190
 191   /* K(1) */
 192   {
 193   size_t plain_len = k + ctx_len + 1;
 194   char plain[plain_len];
 195       const void *ctx;
 196       char *dst;
 197
 198       dst = plain + k;
 199       va_copy (args, argp);
 200       while ((ctx = va_arg (args, void *)))
 201         {
 202           size_t len;
 203
 204           len = va_arg (args, size_t);
 205           memcpy (dst, ctx, len);
 206           dst += len;
 207         }
 208       va_end (args);
 209
 210   if (t > 0)
 211     {
 212       memset (plain + k + ctx_len, 1, 1);
 213 #if DEBUG_HKDF
 214       dump("K(1)", plain, plain_len);
 215 #endif
 216       hc = doHMAC (prf,
 217                    prk,
 218                    xtr_len, &plain[k], ctx_len + 1);
 219       if (hc == NULL)
 220         goto hkdf_error;
 221       memcpy (result, hc, k);
 222       result += k;
 223     }
 224
 225   /* K(i+1) */
 226   for (i = 1; i < t; i++)
 227     {
 228       memcpy (plain, result - k, k);
 229       memset (plain + k + ctx_len, i + 1, 1);
 230       gcry_md_reset (prf);
 231 #if DEBUG_HKDF
 232       dump("K(i+1)", plain, plain_len);
 233 #endif
 234       hc = doHMAC (prf, prk, xtr_len, plain, plain_len);
 235       if (hc == NULL)
 236         goto hkdf_error;
 237       memcpy (result, hc, k);
 238       result += k;
 239     }
 240
 241   /* K(t):d */
 242   if (d > 0)
 243     {
 244       if (t > 0)
 245         {
 246           memcpy (plain, result - k, k);
 247           i++;
 248         }
 249       memset (plain + k + ctx_len, i, 1);
 250       gcry_md_reset (prf);
 251 #if DEBUG_HKDF
 252       dump("K(t):d", plain, plain_len);
 253 #endif
 254       if (t > 0)
 255         hc = doHMAC (prf, prk, xtr_len, plain, plain_len);
 256       else
 257         hc = doHMAC (prf, prk, xtr_len, plain + k, plain_len - k);
 258       if (hc == NULL)
 259         goto hkdf_error;
 260       memcpy (result, hc, d);
 261     }
 262 #if DEBUG_HKDF
 263   dump("result", result - k, out_len);
 264 #endif
 265
 266   ret = GNUNET_YES;
 267   goto hkdf_ok;
 268   }
 269 hkdf_error:
 270   ret = GNUNET_SYSERR;
 271 hkdf_ok:
 272   gcry_md_close (prf);
 273   gcry_md_close (xtr);
 274
 275   return ret;
 276 }
 277
 278
 279 /**
 280  * @brief Derive key
 281  * @param result buffer for the derived key, allocated by caller
 282  * @param out_len desired length of the derived key
 283  * @param xtr_algo hash algorithm for the extraction phase, GCRY_MD_...
 284  * @param prf_algo hash algorithm for the expansion phase, GCRY_MD_...
 285  * @param xts salt
 286  * @param xts_len length of xts
 287  * @param skm source key material
 288  * @param skm_len length of skm
 289  * @return GNUNET_YES on success
 290  */
 291 int
 292 GNUNET_CRYPTO_hkdf (void *result, size_t out_len,
 293                     int xtr_algo, int prf_algo,
 294                     const void *xts, size_t xts_len,
 295                     const void *skm, size_t skm_len,
 296                     ...)
 297 {
 298   va_list argp;
 299   int ret;
 300
 301   va_start(argp, skm_len);
 302   ret = GNUNET_CRYPTO_hkdf_v (result, out_len, xtr_algo, prf_algo, xts,
 303       xts_len, skm, skm_len, argp);
 304   va_end(argp);
 305
 306   return ret;
 307 }
 308
 309 /* end of crypto_hkdf.c */