Fix EVP_PKEY_new_mac_key()
[openssl.git] / crypto / evp / pkey_mac.c
1 /*
2  * Copyright 2018 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <string.h>
11 #include <openssl/err.h>
12 #include <openssl/evp.h>
13 #include <openssl/engine.h>
14 #include <openssl/params.h>
15 #include <openssl/core_names.h>
16 #include "crypto/evp.h"
17 #include "evp_local.h"
18
19 /* MAC PKEY context structure */
20
21 typedef struct {
22     EVP_MAC_CTX *ctx;
23
24     /*
25      * We know of two MAC types:
26      *
27      * 1. those who take a secret in raw form, i.e. raw data as a
28      *    ASN1_OCTET_STRING embedded in a EVP_PKEY.  So far, that's
29      *    all of them but CMAC.
30      * 2. those who take a secret with associated cipher in very generic
31      *    form, i.e. a complete EVP_MAC_CTX embedded in a PKEY.  So far,
32      *    only CMAC does this.
33      *
34      * (one might wonder why the second form isn't used for all)
35      */
36 #define MAC_TYPE_RAW    1   /* HMAC like MAC type (all but CMAC so far) */
37 #define MAC_TYPE_MAC    2   /* CMAC like MAC type (only CMAC known so far) */
38     int type;
39
40     /* The following is only used for MAC_TYPE_RAW implementations */
41     struct {
42         const EVP_MD *md;           /* temp storage of MD */
43         ASN1_OCTET_STRING ktmp;     /* temp storage for key */
44     } raw_data;
45 } MAC_PKEY_CTX;
46
47 static void pkey_mac_cleanup(EVP_PKEY_CTX *ctx);
48
49 static int pkey_mac_init(EVP_PKEY_CTX *ctx)
50 {
51     MAC_PKEY_CTX *hctx;
52     /* We're being smart and using the same base NIDs for PKEY and for MAC */
53     int nid = ctx->pmeth->pkey_id;
54     EVP_MAC *mac = EVP_MAC_fetch(ctx->libctx, OBJ_nid2sn(nid), ctx->propquery);
55
56     /*
57      * mac == NULL may actually be ok in some situations. In an
58      * EVP_PKEY_new_mac_key() call a temporary EVP_PKEY_CTX is created with
59      * default libctx. We don't actually need the underlying MAC to be present
60      * to successfully set the key in that case. The resulting EVP_PKEY could
61      * then be used in some other libctx where the MAC *is* present
62      */
63
64     if ((hctx = OPENSSL_zalloc(sizeof(*hctx))) == NULL) {
65         EVPerr(EVP_F_PKEY_MAC_INIT, ERR_R_MALLOC_FAILURE);
66         return 0;
67     }
68
69     if (mac != NULL) {
70         hctx->ctx = EVP_MAC_CTX_new(mac);
71         if (hctx->ctx == NULL) {
72             OPENSSL_free(hctx);
73             return 0;
74         }
75     }
76
77     if (nid == EVP_PKEY_CMAC) {
78         hctx->type = MAC_TYPE_MAC;
79     } else {
80         hctx->type = MAC_TYPE_RAW;
81         hctx->raw_data.ktmp.type = V_ASN1_OCTET_STRING;
82     }
83
84     pkey_mac_cleanup(ctx);
85     EVP_PKEY_CTX_set_data(ctx, hctx);
86     ctx->keygen_info_count = 0;
87
88     return 1;
89 }
90
91 static int pkey_mac_copy(EVP_PKEY_CTX *dst, const EVP_PKEY_CTX *src)
92 {
93     MAC_PKEY_CTX *sctx, *dctx;
94
95     sctx = EVP_PKEY_CTX_get_data(src);
96
97     if (sctx->ctx == NULL) {
98         /* This actually means the fetch failed during the init call */
99         EVPerr(0, EVP_R_FETCH_FAILED);
100         return 0;
101     }
102
103     if (sctx->ctx->data == NULL)
104         return 0;
105
106     dctx = OPENSSL_zalloc(sizeof(*dctx));
107     if (dctx == NULL) {
108         EVPerr(EVP_F_PKEY_MAC_COPY, ERR_R_MALLOC_FAILURE);
109         return 0;
110     }
111
112     EVP_PKEY_CTX_set_data(dst, dctx);
113     dst->keygen_info_count = 0;
114
115     dctx->ctx = EVP_MAC_CTX_dup(sctx->ctx);
116     if (dctx->ctx == NULL)
117         goto err;
118
119     /*
120      * Normally, nothing special would be done with the MAC method.  In
121      * this particular case, though, the MAC method was fetched internally
122      * by pkey_mac_init() above or by EVP_PKEY_new_CMAC_key() and passed
123      * via the EVP_MAC_CTX, so it is effectively like every new EVP_MAC_CTX
124      * fetches the MAC method anew in this case.  Therefore, its reference
125      * count must be adjusted here.
126      */
127     if (!EVP_MAC_up_ref(EVP_MAC_CTX_mac(dctx->ctx)))
128         goto err;
129
130     dctx->type = sctx->type;
131
132     switch (dctx->type) {
133     case MAC_TYPE_RAW:
134         dctx->raw_data.md = sctx->raw_data.md;
135         if (ASN1_STRING_get0_data(&sctx->raw_data.ktmp) != NULL &&
136             !ASN1_STRING_copy(&dctx->raw_data.ktmp, &sctx->raw_data.ktmp))
137             goto err;
138         break;
139     case MAC_TYPE_MAC:
140         /* Nothing more to do */
141         break;
142     default:
143         /* This should be dead code */
144         return 0;
145     }
146     return 1;
147  err:
148     pkey_mac_cleanup(dst);
149     return 0;
150 }
151
152 static void pkey_mac_cleanup(EVP_PKEY_CTX *ctx)
153 {
154     /*
155      * For the exact same reasons the MAC reference count is incremented
156      * in pkey_mac_copy() above, it must be explicitly freed here.
157      */
158
159     MAC_PKEY_CTX *hctx = ctx == NULL ? NULL : EVP_PKEY_CTX_get_data(ctx);
160
161     if (hctx != NULL) {
162         EVP_MAC *mac = hctx->ctx != NULL ? EVP_MAC_CTX_mac(hctx->ctx) : NULL;
163
164         switch (hctx->type) {
165         case MAC_TYPE_RAW:
166             OPENSSL_clear_free(hctx->raw_data.ktmp.data,
167                                hctx->raw_data.ktmp.length);
168             break;
169         }
170         EVP_MAC_CTX_free(hctx->ctx);
171         EVP_MAC_free(mac);
172         OPENSSL_free(hctx);
173         EVP_PKEY_CTX_set_data(ctx, NULL);
174     }
175 }
176
177 static int pkey_mac_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
178 {
179     MAC_PKEY_CTX *hctx = EVP_PKEY_CTX_get_data(ctx);
180     int nid = ctx->pmeth->pkey_id;
181
182     switch (hctx->type) {
183     case MAC_TYPE_RAW:
184         {
185             ASN1_OCTET_STRING *hkey = NULL;
186
187             if (!hctx->raw_data.ktmp.data)
188                 return 0;
189             hkey = ASN1_OCTET_STRING_dup(&hctx->raw_data.ktmp);
190             if (!hkey)
191                 return 0;
192             EVP_PKEY_assign(pkey, nid, hkey);
193         }
194         break;
195     case MAC_TYPE_MAC:
196         {
197             EVP_MAC_CTX *cmkey;
198
199             if (hctx->ctx == NULL) {
200                 /* This actually means the fetch failed during the init call */
201                 EVPerr(0, EVP_R_FETCH_FAILED);
202                 return 0;
203             }
204
205             cmkey = EVP_MAC_CTX_dup(hctx->ctx);
206             if (cmkey == NULL)
207                 return 0;
208             if (!EVP_MAC_up_ref(EVP_MAC_CTX_mac(hctx->ctx)))
209                 return 0;
210             EVP_PKEY_assign(pkey, nid, cmkey);
211         }
212         break;
213     default:
214         /* This should be dead code */
215         return 0;
216     }
217
218     return 1;
219 }
220
221 static int int_update(EVP_MD_CTX *ctx, const void *data, size_t count)
222 {
223     MAC_PKEY_CTX *hctx = EVP_PKEY_CTX_get_data(EVP_MD_CTX_pkey_ctx(ctx));
224
225     if (!EVP_MAC_update(hctx->ctx, data, count))
226         return 0;
227     return 1;
228 }
229
230 static int pkey_mac_signctx_init(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx)
231 {
232     MAC_PKEY_CTX *hctx = EVP_PKEY_CTX_get_data(ctx);
233     ASN1_OCTET_STRING *key = NULL;
234     int rv = 1;
235     /*
236      * For MACs with the EVP_PKEY_FLAG_SIGCTX_CUSTOM flag set and that
237      * gets the key passed as an ASN.1 OCTET STRING, we set the key here,
238      * as this may be only time it's set during a DigestSign.
239      *
240      * MACs that pass around the key in form of EVP_MAC_CTX are setting
241      * the key through other mechanisms.  (this is only CMAC for now)
242      */
243     int set_key =
244         hctx->type == MAC_TYPE_RAW
245         && (ctx->pmeth->flags & EVP_PKEY_FLAG_SIGCTX_CUSTOM) != 0;
246
247     if (hctx->ctx == NULL) {
248         /* This actually means the fetch failed during the init call */
249         EVPerr(0, EVP_R_FETCH_FAILED);
250         return 0;
251     }
252
253     if (set_key) {
254         if (!EVP_MAC_is_a(EVP_MAC_CTX_mac(hctx->ctx),
255                           OBJ_nid2sn(EVP_PKEY_id(EVP_PKEY_CTX_get0_pkey(ctx)))))
256             return 0;
257         key = EVP_PKEY_get0(EVP_PKEY_CTX_get0_pkey(ctx));
258         if (key == NULL)
259             return 0;
260     }
261
262     EVP_MD_CTX_set_flags(mctx, EVP_MD_CTX_FLAG_NO_INIT);
263     EVP_MD_CTX_set_update_fn(mctx, int_update);
264
265     /* Some MACs don't support this control...  that's fine */
266     {
267         OSSL_PARAM params[3];
268         size_t params_n = 0;
269         int flags = EVP_MD_CTX_test_flags(mctx, ~EVP_MD_CTX_FLAG_NO_INIT);
270
271         /* TODO(3.0) "flags" isn't quite right, i.e. a quick hack for now */
272         params[params_n++] =
273             OSSL_PARAM_construct_int(OSSL_MAC_PARAM_FLAGS, &flags);
274         if (set_key)
275             params[params_n++] =
276                 OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_KEY,
277                                                   key->data, key->length);
278         params[params_n++] = OSSL_PARAM_construct_end();
279         rv = EVP_MAC_CTX_set_params(hctx->ctx, params);
280     }
281     return rv;
282 }
283
284 static int pkey_mac_signctx(EVP_PKEY_CTX *ctx, unsigned char *sig,
285                              size_t *siglen, EVP_MD_CTX *mctx)
286 {
287     MAC_PKEY_CTX *hctx = EVP_PKEY_CTX_get_data(ctx);
288
289     return EVP_MAC_final(hctx->ctx, sig, siglen, EVP_MAC_size(hctx->ctx));
290 }
291
292 static int pkey_mac_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
293 {
294     MAC_PKEY_CTX *hctx = EVP_PKEY_CTX_get_data(ctx);
295
296     switch (type) {
297
298     case EVP_PKEY_CTRL_CIPHER:
299         switch (hctx->type) {
300         case MAC_TYPE_RAW:
301             return -2;       /* The raw types don't support ciphers */
302         case MAC_TYPE_MAC:
303             {
304                 OSSL_PARAM params[3];
305                 size_t params_n = 0;
306                 char *ciphname = (char *)OBJ_nid2sn(EVP_CIPHER_nid(p2));
307 #ifndef OPENSSL_NO_ENGINE
308                 char *engineid = (char *)ENGINE_get_id(ctx->engine);
309
310                 params[params_n++] =
311                     OSSL_PARAM_construct_utf8_string("engine", engineid, 0);
312 #endif
313                 params[params_n++] =
314                     OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_CIPHER,
315                                                      ciphname, 0);
316                 params[params_n] = OSSL_PARAM_construct_end();
317
318                 if (hctx->ctx == NULL) {
319                     /*
320                      * This actually means the fetch failed during the init call
321                      */
322                     EVPerr(0, EVP_R_FETCH_FAILED);
323                     return 0;
324                 }
325
326                 if (!EVP_MAC_CTX_set_params(hctx->ctx, params)
327                     || !EVP_MAC_init(hctx->ctx))
328                     return 0;
329             }
330             break;
331         default:
332             /* This should be dead code */
333             return 0;
334         }
335         break;
336
337     case EVP_PKEY_CTRL_MD:
338         switch (hctx->type) {
339         case MAC_TYPE_RAW:
340             hctx->raw_data.md = p2;
341             break;
342         case MAC_TYPE_MAC: {
343                 EVP_MAC_CTX *new_mac_ctx;
344
345                 if (ctx->pkey == NULL)
346                     return 0;
347                 new_mac_ctx = EVP_MAC_CTX_dup(ctx->pkey->pkey.ptr);
348                 if (new_mac_ctx == NULL)
349                     return 0;
350                 EVP_MAC_CTX_free(hctx->ctx);
351                 hctx->ctx = new_mac_ctx;
352             }
353             break;
354         default:
355             /* This should be dead code */
356             return 0;
357         }
358         break;
359
360     case EVP_PKEY_CTRL_SET_DIGEST_SIZE:
361         {
362             OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
363             size_t size = (size_t)p1;
364             size_t verify = 0;
365
366             /*
367              * We verify that the length is actually set by getting back
368              * the same parameter and checking that it matches what we
369              * tried to set.
370              * TODO(3.0) when we have a more direct mechanism to check if
371              * a parameter was used, we must refactor this to use that.
372              */
373
374             params[0] =
375                 OSSL_PARAM_construct_size_t(OSSL_MAC_PARAM_SIZE, &size);
376
377             if (hctx->ctx == NULL) {
378                 /*
379                  * This actually means the fetch failed during the init call
380                  */
381                 EVPerr(0, EVP_R_FETCH_FAILED);
382                 return 0;
383             }
384
385             if (!EVP_MAC_CTX_set_params(hctx->ctx, params))
386                 return 0;
387
388             params[0] =
389                 OSSL_PARAM_construct_size_t(OSSL_MAC_PARAM_SIZE, &verify);
390
391             if (!EVP_MAC_CTX_get_params(hctx->ctx, params))
392                 return 0;
393
394             /*
395              * Since EVP_MAC_CTX_{get,set}_params() returned successfully,
396              * we can only assume that the size was ignored, i.e. this
397              * control is unsupported.
398              */
399             if (verify != size)
400                 return -2;
401         }
402         break;
403     case EVP_PKEY_CTRL_SET_MAC_KEY:
404         switch (hctx->type) {
405         case MAC_TYPE_RAW:
406             if ((!p2 && p1 > 0) || (p1 < -1))
407                 return 0;
408             if (!ASN1_OCTET_STRING_set(&hctx->raw_data.ktmp, p2, p1))
409                 return 0;
410             break;
411         case MAC_TYPE_MAC:
412             {
413                 OSSL_PARAM params[2];
414                 size_t params_n = 0;
415
416                 params[params_n++] =
417                     OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_KEY,
418                                                       p2, p1);
419                 params[params_n] = OSSL_PARAM_construct_end();
420
421                 if (hctx->ctx == NULL) {
422                     /*
423                      * This actually means the fetch failed during the init call
424                      */
425                     EVPerr(0, EVP_R_FETCH_FAILED);
426                     return 0;
427                 }
428
429                 return EVP_MAC_CTX_set_params(hctx->ctx, params);
430             }
431             break;
432         default:
433             /* This should be dead code */
434             return 0;
435         }
436         break;
437
438     case EVP_PKEY_CTRL_DIGESTINIT:
439         switch (hctx->type) {
440         case MAC_TYPE_RAW:
441             if (hctx->ctx == NULL) {
442                 /* This actually means the fetch failed during the init call */
443                 EVPerr(0, EVP_R_FETCH_FAILED);
444                 return 0;
445             }
446
447             /* Ensure that we have attached the implementation */
448             if (!EVP_MAC_init(hctx->ctx))
449                 return 0;
450             {
451                 ASN1_OCTET_STRING *key =
452                     (ASN1_OCTET_STRING *)ctx->pkey->pkey.ptr;
453                 OSSL_PARAM params[4];
454                 size_t params_n = 0;
455                 char *mdname =
456                     (char *)OBJ_nid2sn(EVP_MD_nid(hctx->raw_data.md));
457 #ifndef OPENSSL_NO_ENGINE
458                 char *engineid = ctx->engine == NULL
459                     ? NULL : (char *)ENGINE_get_id(ctx->engine);
460
461                 if (engineid != NULL)
462                     params[params_n++] =
463                         OSSL_PARAM_construct_utf8_string("engine", engineid, 0);
464 #endif
465                 params[params_n++] =
466                     OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST,
467                                                      mdname, 0);
468                 params[params_n++] =
469                     OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_KEY,
470                                                       key->data, key->length);
471                 params[params_n] = OSSL_PARAM_construct_end();
472
473                 return EVP_MAC_CTX_set_params(hctx->ctx, params);
474             }
475             break;
476         case MAC_TYPE_MAC:
477             return -2;       /* The mac types don't support ciphers */
478         default:
479             /* This should be dead code */
480             return 0;
481         }
482         break;
483
484     default:
485         return -2;
486
487     }
488     return 1;
489 }
490
491 static int pkey_mac_ctrl_str(EVP_PKEY_CTX *ctx,
492                               const char *type, const char *value)
493 {
494     MAC_PKEY_CTX *hctx = EVP_PKEY_CTX_get_data(ctx);
495     const EVP_MAC *mac = EVP_MAC_CTX_mac(hctx->ctx);
496     OSSL_PARAM params[2];
497     int ok = 0;
498
499     /*
500      * Translation of some control names that are equivalent to a single
501      * parameter name.
502      *
503      * "md" and "digest" are the same thing, we use the single "digest"
504      *
505      * "digestsize" was a setting control in siphash, but naming wise,
506      * it's really the same as "size".
507      */
508     if (strcmp(type, "md") == 0)
509         type = OSSL_MAC_PARAM_DIGEST;
510     else if (strcmp(type, "digestsize") == 0)
511         type = OSSL_MAC_PARAM_SIZE;
512
513     if (!OSSL_PARAM_allocate_from_text(&params[0],
514                                        EVP_MAC_settable_ctx_params(mac),
515                                        type, value, strlen(value) + 1, NULL))
516         return 0;
517     params[1] = OSSL_PARAM_construct_end();
518
519     if (hctx->ctx == NULL) {
520         /* This actually means the fetch failed during the init call */
521         EVPerr(0, EVP_R_FETCH_FAILED);
522         return 0;
523     }
524
525     ok = EVP_MAC_CTX_set_params(hctx->ctx, params);
526     OPENSSL_free(params[0].data);
527     return ok;
528 }
529
530 static const EVP_PKEY_METHOD cmac_pkey_meth = {
531     EVP_PKEY_CMAC,
532     EVP_PKEY_FLAG_SIGCTX_CUSTOM,
533     pkey_mac_init,
534     pkey_mac_copy,
535     pkey_mac_cleanup,
536
537     0, 0,
538
539     0,
540     pkey_mac_keygen,
541
542     0, 0,
543
544     0, 0,
545
546     0, 0,
547
548     pkey_mac_signctx_init,
549     pkey_mac_signctx,
550
551     0, 0,
552
553     0, 0,
554
555     0, 0,
556
557     0, 0,
558
559     pkey_mac_ctrl,
560     pkey_mac_ctrl_str
561 };
562
563 const EVP_PKEY_METHOD *cmac_pkey_method(void)
564 {
565     return &cmac_pkey_meth;
566 }
567
568 static const EVP_PKEY_METHOD hmac_pkey_meth = {
569     EVP_PKEY_HMAC,
570     0,
571     pkey_mac_init,
572     pkey_mac_copy,
573     pkey_mac_cleanup,
574
575     0, 0,
576
577     0,
578     pkey_mac_keygen,
579
580     0, 0,
581
582     0, 0,
583
584     0, 0,
585
586     pkey_mac_signctx_init,
587     pkey_mac_signctx,
588
589     0, 0,
590
591     0, 0,
592
593     0, 0,
594
595     0, 0,
596
597     pkey_mac_ctrl,
598     pkey_mac_ctrl_str
599 };
600
601 const EVP_PKEY_METHOD *hmac_pkey_method(void)
602 {
603     return &hmac_pkey_meth;
604 }
605
606 static const EVP_PKEY_METHOD siphash_pkey_meth = {
607     EVP_PKEY_SIPHASH,
608     EVP_PKEY_FLAG_SIGCTX_CUSTOM,
609     pkey_mac_init,
610     pkey_mac_copy,
611     pkey_mac_cleanup,
612
613     0, 0,
614
615     0,
616     pkey_mac_keygen,
617
618     0, 0,
619
620     0, 0,
621
622     0, 0,
623
624     pkey_mac_signctx_init,
625     pkey_mac_signctx,
626
627     0, 0,
628
629     0, 0,
630
631     0, 0,
632
633     0, 0,
634
635     pkey_mac_ctrl,
636     pkey_mac_ctrl_str
637 };
638
639 const EVP_PKEY_METHOD *siphash_pkey_method(void)
640 {
641     return &siphash_pkey_meth;
642 }
643
644 static const EVP_PKEY_METHOD poly1305_pkey_meth = {
645     EVP_PKEY_POLY1305,
646     EVP_PKEY_FLAG_SIGCTX_CUSTOM,
647     pkey_mac_init,
648     pkey_mac_copy,
649     pkey_mac_cleanup,
650
651     0, 0,
652
653     0,
654     pkey_mac_keygen,
655
656     0, 0,
657
658     0, 0,
659
660     0, 0,
661
662     pkey_mac_signctx_init,
663     pkey_mac_signctx,
664
665     0, 0,
666
667     0, 0,
668
669     0, 0,
670
671     0, 0,
672
673     pkey_mac_ctrl,
674     pkey_mac_ctrl_str
675 };
676
677 const EVP_PKEY_METHOD *poly1305_pkey_method(void)
678 {
679     return &poly1305_pkey_meth;
680 }