Coverage Report

Created: 2024-11-21 07:03

/src/openssl/providers/implementations/ciphers/cipher_chacha20_poly1305.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright 2019-2023 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 chacha20_poly1305 cipher */
11
12
#include <openssl/proverr.h>
13
#include "cipher_chacha20_poly1305.h"
14
#include "prov/implementations.h"
15
#include "prov/providercommon.h"
16
17
424
#define CHACHA20_POLY1305_KEYLEN CHACHA_KEY_SIZE
18
147
#define CHACHA20_POLY1305_BLKLEN 1
19
11
#define CHACHA20_POLY1305_MAX_IVLEN 12
20
145
#define CHACHA20_POLY1305_MODE 0
21
147
#define CHACHA20_POLY1305_FLAGS (PROV_CIPHER_FLAG_AEAD                         \
22
147
                                 | PROV_CIPHER_FLAG_CUSTOM_IV)
23
24
static OSSL_FUNC_cipher_newctx_fn chacha20_poly1305_newctx;
25
static OSSL_FUNC_cipher_freectx_fn chacha20_poly1305_freectx;
26
static OSSL_FUNC_cipher_dupctx_fn chacha20_poly1305_dupctx;
27
static OSSL_FUNC_cipher_encrypt_init_fn chacha20_poly1305_einit;
28
static OSSL_FUNC_cipher_decrypt_init_fn chacha20_poly1305_dinit;
29
static OSSL_FUNC_cipher_get_params_fn chacha20_poly1305_get_params;
30
static OSSL_FUNC_cipher_get_ctx_params_fn chacha20_poly1305_get_ctx_params;
31
static OSSL_FUNC_cipher_set_ctx_params_fn chacha20_poly1305_set_ctx_params;
32
static OSSL_FUNC_cipher_cipher_fn chacha20_poly1305_cipher;
33
static OSSL_FUNC_cipher_final_fn chacha20_poly1305_final;
34
static OSSL_FUNC_cipher_gettable_ctx_params_fn chacha20_poly1305_gettable_ctx_params;
35
#define chacha20_poly1305_settable_ctx_params ossl_cipher_aead_settable_ctx_params
36
#define chacha20_poly1305_gettable_params ossl_cipher_generic_gettable_params
37
#define chacha20_poly1305_update chacha20_poly1305_cipher
38
39
static void *chacha20_poly1305_newctx(void *provctx)
40
145
{
41
145
    PROV_CHACHA20_POLY1305_CTX *ctx;
42
43
145
    if (!ossl_prov_is_running())
44
0
        return NULL;
45
46
145
    ctx = OPENSSL_zalloc(sizeof(*ctx));
47
145
    if (ctx != NULL) {
48
145
        ossl_cipher_generic_initkey(&ctx->base, CHACHA20_POLY1305_KEYLEN * 8,
49
145
                                    CHACHA20_POLY1305_BLKLEN * 8,
50
145
                                    CHACHA20_POLY1305_IVLEN * 8,
51
145
                                    CHACHA20_POLY1305_MODE,
52
145
                                    CHACHA20_POLY1305_FLAGS,
53
145
                                    ossl_prov_cipher_hw_chacha20_poly1305(
54
145
                                        CHACHA20_POLY1305_KEYLEN * 8),
55
145
                                    NULL);
56
145
        ctx->tls_payload_length = NO_TLS_PAYLOAD_LENGTH;
57
145
        ossl_chacha20_initctx(&ctx->chacha);
58
145
    }
59
145
    return ctx;
60
145
}
61
62
static void *chacha20_poly1305_dupctx(void *provctx)
63
4.97k
{
64
4.97k
    PROV_CHACHA20_POLY1305_CTX *ctx = provctx;
65
4.97k
    PROV_CHACHA20_POLY1305_CTX *dctx = NULL;
66
67
4.97k
    if (ctx == NULL)
68
0
        return NULL;
69
4.97k
    dctx = OPENSSL_memdup(ctx, sizeof(*ctx));
70
4.97k
    if (dctx != NULL && dctx->base.tlsmac != NULL && dctx->base.alloced) {
71
0
        dctx->base.tlsmac = OPENSSL_memdup(dctx->base.tlsmac,
72
0
                                           dctx->base.tlsmacsize);
73
0
        if (dctx->base.tlsmac == NULL) {
74
0
            OPENSSL_free(dctx);
75
0
            dctx = NULL;
76
0
        }
77
0
    }
78
4.97k
    return dctx;
79
4.97k
}
80
81
static void chacha20_poly1305_freectx(void *vctx)
82
5.12k
{
83
5.12k
    PROV_CHACHA20_POLY1305_CTX *ctx = (PROV_CHACHA20_POLY1305_CTX *)vctx;
84
85
5.12k
    if (ctx != NULL) {
86
5.12k
        ossl_cipher_generic_reset_ctx((PROV_CIPHER_CTX *)vctx);
87
5.12k
        OPENSSL_clear_free(ctx, sizeof(*ctx));
88
5.12k
    }
89
5.12k
}
90
91
static int chacha20_poly1305_get_params(OSSL_PARAM params[])
92
2
{
93
2
    return ossl_cipher_generic_get_params(params, 0, CHACHA20_POLY1305_FLAGS,
94
2
                                          CHACHA20_POLY1305_KEYLEN * 8,
95
2
                                          CHACHA20_POLY1305_BLKLEN * 8,
96
2
                                          CHACHA20_POLY1305_IVLEN * 8);
97
2
}
98
99
static int chacha20_poly1305_get_ctx_params(void *vctx, OSSL_PARAM params[])
100
260
{
101
260
    PROV_CHACHA20_POLY1305_CTX *ctx = (PROV_CHACHA20_POLY1305_CTX *)vctx;
102
260
    OSSL_PARAM *p;
103
104
260
    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN);
