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