Move providers/common/{ciphers,digests}/* to providers/implementations
[openssl.git] / providers / implementations / ciphers / ciphercommon.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 /*
11  * Generic dispatch table functions for ciphers.
12  */
13
14 #include "ciphercommon_local.h"
15 #include "prov/provider_ctx.h"
16 #include "prov/providercommonerr.h"
17
18 /*-
19  * Generic cipher functions for OSSL_PARAM gettables and settables
20  */
21 static const OSSL_PARAM cipher_known_gettable_params[] = {
22     OSSL_PARAM_uint(OSSL_CIPHER_PARAM_MODE, NULL),
23     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
24     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
25     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_BLOCK_SIZE, NULL),
26     OSSL_PARAM_ulong(OSSL_CIPHER_PARAM_FLAGS, NULL),
27     OSSL_PARAM_END
28 };
29 const OSSL_PARAM *cipher_generic_gettable_params(void)
30 {
31     return cipher_known_gettable_params;
32 }
33
34 int cipher_generic_get_params(OSSL_PARAM params[], unsigned int md,
35                               unsigned long flags,
36                               size_t kbits, size_t blkbits, size_t ivbits)
37 {
38     OSSL_PARAM *p;
39
40     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_MODE);
41     if (p != NULL && !OSSL_PARAM_set_uint(p, md)) {
42         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
43         return 0;
44     }
45     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_FLAGS);
46     if (p != NULL && !OSSL_PARAM_set_ulong(p, flags)) {
47         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
48         return 0;
49     }
50     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN);
51     if (p != NULL && !OSSL_PARAM_set_size_t(p, kbits / 8)) {
52         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
53         return 0;
54     }
55     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_BLOCK_SIZE);
56     if (p != NULL && !OSSL_PARAM_set_size_t(p, blkbits / 8)) {
57         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
58         return 0;
59     }
60     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN);
61     if (p != NULL && !OSSL_PARAM_set_size_t(p, ivbits / 8)) {
62         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
63         return 0;
64     }
65     return 1;
66 }
67
68 CIPHER_DEFAULT_GETTABLE_CTX_PARAMS_START(cipher_generic)
69 CIPHER_DEFAULT_GETTABLE_CTX_PARAMS_END(cipher_generic)
70
71 CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_START(cipher_generic)
72 CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_END(cipher_generic)
73
74 /*
75  * Variable key length cipher functions for OSSL_PARAM settables
76  */
77
78 int cipher_var_keylen_set_ctx_params(void *vctx, const OSSL_PARAM params[])
79 {
80     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
81     const OSSL_PARAM *p;
82
83     if (!cipher_generic_set_ctx_params(vctx, params))
84         return 0;
85     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_KEYLEN);
86     if (p != NULL) {
87         size_t keylen;
88
89         if (!OSSL_PARAM_get_size_t(p, &keylen)) {
90             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
91             return 0;
92         }
93         ctx->keylen = keylen;
94     }
95     return 1;
96 }
97
98 CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_START(cipher_var_keylen)
99 OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
100 CIPHER_DEFAULT_SETTABLE_CTX_PARAMS_END(cipher_var_keylen)
101
102 /*-
103  * AEAD cipher functions for OSSL_PARAM gettables and settables
104  */
105 static const OSSL_PARAM cipher_aead_known_gettable_ctx_params[] = {
106     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
107     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
108     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TAGLEN, NULL),
109     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0),
110     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
111     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD, NULL),
112     OSSL_PARAM_END
113 };
114 const OSSL_PARAM *cipher_aead_gettable_ctx_params(void)
115 {
116     return cipher_aead_known_gettable_ctx_params;
117 }
118
119 static const OSSL_PARAM cipher_aead_known_settable_ctx_params[] = {
120     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_IVLEN, NULL),
121     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
122     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD, NULL, 0),
123     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED, NULL, 0),
124     OSSL_PARAM_END
125 };
126 const OSSL_PARAM *cipher_aead_settable_ctx_params(void)
127 {
128     return cipher_aead_known_settable_ctx_params;
129 }
130
131 static int cipher_generic_init_internal(PROV_CIPHER_CTX *ctx,
132                                         const unsigned char *key, size_t keylen,
133                                         const unsigned char *iv, size_t ivlen,
134                                         int enc)
135 {
136     ctx->enc = enc ? 1 : 0;
137
138     if (iv != NULL && ctx->mode != EVP_CIPH_ECB_MODE) {
139         if (!cipher_generic_initiv(ctx, iv, ivlen))
140             return 0;
141     }
142     if (key != NULL) {
143         if ((ctx->flags & EVP_CIPH_VARIABLE_LENGTH) == 0) {
144             if (keylen != ctx->keylen) {
145                 ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEYLEN);
146                 return 0;
147             }
148         } else {
149             ctx->keylen = keylen;
150         }
151         return ctx->hw->init(ctx, key, ctx->keylen);
152     }
153     return 1;
154 }
155
156 int cipher_generic_einit(void *vctx, const unsigned char *key, size_t keylen,
157                          const unsigned char *iv, size_t ivlen)
158 {
159     return cipher_generic_init_internal((PROV_CIPHER_CTX *)vctx, key, keylen,
160                                         iv, ivlen, 1);
161 }
162
163 int cipher_generic_dinit(void *vctx, const unsigned char *key, size_t keylen,
164                          const unsigned char *iv, size_t ivlen)
165 {
166     return cipher_generic_init_internal((PROV_CIPHER_CTX *)vctx, key, keylen,
167                                         iv, ivlen, 0);
168 }
169
170 int cipher_generic_block_update(void *vctx, unsigned char *out, size_t *outl,
171                                 size_t outsize, const unsigned char *in,
172                                 size_t inl)
173 {
174     size_t outlint = 0;
175     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
176     size_t blksz = ctx->blocksize;
177     size_t nextblocks = fillblock(ctx->buf, &ctx->bufsz, blksz, &in, &inl);
178
179     /*
180      * If we're decrypting and we end an update on a block boundary we hold
181      * the last block back in case this is the last update call and the last
182      * block is padded.
183      */
184     if (ctx->bufsz == blksz && (ctx->enc || inl > 0 || !ctx->pad)) {
185         if (outsize < blksz) {
186             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
187             return 0;
188         }
189         if (!ctx->hw->cipher(ctx, out, ctx->buf, blksz)) {
190             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
191             return 0;
192         }
193         ctx->bufsz = 0;
194         outlint = blksz;
195         out += blksz;
196     }
197     if (nextblocks > 0) {
198         if (!ctx->enc && ctx->pad && nextblocks == inl) {
199             if (!ossl_assert(inl >= blksz)) {
200                 ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
201                 return 0;
202             }
203             nextblocks -= blksz;
204         }
205         outlint += nextblocks;
206         if (outsize < outlint) {
207             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
208             return 0;
209         }
210     }
211     if (nextblocks > 0) {
212         if (!ctx->hw->cipher(ctx, out, in, nextblocks)) {
213             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
214             return 0;
215         }
216         in += nextblocks;
217         inl -= nextblocks;
218     }
219     if (!trailingdata(ctx->buf, &ctx->bufsz, blksz, &in, &inl)) {
220         /* ERR_raise already called */
221         return 0;
222     }
223
224     *outl = outlint;
225     return inl == 0;
226 }
227
228 int cipher_generic_block_final(void *vctx, unsigned char *out, size_t *outl,
229                                size_t outsize)
230 {
231     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
232     size_t blksz = ctx->blocksize;
233
234     if (ctx->enc) {
235         if (ctx->pad) {
236             padblock(ctx->buf, &ctx->bufsz, blksz);
237         } else if (ctx->bufsz == 0) {
238             *outl = 0;
239             return 1;
240         } else if (ctx->bufsz != blksz) {
241             ERR_raise(ERR_LIB_PROV, PROV_R_WRONG_FINAL_BLOCK_LENGTH);
242             return 0;
243         }
244
245         if (outsize < blksz) {
246             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
247             return 0;
248         }
249         if (!ctx->hw->cipher(ctx, out, ctx->buf, blksz)) {
250             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
251             return 0;
252         }
253         ctx->bufsz = 0;
254         *outl = blksz;
255         return 1;
256     }
257
258     /* Decrypting */
259     if (ctx->bufsz != blksz) {
260         if (ctx->bufsz == 0 && !ctx->pad) {
261             *outl = 0;
262             return 1;
263         }
264         ERR_raise(ERR_LIB_PROV, PROV_R_WRONG_FINAL_BLOCK_LENGTH);
265         return 0;
266     }
267
268     if (!ctx->hw->cipher(ctx, ctx->buf, ctx->buf, blksz)) {
269         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
270         return 0;
271     }
272
273     if (ctx->pad && !unpadblock(ctx->buf, &ctx->bufsz, blksz)) {
274         /* ERR_raise already called */
275         return 0;
276     }
277
278     if (outsize < ctx->bufsz) {
279         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
280         return 0;
281     }
282     memcpy(out, ctx->buf, ctx->bufsz);
283     *outl = ctx->bufsz;
284     ctx->bufsz = 0;
285     return 1;
286 }
287
288 int cipher_generic_stream_update(void *vctx, unsigned char *out, size_t *outl,
289                                  size_t outsize, const unsigned char *in,
290                                  size_t inl)
291 {
292     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
293
294     if (inl == 0) {
295         *outl = 0;
296         return 1;
297     }
298
299     if (outsize < inl) {
300         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
301         return 0;
302     }
303
304     if (!ctx->hw->cipher(ctx, out, in, inl)) {
305         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
306         return 0;
307     }
308
309     *outl = inl;
310     return 1;
311 }
312 int cipher_generic_stream_final(void *vctx, unsigned char *out, size_t *outl,
313                                 size_t outsize)
314 {
315     *outl = 0;
316     return 1;
317 }
318
319 int cipher_generic_cipher(void *vctx,
320                           unsigned char *out, size_t *outl, size_t outsize,
321                           const unsigned char *in, size_t inl)
322 {
323     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
324
325     if (outsize < inl) {
326         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
327         return 0;
328     }
329
330     if (!ctx->hw->cipher(ctx, out, in, inl)) {
331         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
332         return 0;
333     }
334
335     *outl = inl;
336     return 1;
337 }
338
339 int cipher_generic_get_ctx_params(void *vctx, OSSL_PARAM params[])
340 {
341     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
342     OSSL_PARAM *p;
343
344     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN);
345     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->ivlen)) {
346         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
347         return 0;
348     }
349     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_PADDING);
350     if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->pad)) {
351         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
352         return 0;
353     }
354     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IV);
355     if (p != NULL
356         && !OSSL_PARAM_set_octet_ptr(p, &ctx->oiv, ctx->ivlen)
357         && !OSSL_PARAM_set_octet_string(p, &ctx->oiv, ctx->ivlen)) {
358         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
359         return 0;
360     }
361     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_NUM);
362     if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->num)) {
363         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
364         return 0;
365     }
366     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN);
367     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->keylen)) {
368         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
369         return 0;
370     }
371     return 1;
372 }
373
374 int cipher_generic_set_ctx_params(void *vctx, const OSSL_PARAM params[])
375 {
376     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
377     const OSSL_PARAM *p;
378
379     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_PADDING);
380     if (p != NULL) {
381         unsigned int pad;
382
383         if (!OSSL_PARAM_get_uint(p, &pad)) {
384             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
385             return 0;
386         }
387         ctx->pad = pad ? 1 : 0;
388     }
389     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_NUM);
390     if (p != NULL) {
391         unsigned int num;
392
393         if (!OSSL_PARAM_get_uint(p, &num)) {
394             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
395             return 0;
396         }
397         ctx->num = num;
398     }
399     return 1;
400 }
401
402 int cipher_generic_initiv(PROV_CIPHER_CTX *ctx, const unsigned char *iv,
403                           size_t ivlen)
404 {
405     if (ivlen != ctx->ivlen
406         || ivlen > sizeof(ctx->iv)) {
407         ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IVLEN);
408         return 0;
409     }
410     ctx->iv_set = 1;
411     memcpy(ctx->iv, iv, ivlen);
412     memcpy(ctx->oiv, iv, ivlen);
413     return 1;
414 }
415
416 void cipher_generic_initkey(void *vctx, size_t kbits, size_t blkbits,
417                             size_t ivbits, unsigned int mode, uint64_t flags,
418                             const PROV_CIPHER_HW *hw, void *provctx)
419 {
420     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
421
422     ctx->flags = flags;
423     ctx->pad = 1;
424     ctx->keylen = ((kbits) / 8);
425     ctx->ivlen = ((ivbits) / 8);
426     ctx->hw = hw;
427     ctx->mode = mode;
428     ctx->blocksize = blkbits / 8;
429     if (provctx != NULL)
430         ctx->libctx = PROV_LIBRARY_CONTEXT_OF(provctx); /* used for rand */
431 }