105
260
    if (p != NULL) {
106
128
        if (!OSSL_PARAM_set_size_t(p, CHACHA20_POLY1305_IVLEN)) {
107
0
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
108
0
            return 0;
109
0
        }
110
128
    }
111
260
    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN);
112
260
    if (p != NULL && !OSSL_PARAM_set_size_t(p, CHACHA20_POLY1305_KEYLEN)) {
113
0
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
114
0
        return 0;
115
0
    }
116
260
    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_AEAD_TAGLEN);
117
260
    if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->tag_len)) {
118
0
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
119
0
        return 0;
120
0
    }
121
260
    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD);
122
260
    if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->tls_aad_pad_sz)) {
123
0
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
124
0
        return 0;
125
0
    }
126
127
260
    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_AEAD_TAG);
128
260
    if (p != NULL) {
129
0
        if (p->data_type != OSSL_PARAM_OCTET_STRING) {
130
0
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
131
0
            return 0;
132
0
        }
133
0
        if (!ctx->base.enc) {
134
0
            ERR_raise(ERR_LIB_PROV, PROV_R_TAG_NOT_SET);
135
0
            return 0;
136
0
        }
137
0
        if (p->data_size == 0 || p->data_size > POLY1305_BLOCK_SIZE) {
138
0
            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_TAG_LENGTH);
139
0
            return 0;
140
0
        }
141
0
        memcpy(p->data, ctx->tag, p->data_size);
142
0
    }
143
144
260
    return 1;
145
260
}
146
147
static const OSSL_PARAM chacha20_poly1305_known_gettable_ctx_params[] = {
148
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
149
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
150
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TAGLEN, NULL),
151
    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
152
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD, NULL),
153
    OSSL_PARAM_END
154
};
155
static const OSSL_PARAM *chacha20_poly1305_gettable_ctx_params
156
    (ossl_unused void *cctx, ossl_unused void *provctx)
157
2
{
158
2
    return chacha20_poly1305_known_gettable_ctx_params;
159
2
}
160
161
static int chacha20_poly1305_set_ctx_params(void *vctx,
162
                                            const OSSL_PARAM params[])
163
412
{
164
412
    const OSSL_PARAM *p;
165
412
    size_t len;
166
412
    PROV_CHACHA20_POLY1305_CTX *ctx = (PROV_CHACHA20_POLY1305_CTX *)vctx;
167
412
    PROV_CIPHER_HW_CHACHA20_POLY1305 *hw =
168
412
        (PROV_CIPHER_HW_CHACHA20_POLY1305 *)ctx->base.hw;
169
170
412
    if (ossl_param_is_empty(params))
171
401
        return 1;
172
173
11
    p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_KEYLEN);
