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