Improve small block cipher performance
[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_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN, NULL, 0),
113     OSSL_PARAM_END
114 };
115 const OSSL_PARAM *cipher_aead_gettable_ctx_params(void)
116 {
117     return cipher_aead_known_gettable_ctx_params;
118 }
119
120 static const OSSL_PARAM cipher_aead_known_settable_ctx_params[] = {
121     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_IVLEN, NULL),
122     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
123     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD, NULL, 0),
124     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED, NULL, 0),
125     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_SET_IV_INV, NULL, 0),
126     OSSL_PARAM_END
127 };
128 const OSSL_PARAM *cipher_aead_settable_ctx_params(void)
129 {
130     return cipher_aead_known_settable_ctx_params;
131 }
132
133 static int cipher_generic_init_internal(PROV_CIPHER_CTX *ctx,
134                                         const unsigned char *key, size_t keylen,
135                                         const unsigned char *iv, size_t ivlen,
136                                         int enc)
137 {
138     ctx->enc = enc ? 1 : 0;
139
140     if (iv != NULL && ctx->mode != EVP_CIPH_ECB_MODE) {
141         if (!cipher_generic_initiv(ctx, iv, ivlen))
142             return 0;
143     }
144     if (key != NULL) {
145         if ((ctx->flags & EVP_CIPH_VARIABLE_LENGTH) == 0) {
146             if (keylen != ctx->keylen) {
147                 ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEYLEN);
148                 return 0;
149             }
150         } else {
151             ctx->keylen = keylen;
152         }
153         return ctx->hw->init(ctx, key, ctx->keylen);
154     }
155     return 1;
156 }
157
158 int cipher_generic_einit(void *vctx, const unsigned char *key, size_t keylen,
159                          const unsigned char *iv, size_t ivlen)
160 {
161     return cipher_generic_init_internal((PROV_CIPHER_CTX *)vctx, key, keylen,
162                                         iv, ivlen, 1);
163 }
164
165 int cipher_generic_dinit(void *vctx, const unsigned char *key, size_t keylen,
166                          const unsigned char *iv, size_t ivlen)
167 {
168     return cipher_generic_init_internal((PROV_CIPHER_CTX *)vctx, key, keylen,
169                                         iv, ivlen, 0);
170 }
171
172 int cipher_generic_block_update(void *vctx, unsigned char *out, size_t *outl,
173                                 size_t outsize, const unsigned char *in,
174                                 size_t inl)
175 {
176     size_t outlint = 0;
177     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
178     size_t blksz = ctx->blocksize;
179     size_t nextblocks;
180
181     if (ctx->bufsz != 0)
182         nextblocks = fillblock(ctx->buf, &ctx->bufsz, blksz, &in, &inl);
183     else
184         nextblocks = inl & ~(blksz-1);
185
186     /*
187      * If we're decrypting and we end an update on a block boundary we hold
188      * the last block back in case this is the last update call and the last
189      * block is padded.
190      */
191     if (ctx->bufsz == blksz && (ctx->enc || inl > 0 || !ctx->pad)) {
192         if (outsize < blksz) {
193             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
194             return 0;
195         }
196         if (!ctx->hw->cipher(ctx, out, ctx->buf, blksz)) {
197             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
198             return 0;
199         }
200         ctx->bufsz = 0;
201         outlint = blksz;
202         out += blksz;
203     }
204     if (nextblocks > 0) {
205         if (!ctx->enc && ctx->pad && nextblocks == inl) {
206             if (!ossl_assert(inl >= blksz)) {
207                 ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
208                 return 0;
209             }
210             nextblocks -= blksz;
211         }
212         outlint += nextblocks;
213         if (outsize < outlint) {
214             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
215             return 0;
216         }
217     }
218     if (nextblocks > 0) {
219         if (!ctx->hw->cipher(ctx, out, in, nextblocks)) {
220             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
221             return 0;
222         }
223         in += nextblocks;
224         inl -= nextblocks;
225     }
226     if (inl != 0 && !trailingdata(ctx->buf, &ctx->bufsz, blksz, &in, &inl)) {
227         /* ERR_raise already called */
228         return 0;
229     }
230
231     *outl = outlint;
232     return inl == 0;
233 }
234
235 int cipher_generic_block_final(void *vctx, unsigned char *out, size_t *outl,
236                                size_t outsize)
237 {
238     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
239     size_t blksz = ctx->blocksize;
240
241     if (ctx->enc) {
242         if (ctx->pad) {
243             padblock(ctx->buf, &ctx->bufsz, blksz);
244         } else if (ctx->bufsz == 0) {
245             *outl = 0;
246             return 1;
247         } else if (ctx->bufsz != blksz) {
248             ERR_raise(ERR_LIB_PROV, PROV_R_WRONG_FINAL_BLOCK_LENGTH);
249             return 0;
250         }
251
252         if (outsize < blksz) {
253             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
254             return 0;
255         }
256         if (!ctx->hw->cipher(ctx, out, ctx->buf, blksz)) {
257             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
258             return 0;
259         }
260         ctx->bufsz = 0;
261         *outl = blksz;
262         return 1;
263     }
264
265     /* Decrypting */
266     if (ctx->bufsz != blksz) {
267         if (ctx->bufsz == 0 && !ctx->pad) {
268             *outl = 0;
269             return 1;
270         }
271         ERR_raise(ERR_LIB_PROV, PROV_R_WRONG_FINAL_BLOCK_LENGTH);
272         return 0;
273     }
274
275     if (!ctx->hw->cipher(ctx, ctx->buf, ctx->buf, blksz)) {
276         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
277         return 0;
278     }
279
280     if (ctx->pad && !unpadblock(ctx->buf, &ctx->bufsz, blksz)) {
281         /* ERR_raise already called */
282         return 0;
283     }
284
285     if (outsize < ctx->bufsz) {
286         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
287         return 0;
288     }
289     memcpy(out, ctx->buf, ctx->bufsz);
290     *outl = ctx->bufsz;
291     ctx->bufsz = 0;
292     return 1;
293 }
294
295 int cipher_generic_stream_update(void *vctx, unsigned char *out, size_t *outl,
296                                  size_t outsize, const unsigned char *in,
297                                  size_t inl)
298 {
299     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
300
301     if (inl == 0) {
302         *outl = 0;
303         return 1;
304     }
305
306     if (outsize < inl) {
307         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
308         return 0;
309     }
310
311     if (!ctx->hw->cipher(ctx, out, in, inl)) {
312         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
313         return 0;
314     }
315
316     *outl = inl;
317     return 1;
318 }
319 int cipher_generic_stream_final(void *vctx, unsigned char *out, size_t *outl,
320                                 size_t outsize)
321 {
322     *outl = 0;
323     return 1;
324 }
325
326 int cipher_generic_cipher(void *vctx,
327                           unsigned char *out, size_t *outl, size_t outsize,
328                           const unsigned char *in, size_t inl)
329 {
330     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
331
332     if (outsize < inl) {
333         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
334         return 0;
335     }
336
337     if (!ctx->hw->cipher(ctx, out, in, inl)) {
338         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
339         return 0;
340     }
341
342     *outl = inl;
343     return 1;
344 }
345
346 int cipher_generic_get_ctx_params(void *vctx, OSSL_PARAM params[])
347 {
348     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
349     OSSL_PARAM *p;
350
351     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN);
352     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->ivlen)) {
353         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
354         return 0;
355     }
356     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_PADDING);
357     if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->pad)) {
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_IV);
362     if (p != NULL
363         && !OSSL_PARAM_set_octet_ptr(p, &ctx->oiv, ctx->ivlen)
364         && !OSSL_PARAM_set_octet_string(p, &ctx->oiv, ctx->ivlen)) {
365         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
366         return 0;
367     }
368     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_NUM);
369     if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->num)) {
370         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
371         return 0;
372     }
373     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN);
374     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->keylen)) {
375         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
376         return 0;
377     }
378     return 1;
379 }
380
381 int cipher_generic_set_ctx_params(void *vctx, const OSSL_PARAM params[])
382 {
383     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
384     const OSSL_PARAM *p;
385
386     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_PADDING);
387     if (p != NULL) {
388         unsigned int pad;
389
390         if (!OSSL_PARAM_get_uint(p, &pad)) {
391             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
392             return 0;
393         }
394         ctx->pad = pad ? 1 : 0;
395     }
396     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_NUM);
397     if (p != NULL) {
398         unsigned int num;
399
400         if (!OSSL_PARAM_get_uint(p, &num)) {
401             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
402             return 0;
403         }
404         ctx->num = num;
405     }
406     return 1;
407 }
408
409 int cipher_generic_initiv(PROV_CIPHER_CTX *ctx, const unsigned char *iv,
410                           size_t ivlen)
411 {
412     if (ivlen != ctx->ivlen
413         || ivlen > sizeof(ctx->iv)) {
414         ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IVLEN);
415         return 0;
416     }
417     ctx->iv_set = 1;
418     memcpy(ctx->iv, iv, ivlen);
419     memcpy(ctx->oiv, iv, ivlen);
420     return 1;
421 }
422
423 void cipher_generic_initkey(void *vctx, size_t kbits, size_t blkbits,
424                             size_t ivbits, unsigned int mode, uint64_t flags,
425                             const PROV_CIPHER_HW *hw, void *provctx)
426 {
427     PROV_CIPHER_CTX *ctx = (PROV_CIPHER_CTX *)vctx;
428
429     ctx->flags = flags;
430     ctx->pad = 1;
431     ctx->keylen = ((kbits) / 8);
432     ctx->ivlen = ((ivbits) / 8);
433     ctx->hw = hw;
434     ctx->mode = mode;
435     ctx->blocksize = blkbits / 8;
436     if (provctx != NULL)
437         ctx->libctx = PROV_LIBRARY_CONTEXT_OF(provctx); /* used for rand */
438 }