crypto/kdf/hkdf.c

   1 /*
   2  * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <openssl/hmac.h>
  13 #include <openssl/kdf.h>
  14 #include <openssl/evp.h>
  15 #include "internal/cryptlib.h"
  16 #include "internal/evp_int.h"
  17
  18 #define HKDF_MAXBUF 1024
  19
  20 static unsigned char *HKDF(const EVP_MD *evp_md,
  21                            const unsigned char *salt, size_t salt_len,
  22                            const unsigned char *key, size_t key_len,
  23                            const unsigned char *info, size_t info_len,
  24                            unsigned char *okm, size_t okm_len);
  25
  26 static unsigned char *HKDF_Extract(const EVP_MD *evp_md,
  27                                    const unsigned char *salt, size_t salt_len,
  28                                    const unsigned char *key, size_t key_len,
  29                                    unsigned char *prk, size_t *prk_len);
  30
  31 static unsigned char *HKDF_Expand(const EVP_MD *evp_md,
  32                                   const unsigned char *prk, size_t prk_len,
  33                                   const unsigned char *info, size_t info_len,
  34                                   unsigned char *okm, size_t okm_len);
  35
  36 typedef struct {
  37     int mode;
  38     const EVP_MD *md;
  39     unsigned char *salt;
  40     size_t salt_len;
  41     unsigned char *key;
  42     size_t key_len;
  43     unsigned char info[HKDF_MAXBUF];
  44     size_t info_len;
  45 } HKDF_PKEY_CTX;
  46
  47 static int pkey_hkdf_init(EVP_PKEY_CTX *ctx)
  48 {
  49     HKDF_PKEY_CTX *kctx;
  50
  51     kctx = OPENSSL_zalloc(sizeof(*kctx));
  52     if (kctx == NULL)
  53         return 0;
  54
  55     ctx->data = kctx;
  56
  57     return 1;
  58 }
  59
  60 static void pkey_hkdf_cleanup(EVP_PKEY_CTX *ctx)
  61 {
  62     HKDF_PKEY_CTX *kctx = ctx->data;
  63     OPENSSL_clear_free(kctx->salt, kctx->salt_len);
  64     OPENSSL_clear_free(kctx->key, kctx->key_len);
  65     OPENSSL_cleanse(kctx->info, kctx->info_len);
  66     OPENSSL_free(kctx);
  67 }
  68
  69 static int pkey_hkdf_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
  70 {
  71     HKDF_PKEY_CTX *kctx = ctx->data;
  72
  73     switch (type) {
  74     case EVP_PKEY_CTRL_HKDF_MD:
  75         if (p2 == NULL)
  76             return 0;
  77
  78         kctx->md = p2;
  79         return 1;
  80
  81     case EVP_PKEY_CTRL_HKDF_MODE:
  82         kctx->mode = p1;
  83         return 1;
  84
  85     case EVP_PKEY_CTRL_HKDF_SALT:
  86         if (p1 == 0 || p2 == NULL)
  87             return 1;
  88
  89         if (p1 < 0)
  90             return 0;
  91
  92         if (kctx->salt != NULL)
  93             OPENSSL_clear_free(kctx->salt, kctx->salt_len);
  94
  95         kctx->salt = OPENSSL_memdup(p2, p1);
  96         if (kctx->salt == NULL)
  97             return 0;
  98
  99         kctx->salt_len = p1;
 100         return 1;
 101
 102     case EVP_PKEY_CTRL_HKDF_KEY:
 103         if (p1 < 0)
 104             return 0;
 105
 106         if (kctx->key != NULL)
 107             OPENSSL_clear_free(kctx->key, kctx->key_len);
 108
 109         kctx->key = OPENSSL_memdup(p2, p1);
 110         if (kctx->key == NULL)
 111             return 0;
 112
 113         kctx->key_len  = p1;
 114         return 1;
 115
 116     case EVP_PKEY_CTRL_HKDF_INFO:
 117         if (p1 == 0 || p2 == NULL)
 118             return 1;
 119
 120         if (p1 < 0 || p1 > (int)(HKDF_MAXBUF - kctx->info_len))
 121             return 0;
 122
 123         memcpy(kctx->info + kctx->info_len, p2, p1);
 124         kctx->info_len += p1;
 125         return 1;
 126
 127     default:
 128         return -2;
 129
 130     }
 131 }
 132
 133 static int pkey_hkdf_ctrl_str(EVP_PKEY_CTX *ctx, const char *type,
 134                               const char *value)
 135 {
 136     if (strcmp(type, "mode") == 0) {
 137         int mode;
 138
 139         if (strcmp(value, "EXTRACT_AND_EXPAND") == 0)
 140             mode = EVP_PKEY_HKDEF_MODE_EXTRACT_AND_EXPAND;
 141         else if (strcmp(value, "EXTRACT_ONLY") == 0)
 142             mode = EVP_PKEY_HKDEF_MODE_EXTRACT_ONLY;
 143         else if (strcmp(value, "EXPAND_ONLY") == 0)
 144             mode = EVP_PKEY_HKDEF_MODE_EXPAND_ONLY;
 145         else
 146             return 0;
 147
 148         return EVP_PKEY_CTX_hkdf_mode(ctx, mode);
 149     }
 150
 151     if (strcmp(type, "md") == 0)
 152         return EVP_PKEY_CTX_set_hkdf_md(ctx, EVP_get_digestbyname(value));
 153
 154     if (strcmp(type, "salt") == 0)
 155         return EVP_PKEY_CTX_str2ctrl(ctx, EVP_PKEY_CTRL_HKDF_SALT, value);
 156
 157     if (strcmp(type, "hexsalt") == 0)
 158         return EVP_PKEY_CTX_hex2ctrl(ctx, EVP_PKEY_CTRL_HKDF_SALT, value);
 159
 160     if (strcmp(type, "key") == 0)
 161         return EVP_PKEY_CTX_str2ctrl(ctx, EVP_PKEY_CTRL_HKDF_KEY, value);
 162
 163     if (strcmp(type, "hexkey") == 0)
 164         return EVP_PKEY_CTX_hex2ctrl(ctx, EVP_PKEY_CTRL_HKDF_KEY, value);
 165
 166     if (strcmp(type, "info") == 0)
 167         return EVP_PKEY_CTX_str2ctrl(ctx, EVP_PKEY_CTRL_HKDF_INFO, value);
 168
 169     if (strcmp(type, "hexinfo") == 0)
 170         return EVP_PKEY_CTX_hex2ctrl(ctx, EVP_PKEY_CTRL_HKDF_INFO, value);
 171
 172     return -2;
 173 }
 174
 175 static int pkey_hkdf_derive(EVP_PKEY_CTX *ctx, unsigned char *key,
 176                             size_t *keylen)
 177 {
 178     HKDF_PKEY_CTX *kctx = ctx->data;
 179
 180     if (kctx->md == NULL || kctx->key == NULL)
 181         return 0;
 182
 183     switch (kctx->mode) {
 184     case EVP_PKEY_HKDEF_MODE_EXTRACT_AND_EXPAND:
 185         return HKDF(kctx->md, kctx->salt, kctx->salt_len, kctx->key,
 186                     kctx->key_len, kctx->info, kctx->info_len, key,
 187                     *keylen) != NULL;
 188
 189     case EVP_PKEY_HKDEF_MODE_EXTRACT_ONLY:
 190         if (key == NULL) {
 191             *keylen = EVP_MD_size(kctx->md);
 192             return 1;
 193         }
 194         return HKDF_Extract(kctx->md, kctx->salt, kctx->salt_len, kctx->key,
 195                             kctx->key_len, key, keylen) != NULL;
 196
 197     case EVP_PKEY_HKDEF_MODE_EXPAND_ONLY:
 198         return HKDF_Expand(kctx->md, kctx->key, kctx->key_len, kctx->info,
 199                            kctx->info_len, key, *keylen) != NULL;
 200
 201     default:
 202         return 0;
 203     }
 204 }
 205
 206 const EVP_PKEY_METHOD hkdf_pkey_meth = {
 207     EVP_PKEY_HKDF,
 208     0,
 209     pkey_hkdf_init,
 210     0,
 211     pkey_hkdf_cleanup,
 212
 213     0, 0,
 214     0, 0,
 215
 216     0,
 217     0,
 218
 219     0,
 220     0,
 221
 222     0, 0,
 223
 224     0, 0, 0, 0,
 225
 226     0, 0,
 227
 228     0, 0,
 229
 230     0,
 231     pkey_hkdf_derive,
 232     pkey_hkdf_ctrl,
 233     pkey_hkdf_ctrl_str
 234 };
 235
 236 static unsigned char *HKDF(const EVP_MD *evp_md,
 237                            const unsigned char *salt, size_t salt_len,
 238                            const unsigned char *key, size_t key_len,
 239                            const unsigned char *info, size_t info_len,
 240                            unsigned char *okm, size_t okm_len)
 241 {
 242     unsigned char prk[EVP_MAX_MD_SIZE];
 243     unsigned char *ret;
 244     size_t prk_len;
 245
 246     if (!HKDF_Extract(evp_md, salt, salt_len, key, key_len, prk, &prk_len))
 247         return NULL;
 248
 249     ret = HKDF_Expand(evp_md, prk, prk_len, info, info_len, okm, okm_len);
 250     OPENSSL_cleanse(prk, sizeof(prk));
 251
 252     return ret;
 253 }
 254
 255 static unsigned char *HKDF_Extract(const EVP_MD *evp_md,
 256                                    const unsigned char *salt, size_t salt_len,
 257                                    const unsigned char *key, size_t key_len,
 258                                    unsigned char *prk, size_t *prk_len)
 259 {
 260     unsigned int tmp_len;
 261
 262     if (!HMAC(evp_md, salt, salt_len, key, key_len, prk, &tmp_len))
 263         return NULL;
 264
 265     *prk_len = tmp_len;
 266     return prk;
 267 }
 268
 269 static unsigned char *HKDF_Expand(const EVP_MD *evp_md,
 270                                   const unsigned char *prk, size_t prk_len,
 271                                   const unsigned char *info, size_t info_len,
 272                                   unsigned char *okm, size_t okm_len)
 273 {
 274     HMAC_CTX *hmac;
 275
 276     unsigned int i;
 277
 278     unsigned char prev[EVP_MAX_MD_SIZE];
 279
 280     size_t done_len = 0, dig_len = EVP_MD_size(evp_md);
 281
 282     size_t n = okm_len / dig_len;
 283     if (okm_len % dig_len)
 284         n++;
 285
 286     if (n > 255 || okm == NULL)
 287         return NULL;
 288
 289     if ((hmac = HMAC_CTX_new()) == NULL)
 290         return NULL;
 291
 292     if (!HMAC_Init_ex(hmac, prk, prk_len, evp_md, NULL))
 293         goto err;
 294
 295     for (i = 1; i <= n; i++) {
 296         size_t copy_len;
 297         const unsigned char ctr = i;
 298
 299         if (i > 1) {
 300             if (!HMAC_Init_ex(hmac, NULL, 0, NULL, NULL))
 301                 goto err;
 302
 303             if (!HMAC_Update(hmac, prev, dig_len))
 304                 goto err;
 305         }
 306
 307         if (!HMAC_Update(hmac, info, info_len))
 308             goto err;
 309
 310         if (!HMAC_Update(hmac, &ctr, 1))
 311             goto err;
 312
 313         if (!HMAC_Final(hmac, prev, NULL))
 314             goto err;
 315
 316         copy_len = (done_len + dig_len > okm_len) ?
 317                        okm_len - done_len :
 318                        dig_len;
 319
 320         memcpy(okm + done_len, prev, copy_len);
 321
 322         done_len += copy_len;
 323     }
 324
 325     HMAC_CTX_free(hmac);
 326     return okm;
 327
 328  err:
 329     HMAC_CTX_free(hmac);
 330     return NULL;
 331 }