Get rid of the diversity of names for MAC parameters
[openssl.git] / providers / common / macs / gmac_prov.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 <stdlib.h>
11 #include <openssl/core_numbers.h>
12 #include <openssl/core_names.h>
13 #include <openssl/params.h>
14 #include <openssl/engine.h>
15 #include <openssl/evp.h>
16 #include <openssl/err.h>
17
18 #include "internal/providercommonerr.h"
19 #include "internal/provider_algs.h"
20 #include "internal/provider_ctx.h"
21
22 /*
23  * Forward declaration of everything implemented here.  This is not strictly
24  * necessary for the compiler, but provides an assurance that the signatures
25  * of the functions in the dispatch table are correct.
26  */
27 static OSSL_OP_mac_newctx_fn gmac_new;
28 static OSSL_OP_mac_dupctx_fn gmac_dup;
29 static OSSL_OP_mac_freectx_fn gmac_free;
30 static OSSL_OP_mac_gettable_params_fn gmac_gettable_params;
31 static OSSL_OP_mac_get_params_fn gmac_get_params;
32 static OSSL_OP_mac_settable_ctx_params_fn gmac_settable_ctx_params;
33 static OSSL_OP_mac_set_ctx_params_fn gmac_set_ctx_params;
34 static OSSL_OP_mac_init_fn gmac_init;
35 static OSSL_OP_mac_update_fn gmac_update;
36 static OSSL_OP_mac_final_fn gmac_final;
37
38 /* local GMAC pkey structure */
39
40 struct gmac_data_st {
41     void *provctx;
42     EVP_CIPHER_CTX *ctx;         /* Cipher context */
43
44     /*
45      * References to the underlying cipher implementation.  |cipher| caches
46      * the cipher, always.  |alloc_cipher| only holds a reference to an
47      * explicitly fetched cipher.
48      * |cipher| is cleared after a CMAC_Init call.
49      */
50     const EVP_CIPHER *cipher;    /* Cache GCM cipher */
51     EVP_CIPHER *alloc_cipher;    /* Fetched cipher */
52
53     /*
54      * Conditions for legacy EVP_CIPHER uses.
55      */
56     ENGINE *engine;              /* Engine implementing the cipher */
57 };
58
59 static size_t gmac_size(void);
60
61 static void gmac_free(void *vmacctx)
62 {
63     struct gmac_data_st *macctx = vmacctx;
64
65     if (macctx != NULL) {
66         EVP_CIPHER_CTX_free(macctx->ctx);
67         EVP_CIPHER_meth_free(macctx->alloc_cipher);
68         OPENSSL_free(macctx);
69     }
70 }
71
72 static void *gmac_new(void *provctx)
73 {
74     struct gmac_data_st *macctx;
75
76     if ((macctx = OPENSSL_zalloc(sizeof(*macctx))) == NULL
77         || (macctx->ctx = EVP_CIPHER_CTX_new()) == NULL) {
78         gmac_free(macctx);
79         return NULL;
80     }
81     macctx->provctx = provctx;
82
83     return macctx;
84 }
85
86 static void *gmac_dup(void *vsrc)
87 {
88     struct gmac_data_st *src = vsrc;
89     struct gmac_data_st *dst = gmac_new(src->provctx);
90
91     if (dst == NULL)
92         return NULL;
93
94     if (!EVP_CIPHER_CTX_copy(dst->ctx, src->ctx)
95         || (src->alloc_cipher != NULL
96             && !EVP_CIPHER_up_ref(src->alloc_cipher))) {
97         gmac_free(dst);
98         return NULL;
99     }
100
101     dst->cipher = src->cipher;
102     dst->alloc_cipher = src->alloc_cipher;
103     dst->engine = src->engine;
104     return dst;
105 }
106
107 static int gmac_init(void *vmacctx)
108 {
109     return 1;
110 }
111
112 static int gmac_update(void *vmacctx, const unsigned char *data,
113                        size_t datalen)
114 {
115     struct gmac_data_st *macctx = vmacctx;
116     EVP_CIPHER_CTX *ctx = macctx->ctx;
117     int outlen;
118
119     while (datalen > INT_MAX) {
120         if (!EVP_EncryptUpdate(ctx, NULL, &outlen, data, INT_MAX))
121             return 0;
122         data += INT_MAX;
123         datalen -= INT_MAX;
124     }
125     return EVP_EncryptUpdate(ctx, NULL, &outlen, data, datalen);
126 }
127
128 static int gmac_final(void *vmacctx, unsigned char *out, size_t *outl,
129                       size_t outsize)
130 {
131     struct gmac_data_st *macctx = vmacctx;
132     int hlen = 0;
133
134     if (!EVP_EncryptFinal_ex(macctx->ctx, out, &hlen))
135         return 0;
136
137     /* TODO(3.0) Use params */
138     hlen = gmac_size();
139     if (!EVP_CIPHER_CTX_ctrl(macctx->ctx, EVP_CTRL_AEAD_GET_TAG,
140                              hlen, out))
141         return 0;
142
143     *outl = hlen;
144     return 1;
145 }
146
147 static size_t gmac_size(void)
148 {
149     return EVP_GCM_TLS_TAG_LEN;
150 }
151
152 static const OSSL_PARAM known_gettable_params[] = {
153     OSSL_PARAM_size_t(OSSL_MAC_PARAM_SIZE, NULL),
154     OSSL_PARAM_END
155 };
156 static const OSSL_PARAM *gmac_gettable_params(void)
157 {
158     return known_gettable_params;
159 }
160
161 static int gmac_get_params(OSSL_PARAM params[])
162 {
163     OSSL_PARAM *p;
164
165     if ((p = OSSL_PARAM_locate(params, OSSL_MAC_PARAM_SIZE)) != NULL)
166         return OSSL_PARAM_set_size_t(p, gmac_size());
167
168     return 1;
169 }
170
171 static const OSSL_PARAM known_settable_ctx_params[] = {
172     OSSL_PARAM_utf8_string(OSSL_MAC_PARAM_CIPHER, NULL, 0),
173     OSSL_PARAM_utf8_string(OSSL_MAC_PARAM_ENGINE, NULL, 0),
174     OSSL_PARAM_utf8_string(OSSL_MAC_PARAM_PROPERTIES, NULL, 0),
175     OSSL_PARAM_octet_string(OSSL_MAC_PARAM_KEY, NULL, 0),
176     OSSL_PARAM_octet_string(OSSL_MAC_PARAM_IV, NULL, 0),
177     OSSL_PARAM_END
178 };
179 static const OSSL_PARAM *gmac_settable_ctx_params(void)
180 {
181     return known_settable_ctx_params;
182 }
183
184 /*
185  * ALL parameters should be set before init().
186  */
187 static int gmac_set_ctx_params(void *vmacctx, const OSSL_PARAM params[])
188 {
189     struct gmac_data_st *macctx = vmacctx;
190     EVP_CIPHER_CTX *ctx = macctx->ctx;
191     const OSSL_PARAM *p;
192
193     if ((p = OSSL_PARAM_locate_const(params, OSSL_MAC_PARAM_CIPHER)) != NULL) {
194         if (p->data_type != OSSL_PARAM_UTF8_STRING)
195             return 0;
196
197         {
198             const char *algoname = p->data;
199             const char *propquery = NULL;
200
201 #ifndef FIPS_MODE /* Inside the FIPS module, we don't support engines */
202             ENGINE_finish(macctx->engine);
203             macctx->engine = NULL;
204
205             if ((p = OSSL_PARAM_locate_const(params, OSSL_MAC_PARAM_ENGINE))
206                 != NULL) {
207                 if (p->data_type != OSSL_PARAM_UTF8_STRING)
208                     return 0;
209
210                 macctx->engine = ENGINE_by_id(p->data);
211                 if (macctx->engine == NULL)
212                     return 0;
213             }
214 #endif
215             if ((p = OSSL_PARAM_locate_const(params,
216                                              OSSL_MAC_PARAM_PROPERTIES))
217                 != NULL) {
218                 if (p->data_type != OSSL_PARAM_UTF8_STRING)
219                     return 0;
220
221                 propquery = p->data;
222             }
223
224             EVP_CIPHER_meth_free(macctx->alloc_cipher);
225             macctx->cipher = macctx->alloc_cipher = NULL;
226
227             macctx->cipher = macctx->alloc_cipher =
228                 EVP_CIPHER_fetch(PROV_LIBRARY_CONTEXT_OF(macctx->provctx),
229                                  algoname, propquery);
230 #ifndef FIPS_MODE /* Inside the FIPS module, we don't support legacy ciphers */
231             /* TODO(3.0) BEGIN legacy stuff, to be removed */
232             if (macctx->cipher == NULL)
233                 macctx->cipher = EVP_get_cipherbyname(algoname);
234             /* TODO(3.0) END of legacy stuff */
235 #endif
236
237             if (macctx->cipher == NULL)
238                 return 0;
239
240             if (EVP_CIPHER_mode(macctx->cipher) != EVP_CIPH_GCM_MODE) {
241                 ERR_raise(ERR_LIB_PROV, EVP_R_CIPHER_NOT_GCM_MODE);
242                 return 0;
243             }
244         }
245         if (!EVP_EncryptInit_ex(ctx, macctx->cipher, macctx->engine,
246                                 NULL, NULL))
247             return 0;
248     }
249     if ((p = OSSL_PARAM_locate_const(params, OSSL_MAC_PARAM_KEY)) != NULL) {
250         if (p->data_type != OSSL_PARAM_OCTET_STRING)
251             return 0;
252
253         if (p->data_size != (size_t)EVP_CIPHER_CTX_key_length(ctx)) {
254             ERR_raise(ERR_LIB_PROV, EVP_R_INVALID_KEY_LENGTH);
255             return 0;
256         }
257         if (!EVP_EncryptInit_ex(ctx, NULL, NULL, p->data, NULL))
258             return 0;
259     }
260     if ((p = OSSL_PARAM_locate_const(params, OSSL_MAC_PARAM_IV)) != NULL) {
261         if (p->data_type != OSSL_PARAM_OCTET_STRING)
262             return 0;
263
264         if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN,
265                                  p->data_size, NULL)
266             || !EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, p->data))
267             return 0;
268     }
269     return 1;
270 }
271
272 const OSSL_DISPATCH gmac_functions[] = {
273     { OSSL_FUNC_MAC_NEWCTX, (void (*)(void))gmac_new },
274     { OSSL_FUNC_MAC_DUPCTX, (void (*)(void))gmac_dup },
275     { OSSL_FUNC_MAC_FREECTX, (void (*)(void))gmac_free },
276     { OSSL_FUNC_MAC_INIT, (void (*)(void))gmac_init },
277     { OSSL_FUNC_MAC_UPDATE, (void (*)(void))gmac_update },
278     { OSSL_FUNC_MAC_FINAL, (void (*)(void))gmac_final },
279     { OSSL_FUNC_MAC_GETTABLE_PARAMS, (void (*)(void))gmac_gettable_params },
280     { OSSL_FUNC_MAC_GET_PARAMS, (void (*)(void))gmac_get_params },
281     { OSSL_FUNC_MAC_SETTABLE_CTX_PARAMS,
282       (void (*)(void))gmac_settable_ctx_params },
283     { OSSL_FUNC_MAC_SET_CTX_PARAMS, (void (*)(void))gmac_set_ctx_params },
284     { 0, NULL }
285 };