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 "crypto/evp.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     if (data != NULL && datalen > 0) {
  86         i = (*collector)->length; /* BUF_MEM_grow() changes it! */
  87
  88         if (!BUF_MEM_grow(*collector, i + datalen))
  89             return 0;
  90         memcpy((*collector)->data + i, data, datalen);
  91     }
  92     return 1;
  93 }
  94
  95 static int pkey_kdf_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
  96 {
  97     EVP_PKEY_KDF_CTX *pkctx = ctx->data;
  98     EVP_KDF_CTX *kctx = pkctx->kctx;
  99     enum { T_OCTET_STRING, T_UINT64, T_DIGEST, T_INT } cmd;
 100     const char *name, *mdname;
 101     BUF_MEM **collector = NULL;
 102     OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
 103
 104     switch (type) {
 105     case EVP_PKEY_CTRL_PASS:
 106         cmd = T_OCTET_STRING;
 107         name = OSSL_KDF_PARAM_PASSWORD;
 108         break;
 109     case EVP_PKEY_CTRL_HKDF_SALT:
 110     case EVP_PKEY_CTRL_SCRYPT_SALT:
 111         cmd = T_OCTET_STRING;
 112         name = OSSL_KDF_PARAM_SALT;
 113         break;
 114     case EVP_PKEY_CTRL_TLS_MD:
 115     case EVP_PKEY_CTRL_HKDF_MD:
 116         cmd = T_DIGEST;
 117         name = OSSL_KDF_PARAM_DIGEST;
 118         break;
 119     case EVP_PKEY_CTRL_TLS_SECRET:
 120         cmd = T_OCTET_STRING;
 121         name = OSSL_KDF_PARAM_SECRET;
 122         /*
 123          * Perform the semantics described in
 124          * EVP_PKEY_CTX_add1_tls1_prf_seed(3)
 125          */
 126         if (ctx->pmeth->pkey_id == NID_tls1_prf) {
 127             BUF_MEM_free(pkctx->collected_seed);
 128             pkctx->collected_seed = NULL;
 129         }
 130         break;
 131     case EVP_PKEY_CTRL_TLS_SEED:
 132         cmd = T_OCTET_STRING;
 133         name = OSSL_KDF_PARAM_SEED;
 134         collector = &pkctx->collected_seed;
 135         break;
 136     case EVP_PKEY_CTRL_HKDF_KEY:
 137         cmd = T_OCTET_STRING;
 138         name = OSSL_KDF_PARAM_KEY;
 139         break;
 140     case EVP_PKEY_CTRL_HKDF_INFO:
 141         cmd = T_OCTET_STRING;
 142         name = OSSL_KDF_PARAM_INFO;
 143         collector = &pkctx->collected_info;
 144         break;
 145     case EVP_PKEY_CTRL_HKDF_MODE:
 146         cmd = T_INT;
 147         name = OSSL_KDF_PARAM_MODE;
 148         break;
 149     case EVP_PKEY_CTRL_SCRYPT_N:
 150         cmd = T_UINT64;
 151         name = OSSL_KDF_PARAM_SCRYPT_N;
 152         break;
 153     case EVP_PKEY_CTRL_SCRYPT_R:
 154         cmd = T_UINT64; /* Range checking occurs on the provider side */
 155         name = OSSL_KDF_PARAM_SCRYPT_R;
 156         break;
 157     case EVP_PKEY_CTRL_SCRYPT_P:
 158         cmd = T_UINT64; /* Range checking occurs on the provider side */
 159         name = OSSL_KDF_PARAM_SCRYPT_P;
 160         break;
 161     case EVP_PKEY_CTRL_SCRYPT_MAXMEM_BYTES:
 162         cmd = T_UINT64;
 163         name = OSSL_KDF_PARAM_SCRYPT_MAXMEM;
 164         break;
 165     default:
 166         return -2;
 167     }
 168
 169     if (collector != NULL) {
 170         switch (cmd) {
 171         case T_OCTET_STRING:
 172             return collect(collector, p2, p1);
 173         default:
 174             OPENSSL_assert("You shouldn't be here");
 175             break;
 176         }
 177         return 1;
 178     }
 179
 180     switch (cmd) {
 181     case T_OCTET_STRING:
 182         params[0] =
 183             OSSL_PARAM_construct_octet_string(name, (unsigned char *)p2,
 184                                               (size_t)p1);
 185         break;
 186
 187     case T_DIGEST:
 188         mdname = EVP_MD_name((const EVP_MD *)p2);
 189         params[0] = OSSL_PARAM_construct_utf8_string(name, (char *)mdname, 0);
 190         break;
 191
 192         /*
 193          * These are special because the helper macros pass a pointer to the
 194          * stack, so a local copy is required.
 195          */
 196     case T_INT:
 197         params[0] = OSSL_PARAM_construct_int(name, &p1);
 198         break;
 199
 200     case T_UINT64:
 201         params[0] = OSSL_PARAM_construct_uint64(name, (uint64_t *)p2);
 202         break;
 203     }
 204
 205     return EVP_KDF_CTX_set_params(kctx, params);
 206 }
 207
 208 static int pkey_kdf_ctrl_str(EVP_PKEY_CTX *ctx, const char *type,
 209                              const char *value)
 210 {
 211     EVP_PKEY_KDF_CTX *pkctx = ctx->data;
 212     EVP_KDF_CTX *kctx = pkctx->kctx;
 213     const EVP_KDF *kdf = EVP_KDF_CTX_kdf(kctx);
 214     BUF_MEM **collector = NULL;
 215     const OSSL_PARAM *defs = EVP_KDF_settable_ctx_params(kdf);
 216     OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
 217     int ok = 0;
 218
 219     /* Deal with ctrl name aliasing */
 220     if (strcmp(type, "md") == 0)
 221         type = OSSL_KDF_PARAM_DIGEST;
 222     /* scrypt uses 'N', params uses 'n' */
 223     if (strcmp(type, "N") == 0)
 224         type = OSSL_KDF_PARAM_SCRYPT_N;
 225
 226     if (!OSSL_PARAM_allocate_from_text(&params[0], defs, type,
 227                                        value, strlen(value), NULL))
 228         return 0;
 229
 230     /*
 231      * We do the same special casing of seed and info here as in
 232      * pkey_kdf_ctrl()
 233      */
 234     if (strcmp(params[0].key, OSSL_KDF_PARAM_SEED) == 0)
 235         collector = &pkctx->collected_seed;
 236     else if (strcmp(params[0].key, OSSL_KDF_PARAM_INFO) == 0)
 237         collector = &pkctx->collected_info;
 238
 239     if (collector != NULL)
 240         ok = collect(collector, params[0].data, params[0].data_size);
 241     else
 242         ok = EVP_KDF_CTX_set_params(kctx, params);
 243     OPENSSL_free(params[0].data);
 244     return ok;
 245 }
 246
 247 static int pkey_kdf_derive_init(EVP_PKEY_CTX *ctx)
 248 {
 249     EVP_PKEY_KDF_CTX *pkctx = ctx->data;
 250
 251     pkey_kdf_free_collected(pkctx);
 252     if (pkctx->kctx != NULL)
 253         EVP_KDF_reset(pkctx->kctx);
 254     return 1;
 255 }
 256
 257 /*
 258  * For fixed-output algorithms the keylen parameter is an "out" parameter
 259  * otherwise it is an "in" parameter.
 260  */
 261 static int pkey_kdf_derive(EVP_PKEY_CTX *ctx, unsigned char *key,
 262                            size_t *keylen)
 263 {
 264     EVP_PKEY_KDF_CTX *pkctx = ctx->data;
 265     EVP_KDF_CTX *kctx = pkctx->kctx;
 266     size_t outlen = EVP_KDF_size(kctx);
 267     int r;
 268
 269     if (pkctx->collected_seed != NULL) {
 270         OSSL_PARAM params[] = { OSSL_PARAM_END, OSSL_PARAM_END };
 271
 272         params[0] =
 273             OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED,
 274                                               pkctx->collected_seed->data,
 275                                               pkctx->collected_seed->length);
 276
 277         r = EVP_KDF_CTX_set_params(kctx, params);
 278         pkey_kdf_free_collected(pkctx);
 279         if (!r)
 280             return 0;
 281     }
 282     if (pkctx->collected_info != NULL) {
 283         OSSL_PARAM params[] = { OSSL_PARAM_END, OSSL_PARAM_END };
 284
 285         params[0] =
 286             OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_INFO,
 287                                               pkctx->collected_info->data,
 288                                               pkctx->collected_info->length);
 289
 290         r = EVP_KDF_CTX_set_params(kctx, params);
 291         pkey_kdf_free_collected(pkctx);
 292         if (!r)
 293             return 0;
 294     }
 295     if (outlen == 0 || outlen == SIZE_MAX) {
 296         /* Variable-output algorithm */
 297         if (key == NULL)
 298             return 0;
 299     } else {
 300         /* Fixed-output algorithm */
 301         *keylen = outlen;
 302         if (key == NULL)
 303             return 1;
 304     }
 305     return EVP_KDF_derive(kctx, key, *keylen);
 306 }
 307
 308 #ifndef OPENSSL_NO_SCRYPT
 309 static const EVP_PKEY_METHOD scrypt_pkey_meth = {
 310     EVP_PKEY_SCRYPT,
 311     0,
 312     pkey_kdf_init,
 313     0,
 314     pkey_kdf_cleanup,
 315
 316     0, 0,
 317     0, 0,
 318
 319     0,
 320     0,
 321
 322     0,
 323     0,
 324
 325     0, 0,
 326
 327     0, 0, 0, 0,
 328
 329     0, 0,
 330
 331     0, 0,
 332
 333     pkey_kdf_derive_init,
 334     pkey_kdf_derive,
 335     pkey_kdf_ctrl,
 336     pkey_kdf_ctrl_str
 337 };
 338
 339 const EVP_PKEY_METHOD *scrypt_pkey_method(void)
 340 {
 341     return &scrypt_pkey_meth;
 342 }
 343 #endif
 344
 345 static const EVP_PKEY_METHOD tls1_prf_pkey_meth = {
 346     EVP_PKEY_TLS1_PRF,
 347     0,
 348     pkey_kdf_init,
 349     0,
 350     pkey_kdf_cleanup,
 351
 352     0, 0,
 353     0, 0,
 354
 355     0,
 356     0,
 357
 358     0,
 359     0,
 360
 361     0, 0,
 362
 363     0, 0, 0, 0,
 364
 365     0, 0,
 366
 367     0, 0,
 368
 369     pkey_kdf_derive_init,
 370     pkey_kdf_derive,
 371     pkey_kdf_ctrl,
 372     pkey_kdf_ctrl_str
 373 };
 374
 375 const EVP_PKEY_METHOD *tls1_prf_pkey_method(void)
 376 {
 377     return &tls1_prf_pkey_meth;
 378 }
 379
 380 static const EVP_PKEY_METHOD hkdf_pkey_meth = {
 381     EVP_PKEY_HKDF,
 382     0,
 383     pkey_kdf_init,
 384     0,
 385     pkey_kdf_cleanup,
 386
 387     0, 0,
 388     0, 0,
 389
 390     0,
 391     0,
 392
 393     0,
 394     0,
 395
 396     0, 0,
 397
 398     0, 0, 0, 0,
 399
 400     0, 0,
 401
 402     0, 0,
 403
 404     pkey_kdf_derive_init,
 405     pkey_kdf_derive,
 406     pkey_kdf_ctrl,
 407     pkey_kdf_ctrl_str
 408 };
 409
 410 const EVP_PKEY_METHOD *hkdf_pkey_method(void)
 411 {
 412     return &hkdf_pkey_meth;
 413 }