/src/openssl/providers/implementations/ciphers/ciphercommon.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * Copyright 2019-2021 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 | | /* |
11 | | * Generic dispatch table functions for ciphers. |
12 | | */ |
13 | | |
14 | | /* For SSL3_VERSION */ |
15 | | #include <openssl/prov_ssl.h> |
16 | | #include <openssl/proverr.h> |
17 | | #include "ciphercommon_local.h" |
18 | | #include "prov/provider_ctx.h" |
19 | | #include "prov/providercommon.h" |
20 | | |
21 | | /*- |
22 | | * Generic cipher functions for OSSL_PARAM gettables and settables |
23 | | */ |
24 | | static const OSSL_PARAM cipher_known_gettable_params[] = { |
25 | | OSSL_PARAM_uint(OSSL_CIPHER_PARAM_MODE, NULL), |
26 | | OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL), |
27 | | OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL), |
28 | | OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_BLOCK_SIZE, NULL), |
29 | | OSSL_PARAM_int(OSSL_CIPHER_PARAM_AEAD, NULL), |
30 | | OSSL_PARAM_int(OSSL_CIPHER_PARAM_CUSTOM_IV, NULL), |
31 | | OSSL_PARAM_int(OSSL_CIPHER_PARAM_CTS, NULL), |
32 | | OSSL_PARAM_int(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK, NULL), |
33 | | OSSL_PARAM_int(OSSL_CIPHER_PARAM_HAS_RAND_KEY, NULL), |
34 | | OSSL_PARAM_END |
35 | | }; |
36 | | const OSSL_PARAM *ossl_cipher_generic_gettable_params(ossl_unused void *provctx) |
37 | 0 | { |
38 | 0 | return cipher_known_gettable_params; |
39 | 0 | } |
40 | | |
41 | | int ossl_cipher_generic_get_params(OSSL_PARAM params[], unsigned int md, |
42 | | uint64_t flags, |
43 | | size_t kbits, size_t blkbits, size_t ivbits) |
44 | 130 | { |
45 | 130 | OSSL_PARAM *p; |
46 | | |
47 | 130 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_MODE); |
48 | 130 | if (p != NULL && !OSSL_PARAM_set_uint(p, md)) { |
49 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); |
50 | 0 | return 0; |
51 | 0 | } |
52 | 130 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_AEAD); |
53 | 130 | if (p != NULL |
54 | 130 | && !OSSL_PARAM_set_int(p, (flags & PROV_CIPHER_FLAG_AEAD) != 0)) { |
55 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); |
56 | 0 | return 0; |
57 | 0 | } |
58 | 130 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_CUSTOM_IV); |
59 | 130 | if (p != NULL |
60 | 130 | && !OSSL_PARAM_set_int(p, (flags & PROV_CIPHER_FLAG_CUSTOM_IV) != 0)) { |
61 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); |
62 | 0 | return 0; |
63 | 0 | } |
64 | 130 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_CTS); |
65 | 130 | if (p != NULL |
66 | 130 | && !OSSL_PARAM_set_int(p, (flags & PROV_CIPHER_FLAG_CTS) != 0)) { |
67 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); |
68 | 0 | return 0; |
69 | 0 | } |
70 | 130 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK); |
71 | 130 | if (p != NULL |
72 | 130 | && !OSSL_PARAM_set_int(p, (flags & PROV_CIPHER_FLAG_TLS1_MULTIBLOCK) != 0)) { |
73 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); |
74 | 0 | return 0; |
75 | 0 | } |
76 | 130 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_HAS_RAND_KEY); |
77 | 130 | if (p != NULL |
78 | 130 | && !OSSL_PARAM_set_int(p, (flags & PROV_CIPHER_FLAG_RAND_KEY) != 0)) { |
79 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); |
80 | 0 | return 0; |
81 | 0 | } |
82 | 130 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN); |
83 | 130 | if (p != NULL && !OSSL_PARAM_set_size_t(p, kbits / 8)) { |
84 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); |
85 | 0 | return 0; |
86 | 0 | } |
87 | 130 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_BLOCK_SIZE); |
88 | 130 | if (p != NULL && !OSSL_PARAM_set_size_t(p, blkbits / 8)) { |
89 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); |
90 | 0 | return 0; |
91 | 0 | } |
92 | 130 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN); |
93 | 130 | if (p != NULL && !OSSL_PARAM_set_size_t(p, ivbits / 8)) { |
94 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); |
95 | 0 | return 0; |
96 | 0 | } |
97 | 130 | return 1; |
98 | 130 | } |
99 | | |
100 | | CIPHER_DEFAULT_GETTABLE_CTX_PARAMS_START(ossl_cipher_generic) |
101 | | { OSSL_CIPHER_PARAM_TLS_MAC, OSSL_PARAM_OCTET_PTR, NULL, 0, OSSL_PARAM_UNMODIFIED }, |
102 | | CIPHER_DEFAULT_GETTABLE_CTX_PARAMS_END(ossl_cipher_generic) |
103 | | |
104 | | CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_START(ossl_cipher_generic) |
105 | | OSSL_PARAM_uint(OSSL_CIPHER_PARAM_USE_BITS, NULL), |
106 | | OSSL_PARAM_uint(OSSL_CIPHER_PARAM_TLS_VERSION, NULL), |
107 | | OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS_MAC_SIZE, NULL), |
108 | | CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_END(ossl_cipher_generic) |
109 | | |
110 | | /* |
111 | | * Variable key length cipher functions for OSSL_PARAM settables |
112 | | */ |
113 | | int ossl_cipher_var_keylen_set_ctx_params(void *vctx, const OSSL_PARAM params[]) |
114 | 0 | { |
115 | 0 | PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx; |
116 | 0 | const OSSL_PARAM *p; |
117 | |
|
118 | 0 | if (params == NULL) |
119 | 0 | return 1; |
120 | | |
121 | 0 | if (!ossl_cipher_generic_set_ctx_params(vctx, params)) |
122 | 0 | return 0; |
123 | 0 | p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_KEYLEN); |
124 | 0 | if (p != NULL) { |
125 | 0 | size_t keylen; |
126 | |
|
127 | 0 | if (!OSSL_PARAM_get_size_t(p, &keylen)) { |
128 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER); |
129 | 0 | return 0; |
130 | 0 | } |
131 | 0 | ctx->keylen = keylen; |
132 | 0 | } |
133 | 0 | return 1; |
134 | 0 | } |
135 | | |
136 | | CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_START(ossl_cipher_var_keylen) |
137 | | OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL), |
138 | | CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_END(ossl_cipher_var_keylen) |
139 | | |
140 | | /*- |
141 | | * AEAD cipher functions for OSSL_PARAM gettables and settables |
142 | | */ |
143 | | static const OSSL_PARAM cipher_aead_known_gettable_ctx_params[] = { |
144 | | OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL), |
145 | | OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL), |
146 | | OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TAGLEN, NULL), |
147 | | OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0), |
148 | | OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_UPDATED_IV, NULL, 0), |
149 | | OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0), |
150 | | OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD, NULL), |
151 | | OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN, NULL, 0), |
152 | | OSSL_PARAM_END |
153 | | }; |
154 | | const OSSL_PARAM *ossl_cipher_aead_gettable_ctx_params( |
155 | | ossl_unused void *cctx, ossl_unused void *provctx |
156 | | ) |
157 | 14 | { |
158 | 14 | return cipher_aead_known_gettable_ctx_params; |
159 | 14 | } |
160 | | |
161 | | static const OSSL_PARAM cipher_aead_known_settable_ctx_params[] = { |
162 | | OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_IVLEN, NULL), |
163 | | OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0), |
164 | | OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD, NULL, 0), |
165 | | OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED, NULL, 0), |
166 | | OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_SET_IV_INV, NULL, 0), |
167 | | OSSL_PARAM_END |
168 | | }; |
169 | | const OSSL_PARAM *ossl_cipher_aead_settable_ctx_params( |
170 | | ossl_unused void *cctx, ossl_unused void *provctx |
171 | | ) |
172 | 0 | { |
173 | 0 | return cipher_aead_known_settable_ctx_params; |
174 | 0 | } |
175 | | |
176 | | void ossl_cipher_generic_reset_ctx(PROV_CIPHER_CTX *ctx) |
177 | 5 | { |
178 | 5 | if (ctx != NULL && ctx->alloced) { |
179 | 0 | OPENSSL_free(ctx->tlsmac); |
180 | 0 | ctx->alloced = 0; |
181 | 0 | ctx->tlsmac = NULL; |
182 | 0 | } |
183 | 5 | } |
184 | | |
185 | | static int cipher_generic_init_internal(PROV_CIPHER_CTX *ctx, |
186 | | const unsigned char *key, size_t keylen, |
187 | | const unsigned char *iv, size_t ivlen, |
188 | | const OSSL_PARAM params[], int enc) |
189 | 35 | { |
190 | 35 | ctx->num = 0; |
191 | 35 | ctx->bufsz = 0; |
192 | 35 | ctx->updated = 0; |
193 | 35 | ctx->enc = enc ? 1 : 0; |
194 | | |
195 | 35 | if (!ossl_prov_is_running()) |
196 | 0 | return 0; |
197 | | |
198 | 35 | if (iv != NULL && ctx->mode != EVP_CIPH_ECB_MODE) { |
199 | 4 | if (!ossl_cipher_generic_initiv(ctx, iv, ivlen)) |
200 | 0 | return 0; |
201 | 4 | } |
202 | 35 | if (iv == NULL && ctx->iv_set |
203 | 35 | && (ctx->mode == EVP_CIPH_CBC_MODE |
204 | 5 | || ctx->mode == EVP_CIPH_CFB_MODE |
205 | 5 | || ctx->mode == EVP_CIPH_OFB_MODE)) |
206 | | /* reset IV for these modes to keep compatibility with 1.1.1 */ |
207 | 0 | memcpy(ctx->iv, ctx->oiv, ctx->ivlen); |
208 | | |
209 | 35 | if (key != NULL) { |
210 | 27 | if (ctx->variable_keylength == 0) { |
211 | 27 | if (keylen != ctx->keylen) { |
212 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH); |
213 | 0 | return 0; |
214 | 0 | } |
215 | 27 | } else { |
216 | 0 | ctx->keylen = keylen; |
217 | 0 | } |
218 | 27 | if (!ctx->hw->init(ctx, key, ctx->keylen)) |
219 | 0 | return 0; |
220 | 27 | } |
221 | 35 | return ossl_cipher_generic_set_ctx_params(ctx, params); |
222 | 35 | } |
223 | | |
224 | | int ossl_cipher_generic_einit(void *vctx, const unsigned char *key, |
225 | | size_t keylen, const unsigned char *iv, |
226 | | size_t ivlen, const OSSL_PARAM params[]) |
227 | 35 | { |
228 | 35 | return cipher_generic_init_internal((PROV_CIPHER_CTX *)vctx, key, keylen, |
229 | 35 | iv, ivlen, params, 1); |
230 | 35 | } |
231 | | |
232 | | int ossl_cipher_generic_dinit(void *vctx, const unsigned char *key, |
233 | | size_t keylen, const unsigned char *iv, |
234 | | size_t ivlen, const OSSL_PARAM params[]) |
235 | 0 | { |
236 | 0 | return cipher_generic_init_internal((PROV_CIPHER_CTX *)vctx, key, keylen, |
237 | 0 | iv, ivlen, params, 0); |
238 | 0 | } |
239 | | |
240 | | /* Max padding including padding length byte */ |
241 | 0 | #define MAX_PADDING 256 |
242 | | |
243 | | int ossl_cipher_generic_block_update(void *vctx, unsigned char *out, |
244 | | size_t *outl, size_t outsize, |
245 | | const unsigned char *in, size_t inl) |
246 | 41 | { |
247 | 41 | size_t outlint = 0; |
248 | 41 | PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx; |
249 | 41 | size_t blksz = ctx->blocksize; |
250 | 41 | size_t nextblocks; |
251 | | |
252 | 41 | if (ctx->tlsversion > 0) { |
253 | | /* |
254 | | * Each update call corresponds to a TLS record and is individually |
255 | | * padded |
256 | | */ |
257 | | |
258 | | /* Sanity check inputs */ |
259 | 0 | if (in == NULL |
260 | 0 | || in != out |
261 | 0 | || outsize < inl |
262 | 0 | || !ctx->pad) { |
263 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED); |
264 | 0 | return 0; |
265 | 0 | } |
266 | | |
267 | 0 | if (ctx->enc) { |
268 | 0 | unsigned char padval; |
269 | 0 | size_t padnum, loop; |
270 | | |
271 | | /* Add padding */ |
272 | |
|
273 | 0 | padnum = blksz - (inl % blksz); |
274 | |
|
275 | 0 | if (outsize < inl + padnum) { |
276 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED); |
277 | 0 | return 0; |
278 | 0 | } |
279 | | |
280 | 0 | if (padnum > MAX_PADDING) { |
281 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED); |
282 | 0 | return 0; |
283 | 0 | } |
284 | 0 | padval = (unsigned char)(padnum - 1); |
285 | 0 | if (ctx->tlsversion == SSL3_VERSION) { |
286 | 0 | if (padnum > 1) |
287 | 0 | memset(out + inl, 0, padnum - 1); |
288 | 0 | *(out + inl + padnum - 1) = padval; |
289 | 0 | } else { |
290 | | /* we need to add 'padnum' padding bytes of value padval */ |
291 | 0 | for (loop = inl; loop < inl + padnum; loop++) |
292 | 0 | out[loop] = padval; |
293 | 0 | } |
294 | 0 | inl += padnum; |
295 | 0 | } |
296 | | |
297 | 0 | if ((inl % blksz) != 0) { |
298 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED); |
299 | 0 | return 0; |
300 | 0 | } |
301 | | |
302 | | |
303 | | /* Shouldn't normally fail */ |
304 | 0 | if (!ctx->hw->cipher(ctx, out, in, inl)) { |
305 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED); |
306 | 0 | return 0; |
307 | 0 | } |
308 | | |
309 | 0 | if (ctx->alloced) { |
310 | 0 | OPENSSL_free(ctx->tlsmac); |
311 | 0 | ctx->alloced = 0; |
312 | 0 | ctx->tlsmac = NULL; |
313 | 0 | } |
314 | | |
315 | | /* This only fails if padding is publicly invalid */ |
316 | 0 | *outl = inl; |
317 | 0 | if (!ctx->enc |
318 | 0 | && !ossl_cipher_tlsunpadblock(ctx->libctx, ctx->tlsversion, |
319 | 0 | out, outl, |
320 | 0 | blksz, &ctx->tlsmac, &ctx->alloced, |
321 | 0 | ctx->tlsmacsize, 0)) { |
322 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED); |
323 | 0 | return 0; |
324 | 0 | } |
325 | 0 | return 1; |
326 | 0 | } |
327 | | |
328 | 41 | if (ctx->bufsz != 0) |
329 | 0 | nextblocks = ossl_cipher_fillblock(ctx->buf, &ctx->bufsz, blksz, |
330 | 0 | &in, &inl); |
331 | 41 | else |
332 | 41 | nextblocks = inl & ~(blksz-1); |
333 | | |
334 | | /* |
335 | | * If we're decrypting and we end an update on a block boundary we hold |
336 | | * the last block back in case this is the last update call and the last |
337 | | * block is padded. |
338 | | */ |
339 | 41 | if (ctx->bufsz == blksz && (ctx->enc || inl > 0 || !ctx->pad)) { |
340 | 0 | if (outsize < blksz) { |
341 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL); |
342 | 0 | return 0; |
343 | 0 | } |
344 | 0 | if (!ctx->hw->cipher(ctx, out, ctx->buf, blksz)) { |
345 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED); |
346 | 0 | return 0; |
347 | 0 | } |
348 | 0 | ctx->bufsz = 0; |
349 | 0 | outlint = blksz; |
350 | 0 | out += blksz; |
351 | 0 | } |
352 | 41 | if (nextblocks > 0) { |
353 | 41 | if (!ctx->enc && ctx->pad && nextblocks == inl) { |
354 | 0 | if (!ossl_assert(inl >= blksz)) { |
355 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL); |
356 | 0 | return 0; |
357 | 0 | } |
358 | 0 | nextblocks -= blksz; |
359 | 0 | } |
360 | 41 | outlint += nextblocks; |
361 | 41 | if (outsize < outlint) { |
362 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL); |
363 | 0 | return 0; |
364 | 0 | } |
365 | 41 | } |
366 | 41 | if (nextblocks > 0) { |
367 | 41 | if (!ctx->hw->cipher(ctx, out, in, nextblocks)) { |
368 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED); |
369 | 0 | return 0; |
370 | 0 | } |
371 | 41 | in += nextblocks; |
372 | 41 | inl -= nextblocks; |
373 | 41 | } |
374 | 41 | if (inl != 0 |
375 | 41 | && !ossl_cipher_trailingdata(ctx->buf, &ctx->bufsz, blksz, &in, &inl)) { |
376 | | /* ERR_raise already called */ |
377 | 0 | return 0; |
378 | 0 | } |
379 | | |
380 | 41 | *outl = outlint; |
381 | 41 | return inl == 0; |
382 | 41 | } |
383 | | |
384 | | int ossl_cipher_generic_block_final(void *vctx, unsigned char *out, |
385 | | size_t *outl, size_t outsize) |
386 | 0 | { |
387 | 0 | PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx; |
388 | 0 | size_t blksz = ctx->blocksize; |
389 | |
|
390 | 0 | if (!ossl_prov_is_running()) |
391 | 0 | return 0; |
392 | | |
393 | 0 | if (ctx->tlsversion > 0) { |
394 | | /* We never finalize TLS, so this is an error */ |
395 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED); |
396 | 0 | return 0; |
397 | 0 | } |
398 | | |
399 | 0 | if (ctx->enc) { |
400 | 0 | if (ctx->pad) { |
401 | 0 | ossl_cipher_padblock(ctx->buf, &ctx->bufsz, blksz); |
402 | 0 | } else if (ctx->bufsz == 0) { |
403 | 0 | *outl = 0; |
404 | 0 | return 1; |
405 | 0 | } else if (ctx->bufsz != blksz) { |
406 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_WRONG_FINAL_BLOCK_LENGTH); |
407 | 0 | return 0; |
408 | 0 | } |
409 | | |
410 | 0 | if (outsize < blksz) { |
411 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL); |
412 | 0 | return 0; |
413 | 0 | } |
414 | 0 | if (!ctx->hw->cipher(ctx, out, ctx->buf, blksz)) { |
415 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED); |
416 | 0 | return 0; |
417 | 0 | } |
418 | 0 | ctx->bufsz = 0; |
419 | 0 | *outl = blksz; |
420 | 0 | return 1; |
421 | 0 | } |
422 | | |
423 | | /* Decrypting */ |
424 | 0 | if (ctx->bufsz != blksz) { |
425 | 0 | if (ctx->bufsz == 0 && !ctx->pad) { |
426 | 0 | *outl = 0; |
427 | 0 | return 1; |
428 | 0 | } |
429 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_WRONG_FINAL_BLOCK_LENGTH); |
430 | 0 | return 0; |
431 | 0 | } |
432 | | |
433 | 0 | if (!ctx->hw->cipher(ctx, ctx->buf, ctx->buf, blksz)) { |
434 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED); |
435 | 0 | return 0; |
436 | 0 | } |
437 | | |
438 | 0 | if (ctx->pad && !ossl_cipher_unpadblock(ctx->buf, &ctx->bufsz, blksz)) { |
439 | | /* ERR_raise already called */ |
440 | 0 | return 0; |
441 | 0 | } |
442 | | |
443 | 0 | if (outsize < ctx->bufsz) { |
444 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL); |
445 | 0 | return 0; |
446 | 0 | } |
447 | 0 | memcpy(out, ctx->buf, ctx->bufsz); |
448 | 0 | *outl = ctx->bufsz; |
449 | 0 | ctx->bufsz = 0; |
450 | 0 | return 1; |
451 | 0 | } |
452 | | |
453 | | int ossl_cipher_generic_stream_update(void *vctx, unsigned char *out, |
454 | | size_t *outl, size_t outsize, |
455 | | const unsigned char *in, size_t inl) |
456 | 4 | { |
457 | 4 | PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx; |
458 | | |
459 | 4 | if (inl == 0) { |
460 | 0 | *outl = 0; |
461 | 0 | return 1; |
462 | 0 | } |
463 | | |
464 | 4 | if (outsize < inl) { |
465 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL); |
466 | 0 | return 0; |
467 | 0 | } |
468 | | |
469 | 4 | if (!ctx->hw->cipher(ctx, out, in, inl)) { |
470 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED); |
471 | 0 | return 0; |
472 | 0 | } |
473 | | |
474 | 4 | *outl = inl; |
475 | 4 | if (!ctx->enc && ctx->tlsversion > 0) { |
476 | | /* |
477 | | * Remove any TLS padding. Only used by cipher_aes_cbc_hmac_sha1_hw.c and |
478 | | * cipher_aes_cbc_hmac_sha256_hw.c |
479 | | */ |
480 | 0 | if (ctx->removetlspad) { |
481 | | /* |
482 | | * We should have already failed in the cipher() call above if this |
483 | | * isn't true. |
484 | | */ |
485 | 0 | if (!ossl_assert(*outl >= (size_t)(out[inl - 1] + 1))) |
486 | 0 | return 0; |
487 | | /* The actual padding length */ |
488 | 0 | *outl -= out[inl - 1] + 1; |
489 | 0 | } |
490 | | |
491 | | /* TLS MAC and explicit IV if relevant. We should have already failed |
492 | | * in the cipher() call above if *outl is too short. |
493 | | */ |
494 | 0 | if (!ossl_assert(*outl >= ctx->removetlsfixed)) |
495 | 0 | return 0; |
496 | 0 | *outl -= ctx->removetlsfixed; |
497 | | |
498 | | /* Extract the MAC if there is one */ |
499 | 0 | if (ctx->tlsmacsize > 0) { |
500 | 0 | if (*outl < ctx->tlsmacsize) |
501 | 0 | return 0; |
502 | | |
503 | 0 | ctx->tlsmac = out + *outl - ctx->tlsmacsize; |
504 | 0 | *outl -= ctx->tlsmacsize; |
505 | 0 | } |
506 | 0 | } |
507 | | |
508 | 4 | return 1; |
509 | 4 | } |
510 | | int ossl_cipher_generic_stream_final(void *vctx, unsigned char *out, |
511 | | size_t *outl, size_t outsize) |
512 | 0 | { |
513 | 0 | if (!ossl_prov_is_running()) |
514 | 0 | return 0; |
515 | | |
516 | 0 | *outl = 0; |
517 | 0 | return 1; |
518 | 0 | } |
519 | | |
520 | | int ossl_cipher_generic_cipher(void *vctx, unsigned char *out, size_t *outl, |
521 | | size_t outsize, const unsigned char *in, |
522 | | size_t inl) |
523 | 0 | { |
524 | 0 | PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx; |
525 | |
|
526 | 0 | if (!ossl_prov_is_running()) |
527 | 0 | return 0; |
528 | | |
529 | 0 | if (outsize < inl) { |
530 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL); |
531 | 0 | return 0; |
532 | 0 | } |
533 | | |
534 | 0 | if (!ctx->hw->cipher(ctx, out, in, inl)) { |
535 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED); |
536 | 0 | return 0; |
537 | 0 | } |
538 | | |
539 | 0 | *outl = inl; |
540 | 0 | return 1; |
541 | 0 | } |
542 | | |
543 | | int ossl_cipher_generic_get_ctx_params(void *vctx, OSSL_PARAM params[]) |
544 | 7 | { |
545 | 7 | PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx; |
546 | 7 | OSSL_PARAM *p; |
547 | | |
548 | 7 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN); |
549 | 7 | if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->ivlen)) { |
550 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); |
551 | 0 | return 0; |
552 | 0 | } |
553 | 7 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_PADDING); |
554 | 7 | if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->pad)) { |
555 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); |
556 | 0 | return 0; |
557 | 0 | } |
558 | 7 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IV); |
559 | 7 | if (p != NULL |
560 | 7 | && !OSSL_PARAM_set_octet_ptr(p, &ctx->oiv, ctx->ivlen) |
561 | 7 | && !OSSL_PARAM_set_octet_string(p, &ctx->oiv, ctx->ivlen)) { |
562 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); |
563 | 0 | return 0; |
564 | 0 | } |
565 | 7 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_UPDATED_IV); |
566 | 7 | if (p != NULL |
567 | 7 | && !OSSL_PARAM_set_octet_ptr(p, &ctx->iv, ctx->ivlen) |
568 | 7 | && !OSSL_PARAM_set_octet_string(p, &ctx->iv, ctx->ivlen)) { |
569 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); |
570 | 0 | return 0; |
571 | 0 | } |
572 | 7 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_NUM); |
573 | 7 | if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->num)) { |
574 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); |
575 | 0 | return 0; |
576 | 0 | } |
577 | 7 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN); |
578 | 7 | if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->keylen)) { |
579 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); |
580 | 0 | return 0; |
581 | 0 | } |
582 | 7 | p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_TLS_MAC); |
583 | 7 | if (p != NULL |
584 | 7 | && !OSSL_PARAM_set_octet_ptr(p, ctx->tlsmac, ctx->tlsmacsize)) { |
585 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); |
586 | 0 | return 0; |
587 | 0 | } |
588 | 7 | return 1; |
589 | 7 | } |
590 | | |
591 | | int ossl_cipher_generic_set_ctx_params(void *vctx, const OSSL_PARAM params[]) |
592 | 35 | { |
593 | 35 | PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx; |
594 | 35 | const OSSL_PARAM *p; |
595 | | |
596 | 35 | if (params == NULL) |
597 | 35 | return 1; |
598 | | |
599 | 0 | p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_PADDING); |
600 | 0 | if (p != NULL) { |
601 | 0 | unsigned int pad; |
602 | |
|
603 | 0 | if (!OSSL_PARAM_get_uint(p, &pad)) { |
604 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER); |
605 | 0 | return 0; |
606 | 0 | } |
607 | 0 | ctx->pad = pad ? 1 : 0; |
608 | 0 | } |
609 | 0 | p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_USE_BITS); |
610 | 0 | if (p != NULL) { |
611 | 0 | unsigned int bits; |
612 | |
|
613 | 0 | if (!OSSL_PARAM_get_uint(p, &bits)) { |
614 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER); |
615 | 0 | return 0; |
616 | 0 | } |
617 | 0 | ctx->use_bits = bits ? 1 : 0; |
618 | 0 | } |
619 | 0 | p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_TLS_VERSION); |
620 | 0 | if (p != NULL) { |
621 | 0 | if (!OSSL_PARAM_get_uint(p, &ctx->tlsversion)) { |
622 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER); |
623 | 0 | return 0; |
624 | 0 | } |
625 | 0 | } |
626 | 0 | p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_TLS_MAC_SIZE); |
627 | 0 | if (p != NULL) { |
628 | 0 | if (!OSSL_PARAM_get_size_t(p, &ctx->tlsmacsize)) { |
629 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER); |
630 | 0 | return 0; |
631 | 0 | } |
632 | 0 | } |
633 | 0 | p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_NUM); |
634 | 0 | if (p != NULL) { |
635 | 0 | unsigned int num; |
636 | |
|
637 | 0 | if (!OSSL_PARAM_get_uint(p, &num)) { |
638 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER); |
639 | 0 | return 0; |
640 | 0 | } |
641 | 0 | ctx->num = num; |
642 | 0 | } |
643 | 0 | return 1; |
644 | 0 | } |
645 | | |
646 | | int ossl_cipher_generic_initiv(PROV_CIPHER_CTX *ctx, const unsigned char *iv, |
647 | | size_t ivlen) |
648 | 4 | { |
649 | 4 | if (ivlen != ctx->ivlen |
650 | 4 | || ivlen > sizeof(ctx->iv)) { |
651 | 0 | ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH); |
652 | 0 | return 0; |
653 | 0 | } |
654 | 4 | ctx->iv_set = 1; |
655 | 4 | memcpy(ctx->iv, iv, ivlen); |
656 | 4 | memcpy(ctx->oiv, iv, ivlen); |
657 | 4 | return 1; |
658 | 4 | } |
659 | | |
660 | | void ossl_cipher_generic_initkey(void *vctx, size_t kbits, size_t blkbits, |
661 | | size_t ivbits, unsigned int mode, |
662 | | uint64_t flags, const PROV_CIPHER_HW *hw, |
663 | | void *provctx) |
664 | 5 | { |
665 | 5 | PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx; |
666 | | |
667 | 5 | if ((flags & PROV_CIPHER_FLAG_INVERSE_CIPHER) != 0) |
668 | 0 | ctx->inverse_cipher = 1; |
669 | 5 | if ((flags & PROV_CIPHER_FLAG_VARIABLE_LENGTH) != 0) |
670 | 0 | ctx->variable_keylength = 1; |
671 | | |
672 | 5 | ctx->pad = 1; |
673 | 5 | ctx->keylen = ((kbits) / 8); |
674 | 5 | ctx->ivlen = ((ivbits) / 8); |
675 | 5 | ctx->hw = hw; |
676 | 5 | ctx->mode = mode; |
677 | 5 | ctx->blocksize = blkbits / 8; |
678 | 5 | if (provctx != NULL) |
679 | 5 | ctx->libctx = PROV_LIBCTX_OF(provctx); /* used for rand */ |
680 | 5 | } |