174
11
    if (p != NULL) {
175
0
        if (!OSSL_PARAM_get_size_t(p, &len)) {
176
0
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
177
0
            return 0;
178
0
        }
179
0
        if (len != CHACHA20_POLY1305_KEYLEN) {
180
0
            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH);
181
0
            return 0;
182
0
        }
183
0
    }
184
11
    p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_IVLEN);
185
11
    if (p != NULL) {
186
11
        if (!OSSL_PARAM_get_size_t(p, &len)) {
187
0
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
188
0
            return 0;
189
0
        }
190
11
        if (len != CHACHA20_POLY1305_MAX_IVLEN) {
191
11
            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
192
11
            return 0;
193
11
        }
194
11
    }
195
196
0
    p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_AEAD_TAG);
197
0
    if (p != NULL) {
198
0
        if (p->data_type != OSSL_PARAM_OCTET_STRING) {
199
0
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
200
0
            return 0;
201
0
        }
202
0
        if (p->data_size == 0 || p->data_size > POLY1305_BLOCK_SIZE) {
203
0
            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_TAG_LENGTH);
204
0
            return 0;
205
0
        }
206
0
        if (p->data != NULL) {
207
0
            if (ctx->base.enc) {
208
0
                ERR_raise(ERR_LIB_PROV, PROV_R_TAG_NOT_NEEDED);
209
0
                return 0;
210
0
            }
211
0
            memcpy(ctx->tag, p->data, p->data_size);
212
0
        }
213
0
        ctx->tag_len = p->data_size;
214
0
    }
215
216
0
    p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_AEAD_TLS1_AAD);
217
0
    if (p != NULL) {
218
0
        if (p->data_type != OSSL_PARAM_OCTET_STRING) {
219
0
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
220
0
            return 0;
221
0
        }
222
0
        len = hw->tls_init(&ctx->base, p->data, p->data_size);
223
0
        if (len == 0) {
224
0
            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_DATA);
225
0
            return 0;
226
0
        }
227
0
        ctx->tls_aad_pad_sz = len;
228
0
    }
229
230
0
    p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED);
231
0
    if (p != NULL) {
232
0
        if (p->data_type != OSSL_PARAM_OCTET_STRING) {
233
0
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
234
0
            return 0;
235
0
        }
236
0
        if (hw->tls_iv_set_fixed(&ctx->base, p->data, p->data_size) == 0) {
237
0
            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
238
0
            return 0;
239
0
        }
240
0
    }
241
    /* ignore OSSL_CIPHER_PARAM_AEAD_MAC_KEY */
242
0
    return 1;
243
0
}
244
245
static int chacha20_poly1305_einit(void *vctx, const unsigned char *key,
246
                                  size_t keylen, const unsigned char *iv,
247
                                  size_t ivlen, const OSSL_PARAM params[])
248
398
{
249
398
    int ret;
250
251
    /* The generic function checks for ossl_prov_is_running() */
252
398
    ret = ossl_cipher_generic_einit(vctx, key, keylen, iv, ivlen, NULL);
253
398
    if (ret && iv != NULL) {
254
256
        PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
255
256
        PROV_CIPHER_HW_CHACHA20_POLY1305 *hw =
256
256
            (PROV_CIPHER_HW_CHACHA20_POLY1305 *)ctx->hw;
257
258
256
        hw->initiv(ctx);
259
256
    }
260
398
    if (ret && !chacha20_poly1305_set_ctx_params(vctx, params))
261
0
        ret = 0;
262
398
    return ret;
263
398
}
264
265
static int chacha20_poly1305_dinit(void *vctx, const unsigned char *key,
266
                                  size_t keylen, const unsigned char *iv,
267
                                  size_t ivlen, const OSSL_PARAM params[])
