crypto/evp/pkey_kdf.c

   1 /*
   2  * Copyright 2018 The OpenSSL Project Authors. All Rights Reserved.
   3  * Copyright (c) 2018, Oracle and/or its affiliates.  All rights reserved.
   4  *
   5  * Licensed under the Apache License 2.0 (the "License").  You may not use
   6  * this file except in compliance with the License.  You can obtain a copy
   7  * in the file LICENSE in the source distribution or at
   8  * https://www.openssl.org/source/license.html
   9  */
  10
  11 #include <string.h>
  12 #include <openssl/evp.h>
  13 #include <openssl/err.h>
  14 #include <openssl/buffer.h>
  15 #include <openssl/kdf.h>
  16 #include <openssl/core.h>
  17 #include <openssl/core_names.h>
  18 #include <openssl/params.h>
  19 #include "internal/numbers.h"
  20 #include "internal/evp_int.h"
  21
  22 #define MAX_PARAM   20
  23
  24 typedef struct {
  25     EVP_KDF_CTX *kctx;
  26     /*
  27      * EVP_PKEY implementations collect bits of certain data
  28      */
  29     BUF_MEM *collected_seed;
  30     BUF_MEM *collected_info;
  31 } EVP_PKEY_KDF_CTX;
  32
  33 static void pkey_kdf_free_collected(EVP_PKEY_KDF_CTX *pkctx)
  34 {
  35     BUF_MEM_free(pkctx->collected_seed);
  36     pkctx->collected_seed = NULL;
  37     BUF_MEM_free(pkctx->collected_info);
  38     pkctx->collected_info = NULL;
  39 }
  40
  41 static int pkey_kdf_init(EVP_PKEY_CTX *ctx)
  42 {
  43     EVP_PKEY_KDF_CTX *pkctx;
  44     EVP_KDF_CTX *kctx;
  45     const char *kdf_name = OBJ_nid2sn(ctx->pmeth->pkey_id);
  46     EVP_KDF *kdf;
  47
  48     pkctx = OPENSSL_zalloc(sizeof(*pkctx));
  49     if (pkctx == NULL)
  50         return 0;
  51
  52     kdf = EVP_KDF_fetch(NULL, kdf_name, NULL);
  53     kctx = EVP_KDF_CTX_new(kdf);
  54     EVP_KDF_free(kdf);
  55     if (kctx == NULL) {
  56         OPENSSL_free(pkctx);
  57         return 0;
  58     }
  59
  60     pkctx->kctx = kctx;
  61     ctx->data = pkctx;
  62     return 1;
  63 }
  64
  65 static void pkey_kdf_cleanup(EVP_PKEY_CTX *ctx)
  66 {
  67     EVP_PKEY_KDF_CTX *pkctx = ctx->data;
  68
  69     EVP_KDF_CTX_free(pkctx->kctx);
  70     pkey_kdf_free_collected(pkctx);
  71     OPENSSL_free(pkctx);
  72 }
  73
  74 static int collect(BUF_MEM **collector, void *data, size_t datalen)
  75 {
  76     size_t i;
  77
  78     if (*collector == NULL)
  79         *collector = BUF_MEM_new();
  80     if (*collector == NULL) {
  81         ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
  82         return 0;
  83     }
  84
  85     i = (*collector)->length; /* BUF_MEM_grow() changes it! */
  86     if (!BUF_MEM_grow(*collector, i + datalen))
  87         return 0;
  88     memcpy((*collector)->data + i, data, datalen);
  89     return 1;
  90 }
  91
  92 static int pkey_kdf_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
  93 {
  94     EVP_PKEY_KDF_CTX *pkctx = ctx->data;
  95     EVP_KDF_CTX *kctx = pkctx->kctx;
  96     enum { T_OCTET_STRING, T_UINT64, T_DIGEST, T_INT } cmd;
  97     const char *name, *mdname;
  98     BUF_MEM **collector = NULL;
  99     OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
 100
 101     switch (type) {
 102     case EVP_PKEY_CTRL_PASS:
 103         cmd = T_OCTET_STRING;
 104         name = OSSL_KDF_PARAM_PASSWORD;
 105         break;
 106     case EVP_PKEY_CTRL_HKDF_SALT:
 107     case EVP_PKEY_CTRL_SCRYPT_SALT:
 108         cmd = T_OCTET_STRING;
 109         name = OSSL_KDF_PARAM_SALT;
 110         break;
 111     case EVP_PKEY_CTRL_TLS_MD:
 112     case EVP_PKEY_CTRL_HKDF_MD:
 113         cmd = T_DIGEST;
 114         name = OSSL_KDF_PARAM_DIGEST;
 115         break;
 116     case EVP_PKEY_CTRL_TLS_SECRET:
 117         cmd = T_OCTET_STRING;
 118         name = OSSL_KDF_PARAM_SECRET;
 119         /*
 120          * Perform the semantics described in
 121          * EVP_PKEY_CTX_add1_tls1_prf_seed(3)
 122          */
 123         if (ctx->pmeth->pkey_id == NID_tls1_prf)
 124             BUF_MEM_free(pkctx->collected_seed);
 125         break;
 126     case EVP_PKEY_CTRL_TLS_SEED:
 127         cmd = T_OCTET_STRING;
 128         name = OSSL_KDF_PARAM_SEED;
 129         collector = &pkctx->collected_seed;
 130         break;
 131     case EVP_PKEY_CTRL_HKDF_KEY:
 132         cmd = T_OCTET_STRING;
 133         name = OSSL_KDF_PARAM_KEY;
 134         break;
 135     case EVP_PKEY_CTRL_HKDF_INFO:
 136         cmd = T_OCTET_STRING;
 137         name = OSSL_KDF_PARAM_INFO;
 138         collector = &pkctx->collected_info;
 139         break;
 140     case EVP_PKEY_CTRL_HKDF_MODE:
 141         cmd = T_INT;
 142         name = OSSL_KDF_PARAM_MODE;
 143         break;
 144     case EVP_PKEY_CTRL_SCRYPT_N:
 145         cmd = T_UINT64;
 146         name = OSSL_KDF_PARAM_SCRYPT_N;
 147         break;
 148     case EVP_PKEY_CTRL_SCRYPT_R:
 149         cmd = T_UINT64; /* Range checking occurs on the provider side */
 150         name = OSSL_KDF_PARAM_SCRYPT_R;
 151         break;
 152     case EVP_PKEY_CTRL_SCRYPT_P:
 153         cmd = T_UINT64; /* Range checking occurs on the provider side */
 154         name = OSSL_KDF_PARAM_SCRYPT_P;
 155         break;
 156     case EVP_PKEY_CTRL_SCRYPT_MAXMEM_BYTES:
 157         cmd = T_UINT64;
 158         name = OSSL_KDF_PARAM_SCRYPT_MAXMEM;
 159         break;
 160     default:
 161         return -2;
 162     }
 163
 164     if (collector != NULL) {
 165         switch (cmd) {
 166         case T_OCTET_STRING:
 167             return collect(collector, p2, p1);
 168         default:
 169             OPENSSL_assert("You shouldn't be here");
 170             break;
 171         }
 172         return 1;
 173     }
 174
 175     switch (cmd) {
 176     case T_OCTET_STRING:
 177         params[0] =
 178             OSSL_PARAM_construct_octet_string(name, (unsigned char *)p2,
 179                                               (size_t)p1);
 180         break;
 181
 182     case T_DIGEST:
 183         mdname = EVP_MD_name((const EVP_MD *)p2);
 184         params[0] = OSSL_PARAM_construct_utf8_string(name, (char *)mdname,
 185                                                      strlen(mdname) + 1);
 186         break;
 187
 188         /*
 189          * These are special because the helper macros pass a pointer to the
 190          * stack, so a local copy is required.
 191          */
 192     case T_INT:
 193         params[0] = OSSL_PARAM_construct_int(name, &p1);
 194         break;
 195
 196     case T_UINT64:
 197         params[0] = OSSL_PARAM_construct_uint64(name, (uint64_t *)p2);
 198         break;
 199     }
 200
 201     return EVP_KDF_CTX_set_params(kctx, params);
 202 }
 203
 204 static int pkey_kdf_ctrl_str(EVP_PKEY_CTX *ctx, const char *type,
 205                              const char *value)
 206 {
 207     EVP_PKEY_KDF_CTX *pkctx = ctx->data;
 208     EVP_KDF_CTX *kctx = pkctx->kctx;
 209     const EVP_KDF *kdf = EVP_KDF_CTX_kdf(kctx);
 210     BUF_MEM **collector = NULL;
 211     const OSSL_PARAM *defs = EVP_KDF_CTX_settable_params(kdf);
 212     OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
 213     int ok = 0;
 214
 215     /* Deal with ctrl name aliasing */
 216     if (strcmp(type, "md") == 0)
 217         type = OSSL_KDF_PARAM_DIGEST;
 218     /* scrypt uses 'N', params uses 'n' */
 219     if (strcmp(type, "N") == 0)
 220         type = OSSL_KDF_PARAM_SCRYPT_N;
 221
 222     if (!OSSL_PARAM_allocate_from_text(&params[0], defs, type,
 223                                        value, strlen(value)))
 224         return 0;
 225
 226     /*
 227      * We do the same special casing of seed and info here as in
 228      * pkey_kdf_ctrl()
 229      */
 230     if (strcmp(params[0].key, OSSL_KDF_PARAM_SEED) == 0)
 231         collector = &pkctx->collected_seed;
 232     else if (strcmp(params[0].key, OSSL_KDF_PARAM_INFO) == 0)
 233         collector = &pkctx->collected_info;
 234
 235     if (collector != NULL)
 236         ok = collect(collector, params[0].data, params[0].data_size);
 237     else
 238         ok = EVP_KDF_CTX_set_params(kctx, params);
 239     OPENSSL_free(params[0].data);
 240     return ok;
 241 }
 242
 243 static int pkey_kdf_derive_init(EVP_PKEY_CTX *ctx)
 244 {
 245     EVP_PKEY_KDF_CTX *pkctx = ctx->data;
 246
 247     pkey_kdf_free_collected(pkctx);
 248     if (pkctx->kctx != NULL)
 249         EVP_KDF_reset(pkctx->kctx);
 250     return 1;
 251 }
 252
 253 /*
 254  * For fixed-output algorithms the keylen parameter is an "out" parameter
 255  * otherwise it is an "in" parameter.
 256  */
 257 static int pkey_kdf_derive(EVP_PKEY_CTX *ctx, unsigned char *key,
 258                            size_t *keylen)
 259 {
 260     EVP_PKEY_KDF_CTX *pkctx = ctx->data;
 261     EVP_KDF_CTX *kctx = pkctx->kctx;
 262     size_t outlen = EVP_KDF_size(kctx);
 263     int r;
 264
 265     if (pkctx->collected_seed != NULL) {
 266         OSSL_PARAM params[] = { OSSL_PARAM_END, OSSL_PARAM_END };
 267
 268         params[0] =
 269             OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED,
 270                                               pkctx->collected_seed->data,
 271                                               pkctx->collected_seed->length);
 272
 273         r = EVP_KDF_CTX_set_params(kctx, params);
 274         pkey_kdf_free_collected(pkctx);
 275         if (!r)
 276             return 0;
 277     }
 278     if (pkctx->collected_info != NULL) {
 279         OSSL_PARAM params[] = { OSSL_PARAM_END, OSSL_PARAM_END };
 280
 281         params[0] =
 282             OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_INFO,
 283                                               pkctx->collected_info->data,
 284                                               pkctx->collected_info->length);
 285
 286         r = EVP_KDF_CTX_set_params(kctx, params);
 287         pkey_kdf_free_collected(pkctx);
 288         if (!r)
 289             return 0;
 290     }
 291     if (outlen == 0 || outlen == SIZE_MAX) {
 292         /* Variable-output algorithm */
 293         if (key == NULL)
 294             return 0;
 295     } else {
 296         /* Fixed-output algorithm */
 297         *keylen = outlen;
 298         if (key == NULL)
 299             return 1;
 300     }
 301     return EVP_KDF_derive(kctx, key, *keylen);
 302 }
 303
 304 #ifndef OPENSSL_NO_SCRYPT
 305 const EVP_PKEY_METHOD scrypt_pkey_meth = {
 306     EVP_PKEY_SCRYPT,
 307     0,
 308     pkey_kdf_init,
 309     0,
 310     pkey_kdf_cleanup,
 311
 312     0, 0,
 313     0, 0,
 314
 315     0,
 316     0,
 317
 318     0,
 319     0,
 320
 321     0, 0,
 322
 323     0, 0, 0, 0,
 324
 325     0, 0,
 326
 327     0, 0,
 328
 329     pkey_kdf_derive_init,
 330     pkey_kdf_derive,
 331     pkey_kdf_ctrl,
 332     pkey_kdf_ctrl_str
 333 };
 334 #endif
 335
 336 const EVP_PKEY_METHOD tls1_prf_pkey_meth = {
 337     EVP_PKEY_TLS1_PRF,
 338     0,
 339     pkey_kdf_init,
 340     0,
 341     pkey_kdf_cleanup,
 342
 343     0, 0,
 344     0, 0,
 345
 346     0,
 347     0,
 348
 349     0,
 350     0,
 351
 352     0, 0,
 353
 354     0, 0, 0, 0,
 355
 356     0, 0,
 357
 358     0, 0,
 359
 360     pkey_kdf_derive_init,
 361     pkey_kdf_derive,
 362     pkey_kdf_ctrl,
 363     pkey_kdf_ctrl_str
 364 };
 365
 366 const EVP_PKEY_METHOD hkdf_pkey_meth = {
 367     EVP_PKEY_HKDF,
 368     0,
 369     pkey_kdf_init,
 370     0,
 371     pkey_kdf_cleanup,
 372
 373     0, 0,
 374     0, 0,
 375
 376     0,
 377     0,
 378
 379     0,
 380     0,
 381
 382     0, 0,
 383
 384     0, 0, 0, 0,
 385
 386     0, 0,
 387
 388     0, 0,
 389
 390     pkey_kdf_derive_init,
 391     pkey_kdf_derive,
 392     pkey_kdf_ctrl,
 393     pkey_kdf_ctrl_str
 394 };
 395