Extend the provider MAC bridge for Poly1305
[openssl.git] / providers / implementations / signature / mac_legacy.c
1 /*
2  * Copyright 2019-2020 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 <openssl/crypto.h>
11 #include <openssl/evp.h>
12 #include <openssl/core_dispatch.h>
13 #include <openssl/core_names.h>
14 #include <openssl/params.h>
15 #include <openssl/err.h>
16 #include "prov/implementations.h"
17 #include "prov/provider_ctx.h"
18 #include "prov/macsignature.h"
19
20 static OSSL_FUNC_signature_newctx_fn mac_hmac_newctx;
21 static OSSL_FUNC_signature_digest_sign_init_fn mac_digest_sign_init;
22 static OSSL_FUNC_signature_digest_sign_update_fn mac_digest_sign_update;
23 static OSSL_FUNC_signature_digest_sign_final_fn mac_digest_sign_final;
24 static OSSL_FUNC_signature_freectx_fn mac_freectx;
25 static OSSL_FUNC_signature_dupctx_fn mac_dupctx;
26
27 typedef struct {
28     OPENSSL_CTX *libctx;
29     char *propq;
30     MAC_KEY *key;
31     EVP_MAC_CTX *macctx;
32 } PROV_MAC_CTX;
33
34 static void *mac_newctx(void *provctx, const char *propq, const char *macname)
35 {
36     PROV_MAC_CTX *pmacctx = OPENSSL_zalloc(sizeof(PROV_MAC_CTX));
37     EVP_MAC *mac = NULL;
38
39     if (pmacctx == NULL)
40         return NULL;
41
42     pmacctx->libctx = PROV_LIBRARY_CONTEXT_OF(provctx);
43     if (propq != NULL && (pmacctx->propq = OPENSSL_strdup(propq)) == NULL) {
44         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
45         goto err;
46     }
47
48     mac = EVP_MAC_fetch(pmacctx->libctx, macname, propq);
49     if (mac == NULL)
50         goto err;
51
52     pmacctx->macctx = EVP_MAC_CTX_new(mac);
53     if (pmacctx->macctx == NULL)
54         goto err;
55
56     EVP_MAC_free(mac);
57
58     return pmacctx;
59
60  err:
61     OPENSSL_free(pmacctx);
62     EVP_MAC_free(mac);
63     return NULL;
64 }
65
66 #define MAC_NEWCTX(funcname, macname) \
67     static void *mac_##funcname##_newctx(void *provctx, const char *propq) \
68     { \
69         return mac_newctx(provctx, propq, macname); \
70     }
71
72 MAC_NEWCTX(hmac, "HMAC")
73 MAC_NEWCTX(siphash, "SIPHASH")
74 MAC_NEWCTX(poly1305, "POLY1305")
75
76 static int mac_digest_sign_init(void *vpmacctx, const char *mdname, void *vkey)
77 {
78     PROV_MAC_CTX *pmacctx = (PROV_MAC_CTX *)vpmacctx;
79     OSSL_PARAM params[4], *p = params;
80
81     if (pmacctx == NULL || vkey == NULL || !mac_key_up_ref(vkey))
82         return 0;
83
84
85     mac_key_free(pmacctx->key);
86     pmacctx->key = vkey;
87
88     /* Read only so cast away of const is safe */
89     if (mdname != NULL)
90         *p++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST,
91                                                 (char *)mdname, 0);
92     *p++ = OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_KEY,
93                                              pmacctx->key->priv_key,
94                                              pmacctx->key->priv_key_len);
95     *p = OSSL_PARAM_construct_end();
96
97     if (!EVP_MAC_CTX_set_params(pmacctx->macctx, params))
98         return 0;
99
100     if (!EVP_MAC_init(pmacctx->macctx))
101         return 0;
102
103     return 1;
104 }
105
106 int mac_digest_sign_update(void *vpmacctx, const unsigned char *data,
107                            size_t datalen)
108 {
109     PROV_MAC_CTX *pmacctx = (PROV_MAC_CTX *)vpmacctx;
110
111     if (pmacctx == NULL || pmacctx->macctx == NULL)
112         return 0;
113
114     return EVP_MAC_update(pmacctx->macctx, data, datalen);
115 }
116
117 int mac_digest_sign_final(void *vpmacctx, unsigned char *mac, size_t *maclen,
118                           size_t macsize)
119 {
120     PROV_MAC_CTX *pmacctx = (PROV_MAC_CTX *)vpmacctx;
121
122     if (pmacctx == NULL || pmacctx->macctx == NULL)
123         return 0;
124
125     return EVP_MAC_final(pmacctx->macctx, mac, maclen, macsize);
126 }
127
128 static void mac_freectx(void *vpmacctx)
129 {
130     PROV_MAC_CTX *ctx = (PROV_MAC_CTX *)vpmacctx;
131
132     OPENSSL_free(ctx->propq);
133     EVP_MAC_CTX_free(ctx->macctx);
134     mac_key_free(ctx->key);
135     OPENSSL_free(ctx);
136 }
137
138 static void *mac_dupctx(void *vpmacctx)
139 {
140     PROV_MAC_CTX *srcctx = (PROV_MAC_CTX *)vpmacctx;
141     PROV_MAC_CTX *dstctx;
142
143     dstctx = OPENSSL_zalloc(sizeof(*srcctx));
144     if (dstctx == NULL)
145         return NULL;
146
147     *dstctx = *srcctx;
148     dstctx->key = NULL;
149     dstctx->macctx = NULL;
150
151     if (srcctx->key != NULL && !mac_key_up_ref(srcctx->key))
152         goto err;
153     dstctx->key = srcctx->key;
154
155     if (srcctx->macctx != NULL) {
156         dstctx->macctx = EVP_MAC_CTX_dup(srcctx->macctx);
157         if (dstctx->macctx == NULL)
158             goto err;
159     }
160
161     return dstctx;
162  err:
163     mac_freectx(dstctx);
164     return NULL;
165 }
166
167 #define MAC_SIGNATURE_FUNCTIONS(funcname) \
168     const OSSL_DISPATCH mac_##funcname##_signature_functions[] = { \
169         { OSSL_FUNC_SIGNATURE_NEWCTX, (void (*)(void))mac_##funcname##_newctx }, \
170         { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_INIT, \
171         (void (*)(void))mac_digest_sign_init }, \
172         { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_UPDATE, \
173         (void (*)(void))mac_digest_sign_update }, \
174         { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_FINAL, \
175         (void (*)(void))mac_digest_sign_final }, \
176         { OSSL_FUNC_SIGNATURE_FREECTX, (void (*)(void))mac_freectx }, \
177         { OSSL_FUNC_SIGNATURE_DUPCTX, (void (*)(void))mac_dupctx }, \
178         { 0, NULL } \
179     };
180
181 MAC_SIGNATURE_FUNCTIONS(hmac)
182 MAC_SIGNATURE_FUNCTIONS(siphash)
183 MAC_SIGNATURE_FUNCTIONS(poly1305)