268
3
{
269
3
    int ret;
270
271
    /* The generic function checks for ossl_prov_is_running() */
272
3
    ret = ossl_cipher_generic_dinit(vctx, key, keylen, iv, ivlen, NULL);
273
3
    if (ret && iv != NULL) {
274
0
        PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
275
0
        PROV_CIPHER_HW_CHACHA20_POLY1305 *hw =
276
0
            (PROV_CIPHER_HW_CHACHA20_POLY1305 *)ctx->hw;
277
278
0
        hw->initiv(ctx);
279
0
    }
280
3
    if (ret && !chacha20_poly1305_set_ctx_params(vctx, params))
281
0
        ret = 0;
282
3
    return ret;
283
3
}
284
285
static int chacha20_poly1305_cipher(void *vctx, unsigned char *out,
286
                                    size_t *outl, size_t outsize,
287
                                    const unsigned char *in, size_t inl)
288
384
{
289
384
    PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
290
384
    PROV_CIPHER_HW_CHACHA20_POLY1305 *hw =
291
384
        (PROV_CIPHER_HW_CHACHA20_POLY1305 *)ctx->hw;
292
293
384
    if (!ossl_prov_is_running())
294
0
        return 0;
295
296
384
    if (inl == 0) {
297
0
        *outl = 0;
298
0
        return 1;
299
0
    }
300
301
384
    if (outsize < inl) {
302
0
        ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
303
0
        return 0;
304
0
    }
305
306
384
    if (!hw->aead_cipher(ctx, out, outl, in, inl))
307
0
        return 0;
308
309
384
    return 1;
310
384
}
311
312
static int chacha20_poly1305_final(void *vctx, unsigned char *out, size_t *outl,
313
                                   size_t outsize)
314
0
{
315
0
    PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
316
0
    PROV_CIPHER_HW_CHACHA20_POLY1305 *hw =
317
0
        (PROV_CIPHER_HW_CHACHA20_POLY1305 *)ctx->hw;
318
319
0
    if (!ossl_prov_is_running())
320
0
        return 0;
321
322
0
    if (hw->aead_cipher(ctx, out, outl, NULL, 0) <= 0)
323
0
        return 0;
324
325
0
    *outl = 0;
326
0
    return 1;
327
0
}
328
329
/* ossl_chacha20_ossl_poly1305_functions */
330
const OSSL_DISPATCH ossl_chacha20_ossl_poly1305_functions[] = {
331
    { OSSL_FUNC_CIPHER_NEWCTX, (void (*)(void))chacha20_poly1305_newctx },
332
    { OSSL_FUNC_CIPHER_FREECTX, (void (*)(void))chacha20_poly1305_freectx },
333
    { OSSL_FUNC_CIPHER_DUPCTX, (void (*)(void))chacha20_poly1305_dupctx },
334
    { OSSL_FUNC_CIPHER_ENCRYPT_INIT, (void (*)(void))chacha20_poly1305_einit },
335
    { OSSL_FUNC_CIPHER_DECRYPT_INIT, (void (*)(void))chacha20_poly1305_dinit },
336
    { OSSL_FUNC_CIPHER_UPDATE, (void (*)(void))chacha20_poly1305_update },
337
    { OSSL_FUNC_CIPHER_FINAL, (void (*)(void))chacha20_poly1305_final },
338
    { OSSL_FUNC_CIPHER_CIPHER, (void (*)(void))chacha20_poly1305_cipher },
339
    { OSSL_FUNC_CIPHER_GET_PARAMS,
340
        (void (*)(void))chacha20_poly1305_get_params },
341
    { OSSL_FUNC_CIPHER_GETTABLE_PARAMS,
342
        (void (*)(void))chacha20_poly1305_gettable_params },
343
    { OSSL_FUNC_CIPHER_GET_CTX_PARAMS,
344
         (void (*)(void))chacha20_poly1305_get_ctx_params },
345
    { OSSL_FUNC_CIPHER_GETTABLE_CTX_PARAMS,
346
        (void (*)(void))chacha20_poly1305_gettable_ctx_params },
347
    { OSSL_FUNC_CIPHER_SET_CTX_PARAMS,
348
        (void (*)(void))chacha20_poly1305_set_ctx_params },
349
    { OSSL_FUNC_CIPHER_SETTABLE_CTX_PARAMS,
350
        (void (*)(void))chacha20_poly1305_settable_ctx_params },
351
    OSSL_DISPATCH_END
352
};
353