f32d2131a753c5ff7d8a34a8163aaaa1d58c1eff
[openssl.git] / 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     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,
190                                                      strlen(mdname) + 1);
191         break;
192
193         /*
194          * These are special because the helper macros pass a pointer to the
195          * stack, so a local copy is required.
196          */
197     case T_INT:
198         params[0] = OSSL_PARAM_construct_int(name, &p1);
199         break;
200
201     case T_UINT64:
202         params[0] = OSSL_PARAM_construct_uint64(name, (uint64_t *)p2);
203         break;
204     }
205
206     return EVP_KDF_CTX_set_params(kctx, params);
207 }
208
209 static int pkey_kdf_ctrl_str(EVP_PKEY_CTX *ctx, const char *type,
210                              const char *value)
211 {
212     EVP_PKEY_KDF_CTX *pkctx = ctx->data;
213     EVP_KDF_CTX *kctx = pkctx->kctx;
214     const EVP_KDF *kdf = EVP_KDF_CTX_kdf(kctx);
215     BUF_MEM **collector = NULL;
216     const OSSL_PARAM *defs = EVP_KDF_CTX_settable_params(kdf);
217     OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
218     int ok = 0;
219
220     /* Deal with ctrl name aliasing */
221     if (strcmp(type, "md") == 0)
222         type = OSSL_KDF_PARAM_DIGEST;
223     /* scrypt uses 'N', params uses 'n' */
224     if (strcmp(type, "N") == 0)
225         type = OSSL_KDF_PARAM_SCRYPT_N;
226
227     if (!OSSL_PARAM_allocate_from_text(&params[0], defs, type,
228                                        value, strlen(value)))
229         return 0;
230
231     /*
232      * We do the same special casing of seed and info here as in
233      * pkey_kdf_ctrl()
234      */
235     if (strcmp(params[0].key, OSSL_KDF_PARAM_SEED) == 0)
236         collector = &pkctx->collected_seed;
237     else if (strcmp(params[0].key, OSSL_KDF_PARAM_INFO) == 0)
238         collector = &pkctx->collected_info;
239
240     if (collector != NULL)
241         ok = collect(collector, params[0].data, params[0].data_size);
242     else
243         ok = EVP_KDF_CTX_set_params(kctx, params);
244     OPENSSL_free(params[0].data);
245     return ok;
246 }
247
248 static int pkey_kdf_derive_init(EVP_PKEY_CTX *ctx)
249 {
250     EVP_PKEY_KDF_CTX *pkctx = ctx->data;
251
252     pkey_kdf_free_collected(pkctx);
253     if (pkctx->kctx != NULL)
254         EVP_KDF_reset(pkctx->kctx);
255     return 1;
256 }
257
258 /*
259  * For fixed-output algorithms the keylen parameter is an "out" parameter
260  * otherwise it is an "in" parameter.
261  */
262 static int pkey_kdf_derive(EVP_PKEY_CTX *ctx, unsigned char *key,
263                            size_t *keylen)
264 {
265     EVP_PKEY_KDF_CTX *pkctx = ctx->data;
266     EVP_KDF_CTX *kctx = pkctx->kctx;
267     size_t outlen = EVP_KDF_size(kctx);
268     int r;
269
270     if (pkctx->collected_seed != NULL) {
271         OSSL_PARAM params[] = { OSSL_PARAM_END, OSSL_PARAM_END };
272
273         params[0] =
274             OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED,
275                                               pkctx->collected_seed->data,
276                                               pkctx->collected_seed->length);
277
278         r = EVP_KDF_CTX_set_params(kctx, params);
279         pkey_kdf_free_collected(pkctx);
280         if (!r)
281             return 0;
282     }
283     if (pkctx->collected_info != NULL) {
284         OSSL_PARAM params[] = { OSSL_PARAM_END, OSSL_PARAM_END };
285
286         params[0] =
287             OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_INFO,
288                                               pkctx->collected_info->data,
289                                               pkctx->collected_info->length);
290
291         r = EVP_KDF_CTX_set_params(kctx, params);
292         pkey_kdf_free_collected(pkctx);
293         if (!r)
294             return 0;
295     }
296     if (outlen == 0 || outlen == SIZE_MAX) {
297         /* Variable-output algorithm */
298         if (key == NULL)
299             return 0;
300     } else {
301         /* Fixed-output algorithm */
302         *keylen = outlen;
303         if (key == NULL)
304             return 1;
305     }
306     return EVP_KDF_derive(kctx, key, *keylen);
307 }
308
309 #ifndef OPENSSL_NO_SCRYPT
310 const EVP_PKEY_METHOD scrypt_pkey_meth = {
311     EVP_PKEY_SCRYPT,
312     0,
313     pkey_kdf_init,
314     0,
315     pkey_kdf_cleanup,
316
317     0, 0,
318     0, 0,
319
320     0,
321     0,
322
323     0,
324     0,
325
326     0, 0,
327
328     0, 0, 0, 0,
329
330     0, 0,
331
332     0, 0,
333
334     pkey_kdf_derive_init,
335     pkey_kdf_derive,
336     pkey_kdf_ctrl,
337     pkey_kdf_ctrl_str
338 };
339 #endif
340
341 const EVP_PKEY_METHOD tls1_prf_pkey_meth = {
342     EVP_PKEY_TLS1_PRF,
343     0,
344     pkey_kdf_init,
345     0,
346     pkey_kdf_cleanup,
347
348     0, 0,
349     0, 0,
350
351     0,
352     0,
353
354     0,
355     0,
356
357     0, 0,
358
359     0, 0, 0, 0,
360
361     0, 0,
362
363     0, 0,
364
365     pkey_kdf_derive_init,
366     pkey_kdf_derive,
367     pkey_kdf_ctrl,
368     pkey_kdf_ctrl_str
369 };
370
371 const EVP_PKEY_METHOD hkdf_pkey_meth = {
372     EVP_PKEY_HKDF,
373     0,
374     pkey_kdf_init,
375     0,
376     pkey_kdf_cleanup,
377
378     0, 0,
379     0, 0,
380
381     0,
382     0,
383
384     0,
385     0,
386
387     0, 0,
388
389     0, 0, 0, 0,
390
391     0, 0,
392
393     0, 0,
394
395     pkey_kdf_derive_init,
396     pkey_kdf_derive,
397     pkey_kdf_ctrl,
398     pkey_kdf_ctrl_str
399 };
400