Fix Use after free when copying cipher ctx
[openssl.git] / providers / implementations / ciphers / cipher_aes_ocb.c
1 /*
2  * Copyright 2019 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 "cipher_aes_ocb.h"
11 #include "prov/providercommonerr.h"
12 #include "prov/cipher_aead.h"
13 #include "prov/implementations.h"
14
15 #define AES_OCB_FLAGS AEAD_FLAGS
16
17 #define OCB_DEFAULT_TAG_LEN 16
18 #define OCB_DEFAULT_IV_LEN  12
19 #define OCB_MIN_IV_LEN      1
20 #define OCB_MAX_IV_LEN      15
21
22 PROV_CIPHER_FUNC(int, ocb_cipher, (PROV_AES_OCB_CTX *ctx,
23                                    const unsigned char *in, unsigned char *out,
24                                    size_t nextblock));
25 /* forward declarations */
26 static OSSL_OP_cipher_encrypt_init_fn aes_ocb_einit;
27 static OSSL_OP_cipher_decrypt_init_fn aes_ocb_dinit;
28 static OSSL_OP_cipher_update_fn aes_ocb_block_update;
29 static OSSL_OP_cipher_final_fn aes_ocb_block_final;
30 static OSSL_OP_cipher_cipher_fn aes_ocb_cipher;
31 static OSSL_OP_cipher_freectx_fn aes_ocb_freectx;
32 static OSSL_OP_cipher_dupctx_fn aes_ocb_dupctx;
33 static OSSL_OP_cipher_get_ctx_params_fn aes_ocb_get_ctx_params;
34 static OSSL_OP_cipher_set_ctx_params_fn aes_ocb_set_ctx_params;
35
36 /*
37  * The following methods could be moved into PROV_AES_OCB_HW if
38  * multiple hardware implementations are ever needed.
39  */
40 static ossl_inline int aes_generic_ocb_setiv(PROV_AES_OCB_CTX *ctx,
41                                              const unsigned char *iv,
42                                              size_t ivlen, size_t taglen)
43 {
44     return (CRYPTO_ocb128_setiv(&ctx->ocb, iv, ivlen, taglen) == 1);
45 }
46
47 static ossl_inline int aes_generic_ocb_setaad(PROV_AES_OCB_CTX *ctx,
48                                               const unsigned char *aad,
49                                               size_t alen)
50 {
51     return CRYPTO_ocb128_aad(&ctx->ocb, aad, alen) == 1;
52 }
53
54 static ossl_inline int aes_generic_ocb_gettag(PROV_AES_OCB_CTX *ctx,
55                                               unsigned char *tag, size_t tlen)
56 {
57     return CRYPTO_ocb128_tag(&ctx->ocb, tag, tlen) > 0;
58 }
59
60 static ossl_inline int aes_generic_ocb_final(PROV_AES_OCB_CTX *ctx)
61 {
62     return (CRYPTO_ocb128_finish(&ctx->ocb, ctx->tag, ctx->taglen) == 0);
63 }
64
65 static ossl_inline void aes_generic_ocb_cleanup(PROV_AES_OCB_CTX *ctx)
66 {
67     CRYPTO_ocb128_cleanup(&ctx->ocb);
68 }
69
70 static ossl_inline int aes_generic_ocb_cipher(PROV_AES_OCB_CTX *ctx,
71                                               const unsigned char *in,
72                                               unsigned char *out, size_t len)
73 {
74     if (ctx->base.enc) {
75         if (!CRYPTO_ocb128_encrypt(&ctx->ocb, in, out, len))
76             return 0;
77     } else {
78         if (!CRYPTO_ocb128_decrypt(&ctx->ocb, in, out, len))
79             return 0;
80     }
81     return 1;
82 }
83
84 static ossl_inline int aes_generic_ocb_copy_ctx(PROV_AES_OCB_CTX *dst,
85                                                 PROV_AES_OCB_CTX *src)
86 {
87     return CRYPTO_ocb128_copy_ctx(&dst->ocb, &src->ocb,
88                                   &dst->ksenc.ks, &dst->ksdec.ks);
89 }
90
91 /*-
92  * Provider dispatch functions
93  */
94 static int aes_ocb_init(void *vctx, const unsigned char *key, size_t keylen,
95                         const unsigned char *iv, size_t ivlen, int enc)
96 {
97    PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
98
99    ctx->base.enc = enc;
100
101    if (iv != NULL) {
102        if (ivlen != ctx->base.ivlen) {
103            /* IV len must be 1 to 15 */
104            if (ivlen < OCB_MIN_IV_LEN || ivlen > OCB_MAX_IV_LEN) {
105                ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
106                return 0;
107            }
108            ctx->base.ivlen = ivlen;
109        }
110        if (!cipher_generic_initiv(&ctx->base, iv, ivlen))
111            return 0;
112        ctx->iv_state = IV_STATE_BUFFERED;
113    }
114    if (key != NULL) {
115        if (keylen != ctx->base.keylen) {
116            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH);
117            return 0;
118        }
119        return ctx->base.hw->init(&ctx->base, key, keylen);
120    }
121    return 1;
122 }
123
124 static int aes_ocb_einit(void *vctx, const unsigned char *key, size_t keylen,
125                          const unsigned char *iv, size_t ivlen)
126 {
127     return aes_ocb_init(vctx, key, keylen, iv, ivlen, 1);
128 }
129
130 static int aes_ocb_dinit(void *vctx, const unsigned char *key, size_t keylen,
131                          const unsigned char *iv, size_t ivlen)
132 {
133     return aes_ocb_init(vctx, key, keylen, iv, ivlen, 0);
134 }
135
136 /*
137  * Because of the way OCB works, both the AAD and data are buffered in the
138  * same way. Only the last block can be a partial block.
139  */
140 static int aes_ocb_block_update_internal(PROV_AES_OCB_CTX *ctx,
141                                          unsigned char *buf, size_t *bufsz,
142                                          unsigned char *out, size_t *outl,
143                                          size_t outsize, const unsigned char *in,
144                                          size_t inl, OSSL_ocb_cipher_fn ciph)
145 {
146     size_t nextblocks = fillblock(buf, bufsz, AES_BLOCK_SIZE, &in, &inl);
147     size_t outlint = 0;
148
149     if (*bufsz == AES_BLOCK_SIZE) {
150         if (outsize < AES_BLOCK_SIZE) {
151             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
152             return 0;
153         }
154         if (!ciph(ctx, buf, out, AES_BLOCK_SIZE)) {
155             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
156             return 0;
157         }
158         *bufsz = 0;
159         outlint = AES_BLOCK_SIZE;
160         out += AES_BLOCK_SIZE;
161     }
162     if (nextblocks > 0) {
163         outlint += nextblocks;
164         if (outsize < outlint) {
165             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
166             return 0;
167         }
168         if (!ciph(ctx, in, out, nextblocks)) {
169             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
170             return 0;
171         }
172         in += nextblocks;
173         inl -= nextblocks;
174     }
175     if (!trailingdata(buf, bufsz, AES_BLOCK_SIZE, &in, &inl)) {
176         /* PROVerr already called */
177         return 0;
178     }
179
180     *outl = outlint;
181     return inl == 0;
182 }
183
184 /* A wrapper function that has the same signature as cipher */
185 static int cipher_updateaad(PROV_AES_OCB_CTX *ctx, const unsigned char *in,
186                             unsigned char *out, size_t len)
187 {
188     return aes_generic_ocb_setaad(ctx, in, len);
189 }
190
191 static int update_iv(PROV_AES_OCB_CTX *ctx)
192 {
193     if (ctx->iv_state == IV_STATE_FINISHED
194         || ctx->iv_state == IV_STATE_UNINITIALISED)
195         return 0;
196     if (ctx->iv_state == IV_STATE_BUFFERED) {
197         if (!aes_generic_ocb_setiv(ctx, ctx->base.iv, ctx->base.ivlen,
198                                    ctx->taglen))
199             return 0;
200         ctx->iv_state = IV_STATE_COPIED;
201     }
202     return 1;
203 }
204
205 static int aes_ocb_block_update(void *vctx, unsigned char *out, size_t *outl,
206                                 size_t outsize, const unsigned char *in,
207                                 size_t inl)
208 {
209     PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
210     unsigned char *buf;
211     size_t *buflen;
212     OSSL_ocb_cipher_fn fn;
213
214     if (!ctx->key_set || !update_iv(ctx))
215         return 0;
216
217     /* Are we dealing with AAD or normal data here? */
218     if (out == NULL) {
219         buf = ctx->aad_buf;
220         buflen = &ctx->aad_buf_len;
221         fn = cipher_updateaad;
222     } else {
223         buf = ctx->data_buf;
224         buflen = &ctx->data_buf_len;
225         fn = aes_generic_ocb_cipher;
226     }
227     return aes_ocb_block_update_internal(ctx, buf, buflen, out, outl, outsize,
228                                          in, inl, fn);
229 }
230
231 static int aes_ocb_block_final(void *vctx, unsigned char *out, size_t *outl,
232                                size_t outsize)
233 {
234     PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
235
236     /* If no block_update has run then the iv still needs to be set */
237     if (!ctx->key_set || !update_iv(ctx))
238         return 0;
239
240     /*
241      * Empty the buffer of any partial block that we might have been provided,
242      * both for data and AAD
243      */
244     *outl = 0;
245     if (ctx->data_buf_len > 0) {
246         if (!aes_generic_ocb_cipher(ctx, ctx->data_buf, out, ctx->data_buf_len))
247             return 0;
248         *outl = ctx->data_buf_len;
249         ctx->data_buf_len = 0;
250     }
251     if (ctx->aad_buf_len > 0) {
252         if (!aes_generic_ocb_setaad(ctx, ctx->aad_buf, ctx->aad_buf_len))
253             return 0;
254         ctx->aad_buf_len = 0;
255     }
256     if (ctx->base.enc) {
257         /* If encrypting then just get the tag */
258         if (!aes_generic_ocb_gettag(ctx, ctx->tag, ctx->taglen))
259             return 0;
260     } else {
261         /* If decrypting then verify */
262         if (ctx->taglen == 0)
263             return 0;
264         if (!aes_generic_ocb_final(ctx))
265             return 0;
266     }
267     /* Don't reuse the IV */
268     ctx->iv_state = IV_STATE_FINISHED;
269     return 1;
270 }
271
272 static void *aes_ocb_newctx(void *provctx, size_t kbits, size_t blkbits,
273                             size_t ivbits, unsigned int mode, uint64_t flags)
274 {
275     PROV_AES_OCB_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
276
277     if (ctx != NULL) {
278         cipher_generic_initkey(ctx, kbits, blkbits, ivbits, mode, flags,
279                                PROV_CIPHER_HW_aes_ocb(kbits), NULL);
280         ctx->taglen = OCB_DEFAULT_TAG_LEN;
281     }
282     return ctx;
283 }
284
285 static void aes_ocb_freectx(void *vctx)
286 {
287     PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
288
289     if (ctx != NULL) {
290         aes_generic_ocb_cleanup(ctx);
291         OPENSSL_clear_free(ctx,  sizeof(*ctx));
292     }
293 }
294
295 static void *aes_ocb_dupctx(void *vctx)
296 {
297     PROV_AES_OCB_CTX *in = (PROV_AES_OCB_CTX *)vctx;
298     PROV_AES_OCB_CTX *ret = OPENSSL_malloc(sizeof(*ret));
299
300     if (ret == NULL) {
301         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
302         return NULL;
303     }
304     *ret = *in;
305     if (!aes_generic_ocb_copy_ctx(ret, in)) {
306         OPENSSL_free(ret);
307         ret = NULL;
308     }
309     return ret;
310 }
311
312 static int aes_ocb_set_ctx_params(void *vctx, const OSSL_PARAM params[])
313 {
314     PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
315     const OSSL_PARAM *p;
316     size_t sz;
317
318     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_AEAD_TAG);
319     if (p != NULL) {
320         if (p->data_type != OSSL_PARAM_OCTET_STRING) {
321             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
322             return 0;
323         }
324         if (p->data == NULL) {
325             /* Tag len must be 0 to 16 */
326             if (p->data_size > OCB_MAX_TAG_LEN)
327                 return 0;
328             ctx->taglen = p->data_size;
329         } else {
330             if (p->data_size != ctx->taglen || ctx->base.enc)
331                 return 0;
332             memcpy(ctx->tag, p->data, p->data_size);
333         }
334      }
335     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_AEAD_IVLEN);
336     if (p != NULL) {
337         if (!OSSL_PARAM_get_size_t(p, &sz)) {
338             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
339             return 0;
340         }
341         /* IV len must be 1 to 15 */
342         if (sz < OCB_MIN_IV_LEN || sz > OCB_MAX_IV_LEN)
343             return 0;
344         ctx->base.ivlen = sz;
345     }
346     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_KEYLEN);
347     if (p != NULL) {
348         size_t keylen;
349
350         if (!OSSL_PARAM_get_size_t(p, &keylen)) {
351             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
352             return 0;
353         }
354         if (ctx->base.keylen != keylen) {
355             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH);
356             return 0;
357         }
358     }
359     return 1;
360 }
361
362 static int aes_ocb_get_ctx_params(void *vctx, OSSL_PARAM params[])
363 {
364     PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
365     OSSL_PARAM *p;
366
367     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN);
368     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->base.ivlen)) {
369         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
370         return 0;
371     }
372     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN);
373     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->base.keylen)) {
374         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
375         return 0;
376     }
377     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_AEAD_TAGLEN);
378     if (p != NULL) {
379         if (!OSSL_PARAM_set_size_t(p, ctx->taglen)) {
380             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
381             return 0;
382         }
383     }
384
385     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IV);
386     if (p != NULL) {
387         if (ctx->base.ivlen != p->data_size) {
388             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
389             return 0;
390         }
391         if (!OSSL_PARAM_set_octet_string(p, ctx->base.oiv, ctx->base.ivlen)) {
392             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
393             return 0;
394         }
395     }
396     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_AEAD_TAG);
397     if (p != NULL) {
398         if (p->data_type != OSSL_PARAM_OCTET_STRING) {
399             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
400             return 0;
401         }
402         if (!ctx->base.enc || p->data_size != ctx->taglen) {
403             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_TAGLEN);
404             return 0;
405         }
406         memcpy(p->data, ctx->tag, ctx->taglen);
407     }
408     return 1;
409 }
410
411 static const OSSL_PARAM cipher_ocb_known_gettable_ctx_params[] = {
412     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
413     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
414     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TAGLEN, NULL),
415     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0),
416     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
417     OSSL_PARAM_END
418 };
419 static const OSSL_PARAM *cipher_ocb_gettable_ctx_params(void)
420 {
421     return cipher_ocb_known_gettable_ctx_params;
422 }
423
424 static const OSSL_PARAM cipher_ocb_known_settable_ctx_params[] = {
425     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
426     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_IVLEN, NULL),
427     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
428     OSSL_PARAM_END
429 };
430 static const OSSL_PARAM *cipher_ocb_settable_ctx_params(void)
431 {
432     return cipher_ocb_known_settable_ctx_params;
433 }
434
435 static int aes_ocb_cipher(void *vctx, unsigned char *out, size_t *outl,
436                           size_t outsize, const unsigned char *in, size_t inl)
437 {
438     PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
439
440     if (outsize < inl) {
441         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
442         return 0;
443     }
444
445     if (!aes_generic_ocb_cipher(ctx, in, out, inl)) {
446         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
447         return 0;
448     }
449
450     *outl = inl;
451     return 1;
452 }
453
454 #define IMPLEMENT_cipher(mode, UCMODE, flags, kbits, blkbits, ivbits)          \
455 static OSSL_OP_cipher_get_params_fn aes_##kbits##_##mode##_get_params;         \
456 static int aes_##kbits##_##mode##_get_params(OSSL_PARAM params[])              \
457 {                                                                              \
458     return cipher_generic_get_params(params, EVP_CIPH_##UCMODE##_MODE,         \
459                                      flags, kbits, blkbits, ivbits);           \
460 }                                                                              \
461 static OSSL_OP_cipher_newctx_fn aes_##kbits##_##mode##_newctx;                 \
462 static void *aes_##kbits##_##mode##_newctx(void *provctx)                      \
463 {                                                                              \
464     return aes_##mode##_newctx(provctx, kbits, blkbits, ivbits,                \
465                                EVP_CIPH_##UCMODE##_MODE, flags);               \
466 }                                                                              \
467 const OSSL_DISPATCH aes##kbits##mode##_functions[] = {                         \
468     { OSSL_FUNC_CIPHER_NEWCTX,                                                 \
469         (void (*)(void))aes_##kbits##_##mode##_newctx },                       \
470     { OSSL_FUNC_CIPHER_ENCRYPT_INIT, (void (*)(void))aes_##mode##_einit },     \
471     { OSSL_FUNC_CIPHER_DECRYPT_INIT, (void (*)(void))aes_##mode##_dinit },     \
472     { OSSL_FUNC_CIPHER_UPDATE, (void (*)(void))aes_##mode##_block_update },    \
473     { OSSL_FUNC_CIPHER_FINAL, (void (*)(void))aes_##mode##_block_final },      \
474     { OSSL_FUNC_CIPHER_CIPHER, (void (*)(void))aes_ocb_cipher },               \
475     { OSSL_FUNC_CIPHER_FREECTX, (void (*)(void))aes_##mode##_freectx },        \
476     { OSSL_FUNC_CIPHER_DUPCTX, (void (*)(void))aes_##mode##_dupctx },          \
477     { OSSL_FUNC_CIPHER_GET_PARAMS,                                             \
478         (void (*)(void))aes_##kbits##_##mode##_get_params },                   \
479     { OSSL_FUNC_CIPHER_GET_CTX_PARAMS,                                         \
480         (void (*)(void))aes_##mode##_get_ctx_params },                         \
481     { OSSL_FUNC_CIPHER_SET_CTX_PARAMS,                                         \
482         (void (*)(void))aes_##mode##_set_ctx_params },                         \
483     { OSSL_FUNC_CIPHER_GETTABLE_PARAMS,                                        \
484         (void (*)(void))cipher_generic_gettable_params },                      \
485     { OSSL_FUNC_CIPHER_GETTABLE_CTX_PARAMS,                                    \
486         (void (*)(void))cipher_ocb_gettable_ctx_params },                      \
487     { OSSL_FUNC_CIPHER_SETTABLE_CTX_PARAMS,                                    \
488         (void (*)(void))cipher_ocb_settable_ctx_params },                      \
489     { 0, NULL }                                                                \
490 }
491
492 IMPLEMENT_cipher(ocb, OCB, AES_OCB_FLAGS, 256, 128, OCB_DEFAULT_IV_LEN * 8);
493 IMPLEMENT_cipher(ocb, OCB, AES_OCB_FLAGS, 192, 128, OCB_DEFAULT_IV_LEN * 8);
494 IMPLEMENT_cipher(ocb, OCB, AES_OCB_FLAGS, 128, 128, OCB_DEFAULT_IV_LEN * 8);
495