]>
Commit | Line | Data |
---|---|---|
0d2bfe52 | 1 | /* |
4333b89f | 2 | * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved. |
0d2bfe52 SL |
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 | ||
0081ce9b RL |
10 | /* |
11 | * AES low level APIs are deprecated for public use, but still ok for internal | |
12 | * use where we're using them to implement the higher level EVP interface, as is | |
13 | * the case here. | |
14 | */ | |
15 | #include "internal/deprecated.h" | |
0d2bfe52 | 16 | |
0081ce9b | 17 | /* Dispatch functions for AES_CBC_HMAC_SHA ciphers */ |
0d2bfe52 | 18 | |
a361cb84 MC |
19 | /* Only for SSL3_VERSION and TLS1_VERSION */ |
20 | #include <openssl/ssl.h> | |
0d2bfe52 SL |
21 | #include "cipher_aes_cbc_hmac_sha.h" |
22 | #include "prov/implementations.h" | |
f99d3eed | 23 | #include "prov/providercommon.h" |
0d2bfe52 SL |
24 | |
25 | #ifndef AES_CBC_HMAC_SHA_CAPABLE | |
26 | # define IMPLEMENT_CIPHER(nm, sub, kbits, blkbits, ivbits, flags) \ | |
1be63951 | 27 | const OSSL_DISPATCH ossl_##nm##kbits##sub##_functions[] = { \ |
0d2bfe52 SL |
28 | { 0, NULL } \ |
29 | }; | |
30 | #else | |
31 | # include "prov/providercommonerr.h" | |
32 | ||
a054d15c SL |
33 | # define AES_CBC_HMAC_SHA_FLAGS (PROV_CIPHER_FLAG_AEAD \ |
34 | | PROV_CIPHER_FLAG_TLS1_MULTIBLOCK) | |
0d2bfe52 | 35 | |
363b1e5d DMSP |
36 | static OSSL_FUNC_cipher_freectx_fn aes_cbc_hmac_sha1_freectx; |
37 | static OSSL_FUNC_cipher_freectx_fn aes_cbc_hmac_sha256_freectx; | |
38 | static OSSL_FUNC_cipher_get_ctx_params_fn aes_get_ctx_params; | |
39 | static OSSL_FUNC_cipher_gettable_ctx_params_fn aes_gettable_ctx_params; | |
40 | static OSSL_FUNC_cipher_set_ctx_params_fn aes_set_ctx_params; | |
41 | static OSSL_FUNC_cipher_settable_ctx_params_fn aes_settable_ctx_params; | |
592dcfd3 P |
42 | # define aes_gettable_params ossl_cipher_generic_gettable_params |
43 | # define aes_einit ossl_cipher_generic_einit | |
44 | # define aes_dinit ossl_cipher_generic_dinit | |
45 | # define aes_update ossl_cipher_generic_stream_update | |
46 | # define aes_final ossl_cipher_generic_stream_final | |
47 | # define aes_cipher ossl_cipher_generic_cipher | |
0d2bfe52 SL |
48 | |
49 | static const OSSL_PARAM cipher_aes_known_settable_ctx_params[] = { | |
50 | OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_MAC_KEY, NULL, 0), | |
51 | OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD, NULL, 0), | |
52 | # if !defined(OPENSSL_NO_MULTIBLOCK) | |
53 | OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_SEND_FRAGMENT, NULL), | |
54 | OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD, NULL), | |
55 | OSSL_PARAM_uint(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE, NULL), | |
56 | OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC, NULL, 0), | |
57 | OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_IN, NULL, 0), | |
58 | # endif /* !defined(OPENSSL_NO_MULTIBLOCK) */ | |
59 | OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL), | |
60 | OSSL_PARAM_END | |
61 | }; | |
1017ab21 | 62 | const OSSL_PARAM *aes_settable_ctx_params(ossl_unused void *provctx) |
0d2bfe52 SL |
63 | { |
64 | return cipher_aes_known_settable_ctx_params; | |
65 | } | |
66 | ||
67 | static int aes_set_ctx_params(void *vctx, const OSSL_PARAM params[]) | |
68 | { | |
69 | PROV_AES_HMAC_SHA_CTX *ctx = (PROV_AES_HMAC_SHA_CTX *)vctx; | |
70 | PROV_CIPHER_HW_AES_HMAC_SHA *hw = | |
71 | (PROV_CIPHER_HW_AES_HMAC_SHA *)ctx->hw; | |
d8d4e5fb | 72 | const OSSL_PARAM *p; |
0d2bfe52 | 73 | int ret = 1; |
d8d4e5fb MC |
74 | # if !defined(OPENSSL_NO_MULTIBLOCK) |
75 | EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param; | |
76 | # endif | |
0d2bfe52 SL |
77 | |
78 | p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_AEAD_MAC_KEY); | |
79 | if (p != NULL) { | |
80 | if (p->data_type != OSSL_PARAM_OCTET_STRING) { | |
81 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER); | |
82 | return 0; | |
83 | } | |
84 | hw->init_mac_key(ctx, p->data, p->data_size); | |
85 | } | |
86 | ||
87 | # if !defined(OPENSSL_NO_MULTIBLOCK) | |
88 | p = OSSL_PARAM_locate_const(params, | |
89 | OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_SEND_FRAGMENT); | |
90 | if (p != NULL | |
91 | && !OSSL_PARAM_get_size_t(p, &ctx->multiblock_max_send_fragment)) { | |
92 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER); | |
93 | return 0; | |
94 | } | |
95 | /* | |
96 | * The inputs to tls1_multiblock_aad are: | |
97 | * mb_param->inp | |
98 | * mb_param->len | |
99 | * mb_param->interleave | |
100 | * The outputs of tls1_multiblock_aad are written to: | |
101 | * ctx->multiblock_interleave | |
102 | * ctx->multiblock_aad_packlen | |
103 | */ | |
104 | p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD); | |
105 | if (p != NULL) { | |
d8d4e5fb MC |
106 | const OSSL_PARAM *p1 = OSSL_PARAM_locate_const(params, |
107 | OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE); | |
0d2bfe52 SL |
108 | if (p->data_type != OSSL_PARAM_OCTET_STRING |
109 | || p1 == NULL | |
110 | || !OSSL_PARAM_get_uint(p1, &mb_param.interleave)) { | |
111 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER); | |
112 | return 0; | |
113 | } | |
114 | mb_param.inp = p->data; | |
115 | mb_param.len = p->data_size; | |
116 | if (hw->tls1_multiblock_aad(vctx, &mb_param) <= 0) | |
117 | return 0; | |
118 | } | |
119 | ||
120 | /* | |
121 | * The inputs to tls1_multiblock_encrypt are: | |
122 | * mb_param->inp | |
123 | * mb_param->len | |
124 | * mb_param->interleave | |
125 | * mb_param->out | |
126 | * The outputs of tls1_multiblock_encrypt are: | |
127 | * ctx->multiblock_encrypt_len | |
128 | */ | |
129 | p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC); | |
130 | if (p != NULL) { | |
d8d4e5fb MC |
131 | const OSSL_PARAM *p1 = OSSL_PARAM_locate_const(params, |
132 | OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE); | |
133 | const OSSL_PARAM *pin = OSSL_PARAM_locate_const(params, | |
134 | OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_IN); | |
135 | ||
0d2bfe52 SL |
136 | if (p->data_type != OSSL_PARAM_OCTET_STRING |
137 | || pin == NULL | |
138 | || pin->data_type != OSSL_PARAM_OCTET_STRING | |
139 | || p1 == NULL | |
140 | || !OSSL_PARAM_get_uint(p1, &mb_param.interleave)) { | |
141 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER); | |
142 | return 0; | |
143 | } | |
144 | mb_param.out = p->data; | |
145 | mb_param.inp = pin->data; | |
146 | mb_param.len = pin->data_size; | |
147 | if (hw->tls1_multiblock_encrypt(vctx, &mb_param) <= 0) | |
148 | return 0; | |
149 | } | |
150 | # endif /* !defined(OPENSSL_NO_MULTIBLOCK) */ | |
151 | ||
152 | p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_AEAD_TLS1_AAD); | |
153 | if (p != NULL) { | |
154 | if (p->data_type != OSSL_PARAM_OCTET_STRING) { | |
155 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER); | |
156 | return 0; | |
157 | } | |
158 | if (hw->set_tls1_aad(ctx, p->data, p->data_size) <= 0) | |
159 | return 0; | |
160 | } | |
161 | ||
162 | p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_KEYLEN); | |
163 | if (p != NULL) { | |
164 | size_t keylen; | |
165 | ||
166 | if (!OSSL_PARAM_get_size_t(p, &keylen)) { | |
167 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER); | |
168 | return 0; | |
169 | } | |
170 | if (ctx->base.keylen != keylen) { | |
171 | ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH); | |
172 | return 0; | |
173 | } | |
174 | } | |
a361cb84 MC |
175 | |
176 | p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_TLS_VERSION); | |
177 | if (p != NULL) { | |
178 | if (!OSSL_PARAM_get_uint(p, &ctx->base.tlsversion)) { | |
179 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER); | |
180 | return 0; | |
181 | } | |
182 | if (ctx->base.tlsversion == SSL3_VERSION | |
183 | || ctx->base.tlsversion == TLS1_VERSION) { | |
6db0d58d | 184 | if (!ossl_assert(ctx->base.removetlsfixed >= AES_BLOCK_SIZE)) { |
a361cb84 MC |
185 | ERR_raise(ERR_LIB_PROV, ERR_R_INTERNAL_ERROR); |
186 | return 0; | |
187 | } | |
188 | /* | |
189 | * There is no explicit IV with these TLS versions, so don't attempt | |
190 | * to remove it. | |
191 | */ | |
6db0d58d | 192 | ctx->base.removetlsfixed -= AES_BLOCK_SIZE; |
a361cb84 MC |
193 | } |
194 | } | |
0d2bfe52 SL |
195 | return ret; |
196 | } | |
197 | ||
198 | static int aes_get_ctx_params(void *vctx, OSSL_PARAM params[]) | |
199 | { | |
200 | PROV_AES_HMAC_SHA_CTX *ctx = (PROV_AES_HMAC_SHA_CTX *)vctx; | |
0d2bfe52 SL |
201 | OSSL_PARAM *p; |
202 | ||
203 | # if !defined(OPENSSL_NO_MULTIBLOCK) | |
204 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_BUFSIZE); | |
205 | if (p != NULL) { | |
d8d4e5fb MC |
206 | PROV_CIPHER_HW_AES_HMAC_SHA *hw = |
207 | (PROV_CIPHER_HW_AES_HMAC_SHA *)ctx->hw; | |
0d2bfe52 SL |
208 | size_t len = hw->tls1_multiblock_max_bufsize(ctx); |
209 | ||
210 | if (!OSSL_PARAM_set_size_t(p, len)) { | |
211 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); | |
212 | return 0; | |
213 | } | |
214 | } | |
215 | ||
216 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE); | |
217 | if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->multiblock_interleave)) { | |
218 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); | |
219 | return 0; | |
220 | } | |
221 | ||
222 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD_PACKLEN); | |
223 | if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->multiblock_aad_packlen)) { | |
224 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); | |
225 | return 0; | |
226 | } | |
227 | ||
228 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN); | |
229 | if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->multiblock_encrypt_len)) { | |
230 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); | |
231 | return 0; | |
232 | } | |
233 | # endif /* !defined(OPENSSL_NO_MULTIBLOCK) */ | |
234 | ||
235 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD); | |
236 | if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->tls_aad_pad)) { | |
237 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); | |
238 | return 0; | |
239 | } | |
240 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN); | |
241 | if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->base.keylen)) { | |
242 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); | |
243 | return 0; | |
244 | } | |
245 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN); | |
246 | if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->base.ivlen)) { | |
247 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); | |
248 | return 0; | |
249 | } | |
250 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IV); | |
251 | if (p != NULL | |
320d96a3 BK |
252 | && !OSSL_PARAM_set_octet_string(p, ctx->base.oiv, ctx->base.ivlen) |
253 | && !OSSL_PARAM_set_octet_ptr(p, &ctx->base.oiv, ctx->base.ivlen)) { | |
0d2bfe52 SL |
254 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); |
255 | return 0; | |
256 | } | |
0d83b7b9 | 257 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_UPDATED_IV); |
84890268 | 258 | if (p != NULL |
0d83b7b9 TM |
259 | && !OSSL_PARAM_set_octet_string(p, ctx->base.iv, ctx->base.ivlen) |
260 | && !OSSL_PARAM_set_octet_ptr(p, &ctx->base.iv, ctx->base.ivlen)) { | |
84890268 BK |
261 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); |
262 | return 0; | |
263 | } | |
0d2bfe52 SL |
264 | return 1; |
265 | } | |
266 | ||
267 | static const OSSL_PARAM cipher_aes_known_gettable_ctx_params[] = { | |
268 | # if !defined(OPENSSL_NO_MULTIBLOCK) | |
269 | OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_BUFSIZE, NULL), | |
270 | OSSL_PARAM_uint(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE, NULL), | |
271 | OSSL_PARAM_uint(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD_PACKLEN, NULL), | |
272 | OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN, NULL), | |
273 | # endif /* !defined(OPENSSL_NO_MULTIBLOCK) */ | |
274 | OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD, NULL), | |
275 | OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL), | |
276 | OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL), | |
277 | OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0), | |
0d83b7b9 | 278 | OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_UPDATED_IV, NULL, 0), |
0d2bfe52 SL |
279 | OSSL_PARAM_END |
280 | }; | |
1017ab21 | 281 | const OSSL_PARAM *aes_gettable_ctx_params(ossl_unused void *provctx) |
0d2bfe52 SL |
282 | { |
283 | return cipher_aes_known_gettable_ctx_params; | |
284 | } | |
285 | ||
286 | static void base_init(void *provctx, PROV_AES_HMAC_SHA_CTX *ctx, | |
287 | const PROV_CIPHER_HW_AES_HMAC_SHA *meths, | |
288 | size_t kbits, size_t blkbits, size_t ivbits, | |
289 | uint64_t flags) | |
290 | { | |
592dcfd3 P |
291 | ossl_cipher_generic_initkey(&ctx->base, kbits, blkbits, ivbits, |
292 | EVP_CIPH_CBC_MODE, flags, | |
293 | &meths->base, provctx); | |
0d2bfe52 SL |
294 | ctx->hw = (PROV_CIPHER_HW_AES_HMAC_SHA *)ctx->base.hw; |
295 | } | |
296 | ||
297 | static void *aes_cbc_hmac_sha1_newctx(void *provctx, size_t kbits, | |
298 | size_t blkbits, size_t ivbits, | |
299 | uint64_t flags) | |
300 | { | |
f99d3eed | 301 | PROV_AES_HMAC_SHA1_CTX *ctx; |
0d2bfe52 | 302 | |
f99d3eed P |
303 | if (!ossl_prov_is_running()) |
304 | return NULL; | |
305 | ||
306 | ctx = OPENSSL_zalloc(sizeof(*ctx)); | |
0d2bfe52 SL |
307 | if (ctx != NULL) |
308 | base_init(provctx, &ctx->base_ctx, | |
7d6766cb | 309 | ossl_prov_cipher_hw_aes_cbc_hmac_sha1(), kbits, blkbits, |
0d2bfe52 SL |
310 | ivbits, flags); |
311 | return ctx; | |
312 | } | |
313 | ||
314 | static void aes_cbc_hmac_sha1_freectx(void *vctx) | |
315 | { | |
316 | PROV_AES_HMAC_SHA1_CTX *ctx = (PROV_AES_HMAC_SHA1_CTX *)vctx; | |
317 | ||
63ee6ec1 | 318 | if (ctx != NULL) { |
592dcfd3 | 319 | ossl_cipher_generic_reset_ctx((PROV_CIPHER_CTX *)vctx); |
d5e66eab | 320 | OPENSSL_clear_free(ctx, sizeof(*ctx)); |
63ee6ec1 | 321 | } |
0d2bfe52 SL |
322 | } |
323 | ||
324 | static void *aes_cbc_hmac_sha256_newctx(void *provctx, size_t kbits, | |
325 | size_t blkbits, size_t ivbits, | |
326 | uint64_t flags) | |
327 | { | |
f99d3eed P |
328 | PROV_AES_HMAC_SHA256_CTX *ctx; |
329 | ||
330 | if (!ossl_prov_is_running()) | |
331 | return NULL; | |
0d2bfe52 | 332 | |
f99d3eed | 333 | ctx = OPENSSL_zalloc(sizeof(*ctx)); |
0d2bfe52 SL |
334 | if (ctx != NULL) |
335 | base_init(provctx, &ctx->base_ctx, | |
7d6766cb | 336 | ossl_prov_cipher_hw_aes_cbc_hmac_sha256(), kbits, blkbits, |
0d2bfe52 SL |
337 | ivbits, flags); |
338 | return ctx; | |
339 | } | |
340 | ||
341 | static void aes_cbc_hmac_sha256_freectx(void *vctx) | |
342 | { | |
343 | PROV_AES_HMAC_SHA256_CTX *ctx = (PROV_AES_HMAC_SHA256_CTX *)vctx; | |
344 | ||
63ee6ec1 | 345 | if (ctx != NULL) { |
592dcfd3 | 346 | ossl_cipher_generic_reset_ctx((PROV_CIPHER_CTX *)vctx); |
d5e66eab | 347 | OPENSSL_clear_free(ctx, sizeof(*ctx)); |
63ee6ec1 | 348 | } |
0d2bfe52 SL |
349 | } |
350 | ||
363b1e5d DMSP |
351 | # define IMPLEMENT_CIPHER(nm, sub, kbits, blkbits, ivbits, flags) \ |
352 | static OSSL_FUNC_cipher_newctx_fn nm##_##kbits##_##sub##_newctx; \ | |
0d2bfe52 SL |
353 | static void *nm##_##kbits##_##sub##_newctx(void *provctx) \ |
354 | { \ | |
355 | return nm##_##sub##_newctx(provctx, kbits, blkbits, ivbits, flags); \ | |
356 | } \ | |
363b1e5d | 357 | static OSSL_FUNC_cipher_get_params_fn nm##_##kbits##_##sub##_get_params; \ |
0d2bfe52 SL |
358 | static int nm##_##kbits##_##sub##_get_params(OSSL_PARAM params[]) \ |
359 | { \ | |
592dcfd3 P |
360 | return ossl_cipher_generic_get_params(params, EVP_CIPH_CBC_MODE, \ |
361 | flags, kbits, blkbits, ivbits); \ | |
0d2bfe52 | 362 | } \ |
1be63951 | 363 | const OSSL_DISPATCH ossl_##nm##kbits##sub##_functions[] = { \ |
0d2bfe52 SL |
364 | { OSSL_FUNC_CIPHER_NEWCTX, (void (*)(void))nm##_##kbits##_##sub##_newctx },\ |
365 | { OSSL_FUNC_CIPHER_FREECTX, (void (*)(void))nm##_##sub##_freectx }, \ | |
366 | { OSSL_FUNC_CIPHER_ENCRYPT_INIT, (void (*)(void))nm##_einit }, \ | |
367 | { OSSL_FUNC_CIPHER_DECRYPT_INIT, (void (*)(void))nm##_dinit }, \ | |
368 | { OSSL_FUNC_CIPHER_UPDATE, (void (*)(void))nm##_update }, \ | |
369 | { OSSL_FUNC_CIPHER_FINAL, (void (*)(void))nm##_final }, \ | |
370 | { OSSL_FUNC_CIPHER_CIPHER, (void (*)(void))nm##_cipher }, \ | |
371 | { OSSL_FUNC_CIPHER_GET_PARAMS, \ | |
372 | (void (*)(void))nm##_##kbits##_##sub##_get_params }, \ | |
373 | { OSSL_FUNC_CIPHER_GETTABLE_PARAMS, \ | |
374 | (void (*)(void))nm##_gettable_params }, \ | |
375 | { OSSL_FUNC_CIPHER_GET_CTX_PARAMS, \ | |
376 | (void (*)(void))nm##_get_ctx_params }, \ | |
377 | { OSSL_FUNC_CIPHER_GETTABLE_CTX_PARAMS, \ | |
378 | (void (*)(void))nm##_gettable_ctx_params }, \ | |
379 | { OSSL_FUNC_CIPHER_SET_CTX_PARAMS, \ | |
380 | (void (*)(void))nm##_set_ctx_params }, \ | |
381 | { OSSL_FUNC_CIPHER_SETTABLE_CTX_PARAMS, \ | |
382 | (void (*)(void))nm##_settable_ctx_params }, \ | |
383 | { 0, NULL } \ | |
384 | }; | |
385 | ||
386 | #endif /* AES_CBC_HMAC_SHA_CAPABLE */ | |
387 | ||
1be63951 | 388 | /* ossl_aes128cbc_hmac_sha1_functions */ |
0d2bfe52 | 389 | IMPLEMENT_CIPHER(aes, cbc_hmac_sha1, 128, 128, 128, AES_CBC_HMAC_SHA_FLAGS) |
1be63951 | 390 | /* ossl_aes256cbc_hmac_sha1_functions */ |
0d2bfe52 | 391 | IMPLEMENT_CIPHER(aes, cbc_hmac_sha1, 256, 128, 128, AES_CBC_HMAC_SHA_FLAGS) |
1be63951 | 392 | /* ossl_aes128cbc_hmac_sha256_functions */ |
0d2bfe52 | 393 | IMPLEMENT_CIPHER(aes, cbc_hmac_sha256, 128, 128, 128, AES_CBC_HMAC_SHA_FLAGS) |
1be63951 | 394 | /* ossl_aes256cbc_hmac_sha256_functions */ |
0d2bfe52 | 395 | IMPLEMENT_CIPHER(aes, cbc_hmac_sha256, 256, 128, 128, AES_CBC_HMAC_SHA_FLAGS) |