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