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