Set cipher IV as octet string and pointer from providers
[openssl.git] / providers / implementations / ciphers / ciphercommon_ccm.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 /* Dispatch functions for ccm mode */
11
12 #include "prov/ciphercommon.h"
13 #include "prov/ciphercommon_ccm.h"
14 #include "prov/providercommonerr.h"
15
16 static int ccm_cipher_internal(PROV_CCM_CTX *ctx, unsigned char *out,
17                                size_t *padlen, const unsigned char *in,
18                                size_t len);
19
20 static int ccm_tls_init(PROV_CCM_CTX *ctx, unsigned char *aad, size_t alen)
21 {
22     size_t len;
23
24     if (alen != EVP_AEAD_TLS1_AAD_LEN)
25         return 0;
26
27     /* Save the aad for later use. */
28     memcpy(ctx->buf, aad, alen);
29     ctx->tls_aad_len = alen;
30
31     len = ctx->buf[alen - 2] << 8 | ctx->buf[alen - 1];
32     if (len < EVP_CCM_TLS_EXPLICIT_IV_LEN)
33         return 0;
34
35     /* Correct length for explicit iv. */
36     len -= EVP_CCM_TLS_EXPLICIT_IV_LEN;
37
38     if (!ctx->enc) {
39         if (len < ctx->m)
40             return 0;
41         /* Correct length for tag. */
42         len -= ctx->m;
43     }
44     ctx->buf[alen - 2] = (unsigned char)(len >> 8);
45     ctx->buf[alen - 1] = (unsigned char)(len & 0xff);
46
47     /* Extra padding: tag appended to record. */
48     return ctx->m;
49 }
50
51 static int ccm_tls_iv_set_fixed(PROV_CCM_CTX *ctx, unsigned char *fixed,
52                                 size_t flen)
53 {
54     if (flen != EVP_CCM_TLS_FIXED_IV_LEN)
55         return 0;
56
57     /* Copy to first part of the iv. */
58     memcpy(ctx->iv, fixed, flen);
59     return 1;
60 }
61
62 static size_t ccm_get_ivlen(PROV_CCM_CTX *ctx)
63 {
64     return 15 - ctx->l;
65 }
66
67 int ccm_set_ctx_params(void *vctx, const OSSL_PARAM params[])
68 {
69     PROV_CCM_CTX *ctx = (PROV_CCM_CTX *)vctx;
70     const OSSL_PARAM *p;
71     size_t sz;
72
73     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_AEAD_TAG);
74     if (p != NULL) {
75         if (p->data_type != OSSL_PARAM_OCTET_STRING) {
76             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
77             return 0;
78         }
79         if ((p->data_size & 1) || (p->data_size < 4) || p->data_size > 16) {
80             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_TAGLEN);
81             return 0;
82         }
83
84         if (p->data != NULL) {
85             if (ctx->enc) {
86                 ERR_raise(ERR_LIB_PROV, PROV_R_TAG_NOT_NEEDED);
87                 return 0;
88             }
89             memcpy(ctx->buf, p->data, p->data_size);
90             ctx->tag_set = 1;
91         }
92         ctx->m = p->data_size;
93     }
94
95     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_AEAD_IVLEN);
96     if (p != NULL) {
97         size_t ivlen;
98
99         if (!OSSL_PARAM_get_size_t(p, &sz)) {
100             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
101             return 0;
102         }
103         ivlen = 15 - sz;
104         if (ivlen < 2 || ivlen > 8) {
105             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IVLEN);
106             return 0;
107         }
108         ctx->l = ivlen;
109     }
110
111     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_AEAD_TLS1_AAD);
112     if (p != NULL) {
113         if (p->data_type != OSSL_PARAM_OCTET_STRING) {
114             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
115             return 0;
116         }
117         sz = ccm_tls_init(ctx, p->data, p->data_size);
118         if (sz == 0) {
119             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_DATA);
120             return 0;
121         }
122         ctx->tls_aad_pad_sz = sz;
123     }
124
125     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED);
126     if (p != NULL) {
127         if (p->data_type != OSSL_PARAM_OCTET_STRING) {
128             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
129             return 0;
130         }
131         if (ccm_tls_iv_set_fixed(ctx, p->data, p->data_size) == 0) {
132             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IVLEN);
133             return 0;
134         }
135     }
136
137     return 1;
138 }
139
140 int ccm_get_ctx_params(void *vctx, OSSL_PARAM params[])
141 {
142     PROV_CCM_CTX *ctx = (PROV_CCM_CTX *)vctx;
143     OSSL_PARAM *p;
144
145     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN);
146     if (p != NULL && !OSSL_PARAM_set_size_t(p, ccm_get_ivlen(ctx))) {
147         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
148         return 0;
149     }
150
151     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_AEAD_TAGLEN);
152     if (p != NULL) {
153         size_t m = ctx->m;
154
155         if (!OSSL_PARAM_set_size_t(p, m)) {
156             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
157             return 0;
158         }
159     }
160
161     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IV);
162     if (p != NULL) {
163         if (ccm_get_ivlen(ctx) != p->data_size) {
164             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IVLEN);
165             return 0;
166         }
167         if (!OSSL_PARAM_set_octet_string(p, ctx->iv, p->data_size)
168             && !OSSL_PARAM_set_octet_ptr(p, &ctx->iv, p->data_size)) {
169             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
170             return 0;
171         }
172     }
173
174     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN);
175     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->keylen)) {
176         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
177         return 0;
178     }
179
180     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD);
181     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->tls_aad_pad_sz)) {
182         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
183         return 0;
184     }
185
186     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_AEAD_TAG);
187     if (p != NULL) {
188         if (!ctx->enc || !ctx->tag_set) {
189             ERR_raise(ERR_LIB_PROV, PROV_R_TAG_NOTSET);
190             return 0;
191         }
192         if (p->data_type != OSSL_PARAM_OCTET_STRING) {
193             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
194             return 0;
195         }
196         if (!ctx->hw->gettag(ctx, p->data, p->data_size))
197             return 0;
198         ctx->tag_set = 0;
199         ctx->iv_set = 0;
200         ctx->len_set = 0;
201     }
202     return 1;
203 }
204
205 static int ccm_init(void *vctx, const unsigned char *key, size_t keylen,
206                     const unsigned char *iv, size_t ivlen, int enc)
207 {
208     PROV_CCM_CTX *ctx = (PROV_CCM_CTX *)vctx;
209
210     ctx->enc = enc;
211
212     if (iv != NULL) {
213         if (ivlen != ccm_get_ivlen(ctx)) {
214             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IVLEN);
215             return 0;
216         }
217         memcpy(ctx->iv, iv, ivlen);
218         ctx->iv_set = 1;
219     }
220     if (key != NULL) {
221         if (keylen != ctx->keylen) {
222             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEYLEN);
223             return 0;
224         }
225         return ctx->hw->setkey(ctx, key, keylen);
226     }
227     return 1;
228 }
229
230 int ccm_einit(void *vctx, const unsigned char *key, size_t keylen,
231                      const unsigned char *iv, size_t ivlen)
232 {
233     return ccm_init(vctx, key, keylen, iv, ivlen, 1);
234 }
235
236 int ccm_dinit(void *vctx, const unsigned char *key, size_t keylen,
237                      const unsigned char *iv, size_t ivlen)
238 {
239     return ccm_init(vctx, key, keylen, iv, ivlen, 0);
240 }
241
242 int ccm_stream_update(void *vctx, unsigned char *out, size_t *outl,
243                              size_t outsize, const unsigned char *in,
244                              size_t inl)
245 {
246     PROV_CCM_CTX *ctx = (PROV_CCM_CTX *)vctx;
247
248     if (outsize < inl) {
249         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
250         return 0;
251     }
252
253     if (!ccm_cipher_internal(ctx, out, outl, in, inl)) {
254         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
255         return 0;
256     }
257     return 1;
258 }
259
260 int ccm_stream_final(void *vctx, unsigned char *out, size_t *outl,
261                             size_t outsize)
262 {
263     PROV_CCM_CTX *ctx = (PROV_CCM_CTX *)vctx;
264     int i;
265
266     i = ccm_cipher_internal(ctx, out, outl, NULL, 0);
267     if (i <= 0)
268         return 0;
269
270     *outl = 0;
271     return 1;
272 }
273
274 int ccm_cipher(void *vctx,
275                       unsigned char *out, size_t *outl, size_t outsize,
276                       const unsigned char *in, size_t inl)
277 {
278     PROV_CCM_CTX *ctx = (PROV_CCM_CTX *)vctx;
279
280     if (outsize < inl) {
281         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
282         return 0;
283     }
284
285     if (ccm_cipher_internal(ctx, out, outl, in, inl) <= 0)
286         return 0;
287
288     *outl = inl;
289     return 1;
290 }
291
292 /* Copy the buffered iv */
293 static int ccm_set_iv(PROV_CCM_CTX *ctx, size_t mlen)
294 {
295     const PROV_CCM_HW *hw = ctx->hw;
296
297     if (!hw->setiv(ctx, ctx->iv, ccm_get_ivlen(ctx), mlen))
298         return 0;
299     ctx->len_set = 1;
300     return 1;
301 }
302
303 static int ccm_tls_cipher(PROV_CCM_CTX *ctx,
304                           unsigned char *out, size_t *padlen,
305                           const unsigned char *in, size_t len)
306 {
307     int rv = 0;
308     size_t olen = 0;
309
310     /* Encrypt/decrypt must be performed in place */
311     if (in == NULL || out != in || len < EVP_CCM_TLS_EXPLICIT_IV_LEN + ctx->m)
312         goto err;
313
314     /* If encrypting set explicit IV from sequence number (start of AAD) */
315     if (ctx->enc)
316         memcpy(out, ctx->buf, EVP_CCM_TLS_EXPLICIT_IV_LEN);
317     /* Get rest of IV from explicit IV */
318     memcpy(ctx->iv + EVP_CCM_TLS_FIXED_IV_LEN, in, EVP_CCM_TLS_EXPLICIT_IV_LEN);
319     /* Correct length value */
320     len -= EVP_CCM_TLS_EXPLICIT_IV_LEN + ctx->m;
321     if (!ccm_set_iv(ctx, len))
322         goto err;
323
324     /* Use saved AAD */
325     if (!ctx->hw->setaad(ctx, ctx->buf, ctx->tls_aad_len))
326         goto err;
327
328     /* Fix buffer to point to payload */
329     in += EVP_CCM_TLS_EXPLICIT_IV_LEN;
330     out += EVP_CCM_TLS_EXPLICIT_IV_LEN;
331     if (ctx->enc) {
332         if (!ctx->hw->auth_encrypt(ctx, in, out, len,  out + len, ctx->m))
333             goto err;
334         olen = len + EVP_CCM_TLS_EXPLICIT_IV_LEN + ctx->m;
335     } else {
336         if (!ctx->hw->auth_decrypt(ctx, in, out, len,
337                                    (unsigned char *)in + len, ctx->m))
338             goto err;
339         olen = len;
340     }
341     rv = 1;
342 err:
343     *padlen = olen;
344     return rv;
345 }
346
347 static int ccm_cipher_internal(PROV_CCM_CTX *ctx, unsigned char *out,
348                                size_t *padlen, const unsigned char *in,
349                                size_t len)
350 {
351     int rv = 0;
352     size_t olen = 0;
353     const PROV_CCM_HW *hw = ctx->hw;
354
355     /* If no key set, return error */
356     if (!ctx->key_set)
357         return 0;
358
359     if (ctx->tls_aad_len != UNINITIALISED_SIZET)
360         return ccm_tls_cipher(ctx, out, padlen, in, len);
361
362     /* EVP_*Final() doesn't return any data */
363     if (in == NULL && out != NULL)
364         goto finish;
365
366     if (!ctx->iv_set)
367         goto err;
368
369     if (out == NULL) {
370         if (in == NULL) {
371             if (!ccm_set_iv(ctx, len))
372                 goto err;
373         } else {
374             /* If we have AAD, we need a message length */
375             if (!ctx->len_set && len)
376                 goto err;
377             if (!hw->setaad(ctx, in, len))
378                 goto err;
379         }
380     } else {
381         /* If not set length yet do it */
382         if (!ctx->len_set && !ccm_set_iv(ctx, len))
383             goto err;
384
385         if (ctx->enc) {
386             if (!hw->auth_encrypt(ctx, in, out, len, NULL, 0))
387                 goto err;
388             ctx->tag_set = 1;
389         } else {
390             /* The tag must be set before actually decrypting data */
391             if (!ctx->tag_set)
392                 goto err;
393
394             if (!hw->auth_decrypt(ctx, in, out, len, ctx->buf, ctx->m))
395                 goto err;
396             /* Finished - reset flags so calling this method again will fail */
397             ctx->iv_set = 0;
398             ctx->tag_set = 0;
399             ctx->len_set = 0;
400         }
401     }
402     olen = len;
403 finish:
404     rv = 1;
405 err:
406     *padlen = olen;
407     return rv;
408 }
409
410 void ccm_initctx(PROV_CCM_CTX *ctx, size_t keybits, const PROV_CCM_HW *hw)
411 {
412     ctx->keylen = keybits / 8;
413     ctx->key_set = 0;
414     ctx->iv_set = 0;
415     ctx->tag_set = 0;
416     ctx->len_set = 0;
417     ctx->l = 8;
418     ctx->m = 12;
419     ctx->tls_aad_len = UNINITIALISED_SIZET;
420     ctx->hw = hw;
421 }
422