Make the RSA_METHOD structure opaque
[openssl.git] / engines / e_dasync.c
1 /*
2  * Written by Matt Caswell (matt@openssl.org) for the OpenSSL project.
3  */
4 /* ====================================================================
5  * Copyright (c) 2015 The OpenSSL Project.  All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  *
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in
16  *    the documentation and/or other materials provided with the
17  *    distribution.
18  *
19  * 3. All advertising materials mentioning features or use of this
20  *    software must display the following acknowledgment:
21  *    "This product includes software developed by the OpenSSL Project
22  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
23  *
24  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
25  *    endorse or promote products derived from this software without
26  *    prior written permission. For written permission, please contact
27  *    licensing@OpenSSL.org.
28  *
29  * 5. Products derived from this software may not be called "OpenSSL"
30  *    nor may "OpenSSL" appear in their names without prior written
31  *    permission of the OpenSSL Project.
32  *
33  * 6. Redistributions of any form whatsoever must retain the following
34  *    acknowledgment:
35  *    "This product includes software developed by the OpenSSL Project
36  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
37  *
38  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
39  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
40  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
41  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
42  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
43  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
44  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
45  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
46  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
47  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
48  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
49  * OF THE POSSIBILITY OF SUCH DAMAGE.
50  * ====================================================================
51  */
52
53 #include <stdio.h>
54 #include <string.h>
55
56 #include <openssl/engine.h>
57 #include <openssl/sha.h>
58 #include <openssl/aes.h>
59 #include <openssl/rsa.h>
60 #include <openssl/evp.h>
61 #include <openssl/async.h>
62 #include <openssl/bn.h>
63 #include <openssl/crypto.h>
64 #include <openssl/ssl.h>
65 #include <openssl/modes.h>
66
67 #if (defined(OPENSSL_SYS_UNIX) || defined(OPENSSL_SYS_CYGWIN)) && defined(OPENSSL_THREADS)
68 # undef ASYNC_POSIX
69 # define ASYNC_POSIX
70 # include <unistd.h>
71 #elif defined(_WIN32)
72 # undef ASYNC_WIN
73 # define ASYNC_WIN
74 # include <windows.h>
75 #endif
76
77 #define DASYNC_LIB_NAME "DASYNC"
78 #include "e_dasync_err.c"
79
80 /* Engine Id and Name */
81 static const char *engine_dasync_id = "dasync";
82 static const char *engine_dasync_name = "Dummy Async engine support";
83
84
85 /* Engine Lifetime functions */
86 static int dasync_destroy(ENGINE *e);
87 static int dasync_init(ENGINE *e);
88 static int dasync_finish(ENGINE *e);
89 void engine_load_dasync_internal(void);
90
91
92 /* Set up digests. Just SHA1 for now */
93 static int dasync_digests(ENGINE *e, const EVP_MD **digest,
94                           const int **nids, int nid);
95
96 static void dummy_pause_job(void);
97
98 /* SHA1 */
99 static int dasync_sha1_init(EVP_MD_CTX *ctx);
100 static int dasync_sha1_update(EVP_MD_CTX *ctx, const void *data,
101                              size_t count);
102 static int dasync_sha1_final(EVP_MD_CTX *ctx, unsigned char *md);
103
104 /*
105  * Holds the EVP_MD object for sha1 in this engine. Set up once only during
106  * engine bind and can then be reused many times.
107  */
108 static EVP_MD *_hidden_sha1_md = NULL;
109 static const EVP_MD *dasync_sha1(void)
110 {
111     return _hidden_sha1_md;
112 }
113 static void destroy_digests(void)
114 {
115     EVP_MD_meth_free(_hidden_sha1_md);
116     _hidden_sha1_md = NULL;
117 }
118
119 static int dasync_digest_nids(const int **nids)
120 {
121     static int digest_nids[2] = { 0, 0 };
122     static int pos = 0;
123     static int init = 0;
124
125     if (!init) {
126         const EVP_MD *md;
127         if ((md = dasync_sha1()) != NULL)
128             digest_nids[pos++] = EVP_MD_type(md);
129         digest_nids[pos] = 0;
130         init = 1;
131     }
132     *nids = digest_nids;
133     return pos;
134 }
135
136 /* RSA */
137
138 static int dasync_pub_enc(int flen, const unsigned char *from,
139                     unsigned char *to, RSA *rsa, int padding);
140 static int dasync_pub_dec(int flen, const unsigned char *from,
141                     unsigned char *to, RSA *rsa, int padding);
142 static int dasync_rsa_priv_enc(int flen, const unsigned char *from,
143                       unsigned char *to, RSA *rsa, int padding);
144 static int dasync_rsa_priv_dec(int flen, const unsigned char *from,
145                       unsigned char *to, RSA *rsa, int padding);
146 static int dasync_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa,
147                               BN_CTX *ctx);
148
149 static int dasync_rsa_init(RSA *rsa);
150 static int dasync_rsa_finish(RSA *rsa);
151
152 static RSA_METHOD *dasync_rsa_method = NULL;
153
154 /* AES */
155
156 static int dasync_aes128_cbc_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg,
157                                   void *ptr);
158 static int dasync_aes128_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
159                                   const unsigned char *iv, int enc);
160 static int dasync_aes128_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
161                                     const unsigned char *in, size_t inl);
162 static int dasync_aes128_cbc_cleanup(EVP_CIPHER_CTX *ctx);
163
164 static int dasync_aes128_cbc_hmac_sha1_ctrl(EVP_CIPHER_CTX *ctx, int type,
165                                              int arg, void *ptr);
166 static int dasync_aes128_cbc_hmac_sha1_init_key(EVP_CIPHER_CTX *ctx,
167                                                  const unsigned char *key,
168                                                  const unsigned char *iv,
169                                                  int enc);
170 static int dasync_aes128_cbc_hmac_sha1_cipher(EVP_CIPHER_CTX *ctx,
171                                                unsigned char *out,
172                                                const unsigned char *in,
173                                                size_t inl);
174 static int dasync_aes128_cbc_hmac_sha1_cleanup(EVP_CIPHER_CTX *ctx);
175
176 struct dasync_pipeline_ctx {
177     void *inner_cipher_data;
178     unsigned int numpipes;
179     unsigned char **inbufs;
180     unsigned char **outbufs;
181     size_t *lens;
182     int enc;
183     unsigned char tlsaad[SSL_MAX_PIPELINES][EVP_AEAD_TLS1_AAD_LEN];
184     unsigned int aadctr;
185 };
186
187 /*
188  * Holds the EVP_CIPHER object for aes_128_cbc in this engine. Set up once only
189  * during engine bind and can then be reused many times.
190  */
191 static EVP_CIPHER *_hidden_aes_128_cbc = NULL;
192 static const EVP_CIPHER *dasync_aes_128_cbc(void)
193 {
194     return _hidden_aes_128_cbc;
195 }
196
197 /*
198  * Holds the EVP_CIPHER object for aes_128_cbc_hmac_sha1 in this engine. Set up
199  * once only during engine bind and can then be reused many times.
200  */
201 static EVP_CIPHER *_hidden_aes_128_cbc_hmac_sha1 = NULL;
202 static const EVP_CIPHER *dasync_aes_128_cbc_hmac_sha1(void)
203 {
204     return _hidden_aes_128_cbc_hmac_sha1;
205 }
206
207 static void destroy_ciphers(void)
208 {
209     EVP_CIPHER_meth_free(_hidden_aes_128_cbc);
210     EVP_CIPHER_meth_free(_hidden_aes_128_cbc_hmac_sha1);
211     _hidden_aes_128_cbc = NULL;
212     _hidden_aes_128_cbc_hmac_sha1 = NULL;
213 }
214
215 static int dasync_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
216                                    const int **nids, int nid);
217
218 static int dasync_cipher_nids[] = {
219     NID_aes_128_cbc,
220     NID_aes_128_cbc_hmac_sha1,
221     0
222 };
223
224 static int bind_dasync(ENGINE *e)
225 {
226     /* Setup RSA_METHOD */
227     if ((dasync_rsa_method = RSA_meth_new("Dummy Async RSA method", 0)) == NULL
228         || RSA_meth_set_pub_enc(dasync_rsa_method, dasync_pub_enc) == 0
229         || RSA_meth_set_pub_dec(dasync_rsa_method, dasync_pub_dec) == 0
230         || RSA_meth_set_priv_enc(dasync_rsa_method, dasync_rsa_priv_enc) == 0
231         || RSA_meth_set_priv_enc(dasync_rsa_method, dasync_rsa_priv_dec) == 0
232         || RSA_meth_set_mod_exp(dasync_rsa_method, dasync_rsa_mod_exp) == 0
233         || RSA_meth_set_bn_mod_exp(dasync_rsa_method, BN_mod_exp_mont) == 0
234         || RSA_meth_set_init(dasync_rsa_method, dasync_rsa_init) == 0
235         || RSA_meth_set_finish(dasync_rsa_method, dasync_rsa_finish) == 0) {
236         DASYNCerr(DASYNC_F_BIND_DASYNC, DASYNC_R_INIT_FAILED);
237         return 0;
238     }
239
240     /* Ensure the dasync error handling is set up */
241     ERR_load_DASYNC_strings();
242
243     if (!ENGINE_set_id(e, engine_dasync_id)
244         || !ENGINE_set_name(e, engine_dasync_name)
245         || !ENGINE_set_RSA(e, dasync_rsa_method)
246         || !ENGINE_set_digests(e, dasync_digests)
247         || !ENGINE_set_ciphers(e, dasync_ciphers)
248         || !ENGINE_set_destroy_function(e, dasync_destroy)
249         || !ENGINE_set_init_function(e, dasync_init)
250         || !ENGINE_set_finish_function(e, dasync_finish)) {
251         DASYNCerr(DASYNC_F_BIND_DASYNC, DASYNC_R_INIT_FAILED);
252         return 0;
253     }
254
255     /*
256      * Set up the EVP_CIPHER and EVP_MD objects for the ciphers/digests
257      * supplied by this engine
258      */
259     _hidden_sha1_md = EVP_MD_meth_new(NID_sha1, NID_sha1WithRSAEncryption);
260     if (_hidden_sha1_md == NULL
261         || !EVP_MD_meth_set_result_size(_hidden_sha1_md, SHA_DIGEST_LENGTH)
262         || !EVP_MD_meth_set_input_blocksize(_hidden_sha1_md, SHA_CBLOCK)
263         || !EVP_MD_meth_set_app_datasize(_hidden_sha1_md,
264                                          sizeof(EVP_MD *) + sizeof(SHA_CTX))
265         || !EVP_MD_meth_set_flags(_hidden_sha1_md, EVP_MD_FLAG_DIGALGID_ABSENT)
266         || !EVP_MD_meth_set_init(_hidden_sha1_md, dasync_sha1_init)
267         || !EVP_MD_meth_set_update(_hidden_sha1_md, dasync_sha1_update)
268         || !EVP_MD_meth_set_final(_hidden_sha1_md, dasync_sha1_final)) {
269         EVP_MD_meth_free(_hidden_sha1_md);
270         _hidden_sha1_md = NULL;
271     }
272
273     _hidden_aes_128_cbc = EVP_CIPHER_meth_new(NID_aes_128_cbc,
274                                               16 /* block size */,
275                                               16 /* key len */);
276     if (_hidden_aes_128_cbc == NULL
277             || !EVP_CIPHER_meth_set_iv_length(_hidden_aes_128_cbc,16)
278             || !EVP_CIPHER_meth_set_flags(_hidden_aes_128_cbc,
279                                           EVP_CIPH_FLAG_DEFAULT_ASN1
280                                           | EVP_CIPH_CBC_MODE
281                                           | EVP_CIPH_FLAG_PIPELINE)
282             || !EVP_CIPHER_meth_set_init(_hidden_aes_128_cbc,
283                                          dasync_aes128_init_key)
284             || !EVP_CIPHER_meth_set_do_cipher(_hidden_aes_128_cbc,
285                                               dasync_aes128_cbc_cipher)
286             || !EVP_CIPHER_meth_set_cleanup(_hidden_aes_128_cbc,
287                                             dasync_aes128_cbc_cleanup)
288             || !EVP_CIPHER_meth_set_ctrl(_hidden_aes_128_cbc,
289                                          dasync_aes128_cbc_ctrl)
290             || !EVP_CIPHER_meth_set_impl_ctx_size(_hidden_aes_128_cbc,
291                                 sizeof(struct dasync_pipeline_ctx))) {
292         EVP_CIPHER_meth_free(_hidden_aes_128_cbc);
293         _hidden_aes_128_cbc = NULL;
294     }
295
296     _hidden_aes_128_cbc_hmac_sha1 = EVP_CIPHER_meth_new(
297                                                 NID_aes_128_cbc_hmac_sha1,
298                                                 16 /* block size */,
299                                                 16 /* key len */);
300     if (_hidden_aes_128_cbc_hmac_sha1 == NULL
301             || !EVP_CIPHER_meth_set_iv_length(_hidden_aes_128_cbc_hmac_sha1,16)
302             || !EVP_CIPHER_meth_set_flags(_hidden_aes_128_cbc_hmac_sha1,
303                                             EVP_CIPH_CBC_MODE
304                                           | EVP_CIPH_FLAG_DEFAULT_ASN1
305                                           | EVP_CIPH_FLAG_AEAD_CIPHER
306                                           | EVP_CIPH_FLAG_PIPELINE)
307             || !EVP_CIPHER_meth_set_init(_hidden_aes_128_cbc_hmac_sha1,
308                                          dasync_aes128_cbc_hmac_sha1_init_key)
309             || !EVP_CIPHER_meth_set_do_cipher(_hidden_aes_128_cbc_hmac_sha1,
310                                             dasync_aes128_cbc_hmac_sha1_cipher)
311             || !EVP_CIPHER_meth_set_cleanup(_hidden_aes_128_cbc_hmac_sha1,
312                                             dasync_aes128_cbc_hmac_sha1_cleanup)
313             || !EVP_CIPHER_meth_set_ctrl(_hidden_aes_128_cbc_hmac_sha1,
314                                          dasync_aes128_cbc_hmac_sha1_ctrl)
315             || !EVP_CIPHER_meth_set_impl_ctx_size(_hidden_aes_128_cbc_hmac_sha1,
316                                 sizeof(struct dasync_pipeline_ctx))) {
317         EVP_CIPHER_meth_free(_hidden_aes_128_cbc_hmac_sha1);
318         _hidden_aes_128_cbc_hmac_sha1 = NULL;
319     }
320
321     return 1;
322 }
323
324 # ifndef OPENSSL_NO_DYNAMIC_ENGINE
325 static int bind_helper(ENGINE *e, const char *id)
326 {
327     if (id && (strcmp(id, engine_dasync_id) != 0))
328         return 0;
329     if (!bind_dasync(e))
330         return 0;
331     return 1;
332 }
333
334 IMPLEMENT_DYNAMIC_CHECK_FN()
335     IMPLEMENT_DYNAMIC_BIND_FN(bind_helper)
336 # endif
337
338 static ENGINE *engine_dasync(void)
339 {
340     ENGINE *ret = ENGINE_new();
341     if (!ret)
342         return NULL;
343     if (!bind_dasync(ret)) {
344         ENGINE_free(ret);
345         return NULL;
346     }
347     return ret;
348 }
349
350 void engine_load_dasync_internal(void)
351 {
352     ENGINE *toadd = engine_dasync();
353     if (!toadd)
354         return;
355     ENGINE_add(toadd);
356     ENGINE_free(toadd);
357     ERR_clear_error();
358 }
359
360 static int dasync_init(ENGINE *e)
361 {
362     return 1;
363 }
364
365
366 static int dasync_finish(ENGINE *e)
367 {
368     return 1;
369 }
370
371
372 static int dasync_destroy(ENGINE *e)
373 {
374     destroy_digests();
375     destroy_ciphers();
376     RSA_meth_free(dasync_rsa_method);
377     ERR_unload_DASYNC_strings();
378     return 1;
379 }
380
381 static int dasync_digests(ENGINE *e, const EVP_MD **digest,
382                           const int **nids, int nid)
383 {
384     int ok = 1;
385     if (!digest) {
386         /* We are returning a list of supported nids */
387         return dasync_digest_nids(nids);
388     }
389     /* We are being asked for a specific digest */
390     switch (nid) {
391     case NID_sha1:
392         *digest = dasync_sha1();
393         break;
394     default:
395         ok = 0;
396         *digest = NULL;
397         break;
398     }
399     return ok;
400 }
401
402 static int dasync_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
403                                    const int **nids, int nid)
404 {
405     int ok = 1;
406     if (cipher == NULL) {
407         /* We are returning a list of supported nids */
408         *nids = dasync_cipher_nids;
409         return (sizeof(dasync_cipher_nids) -
410                 1) / sizeof(dasync_cipher_nids[0]);
411     }
412     /* We are being asked for a specific cipher */
413     switch (nid) {
414     case NID_aes_128_cbc:
415         *cipher = dasync_aes_128_cbc();
416         break;
417     case NID_aes_128_cbc_hmac_sha1:
418         *cipher = dasync_aes_128_cbc_hmac_sha1();
419         break;
420     default:
421         ok = 0;
422         *cipher = NULL;
423         break;
424     }
425     return ok;
426 }
427
428 static void wait_cleanup(ASYNC_WAIT_CTX *ctx, const void *key,
429                          OSSL_ASYNC_FD readfd, void *pvwritefd)
430 {
431     OSSL_ASYNC_FD *pwritefd = (OSSL_ASYNC_FD *)pvwritefd;
432 #if defined(ASYNC_WIN)
433     CloseHandle(readfd);
434     CloseHandle(*pwritefd);
435 #elif defined(ASYNC_POSIX)
436     close(readfd);
437     close(*pwritefd);
438 #endif
439     OPENSSL_free(pwritefd);
440 }
441
442 #define DUMMY_CHAR 'X'
443
444 static void dummy_pause_job(void) {
445     ASYNC_JOB *job;
446     ASYNC_WAIT_CTX *waitctx;
447     OSSL_ASYNC_FD pipefds[2] = {0, 0};
448     OSSL_ASYNC_FD *writefd;
449 #if defined(ASYNC_WIN)
450     DWORD numwritten, numread;
451     char buf = DUMMY_CHAR;
452 #elif defined(ASYNC_POSIX)
453     char buf = DUMMY_CHAR;
454 #endif
455
456     if ((job = ASYNC_get_current_job()) == NULL)
457         return;
458
459     waitctx = ASYNC_get_wait_ctx(job);
460
461     if (ASYNC_WAIT_CTX_get_fd(waitctx, engine_dasync_id, &pipefds[0],
462                               (void **)&writefd)) {
463         pipefds[1] = *writefd;
464     } else {
465         writefd = OPENSSL_malloc(sizeof(*writefd));
466         if (writefd == NULL)
467             return;
468 #if defined(ASYNC_WIN)
469         if (CreatePipe(&pipefds[0], &pipefds[1], NULL, 256) == 0) {
470             OPENSSL_free(writefd);
471             return;
472         }
473 #elif defined(ASYNC_POSIX)
474         if (pipe(pipefds) != 0) {
475             OPENSSL_free(writefd);
476             return;
477         }
478 #endif
479         *writefd = pipefds[1];
480
481         if(!ASYNC_WAIT_CTX_set_wait_fd(waitctx, engine_dasync_id, pipefds[0],
482                                        writefd, wait_cleanup)) {
483             wait_cleanup(waitctx, engine_dasync_id, pipefds[0], writefd);
484             return;
485         }
486     }
487     /*
488      * In the Dummy async engine we are cheating. We signal that the job
489      * is complete by waking it before the call to ASYNC_pause_job(). A real
490      * async engine would only wake when the job was actually complete
491      */
492 #if defined(ASYNC_WIN)
493     WriteFile(pipefds[1], &buf, 1, &numwritten, NULL);
494 #elif defined(ASYNC_POSIX)
495     if (write(pipefds[1], &buf, 1) < 0)
496         return;
497 #endif
498
499     /* Ignore errors - we carry on anyway */
500     ASYNC_pause_job();
501
502     /* Clear the wake signal */
503 #if defined(ASYNC_WIN)
504     ReadFile(pipefds[0], &buf, 1, &numread, NULL);
505 #elif defined(ASYNC_POSIX)
506     if (read(pipefds[0], &buf, 1) < 0)
507         return;
508 #endif
509 }
510
511 /*
512  * SHA1 implementation. At the moment we just defer to the standard
513  * implementation
514  */
515 #undef data
516 #define data(ctx) ((SHA_CTX *)EVP_MD_CTX_md_data(ctx))
517 static int dasync_sha1_init(EVP_MD_CTX *ctx)
518 {
519     dummy_pause_job();
520
521     return SHA1_Init(data(ctx));
522 }
523
524 static int dasync_sha1_update(EVP_MD_CTX *ctx, const void *data,
525                              size_t count)
526 {
527     dummy_pause_job();
528
529     return SHA1_Update(data(ctx), data, (size_t)count);
530 }
531
532 static int dasync_sha1_final(EVP_MD_CTX *ctx, unsigned char *md)
533 {
534     dummy_pause_job();
535
536     return SHA1_Final(md, data(ctx));
537 }
538
539 /*
540  * RSA implementation
541  */
542
543 static int dasync_pub_enc(int flen, const unsigned char *from,
544                     unsigned char *to, RSA *rsa, int padding) {
545     /* Ignore errors - we carry on anyway */
546     dummy_pause_job();
547     return RSA_meth_get_pub_enc(RSA_PKCS1_OpenSSL())
548         (flen, from, to, rsa, padding);
549 }
550
551 static int dasync_pub_dec(int flen, const unsigned char *from,
552                     unsigned char *to, RSA *rsa, int padding) {
553     /* Ignore errors - we carry on anyway */
554     dummy_pause_job();
555     return RSA_meth_get_pub_dec(RSA_PKCS1_OpenSSL())
556         (flen, from, to, rsa, padding);
557 }
558
559 static int dasync_rsa_priv_enc(int flen, const unsigned char *from,
560                       unsigned char *to, RSA *rsa, int padding)
561 {
562     /* Ignore errors - we carry on anyway */
563     dummy_pause_job();
564     return RSA_meth_get_priv_enc(RSA_PKCS1_OpenSSL())
565         (flen, from, to, rsa, padding);
566 }
567
568 static int dasync_rsa_priv_dec(int flen, const unsigned char *from,
569                       unsigned char *to, RSA *rsa, int padding)
570 {
571     /* Ignore errors - we carry on anyway */
572     dummy_pause_job();
573     return RSA_meth_get_priv_dec(RSA_PKCS1_OpenSSL())
574         (flen, from, to, rsa, padding);
575 }
576
577 static int dasync_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx)
578 {
579     /* Ignore errors - we carry on anyway */
580     dummy_pause_job();
581     return RSA_meth_get_mod_exp(RSA_PKCS1_OpenSSL())(r0, I, rsa, ctx);
582 }
583
584 static int dasync_rsa_init(RSA *rsa)
585 {
586     return RSA_meth_get_init(RSA_PKCS1_OpenSSL())(rsa);
587 }
588 static int dasync_rsa_finish(RSA *rsa)
589 {
590     return RSA_meth_get_finish(RSA_PKCS1_OpenSSL())(rsa);
591 }
592
593 /* Cipher helper functions */
594
595 static int dasync_cipher_ctrl_helper(EVP_CIPHER_CTX *ctx, int type, int arg,
596                                      void *ptr, int aeadcapable)
597 {
598     int ret;
599     struct dasync_pipeline_ctx *pipe_ctx =
600         (struct dasync_pipeline_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx);
601
602     if (pipe_ctx == NULL)
603         return 0;
604
605     switch (type) {
606         case EVP_CTRL_SET_PIPELINE_OUTPUT_BUFS:
607             pipe_ctx->numpipes = arg;
608             pipe_ctx->outbufs = (unsigned char **)ptr;
609             break;
610
611         case EVP_CTRL_SET_PIPELINE_INPUT_BUFS:
612             pipe_ctx->numpipes = arg;
613             pipe_ctx->inbufs = (unsigned char **)ptr;
614             break;
615
616         case EVP_CTRL_SET_PIPELINE_INPUT_LENS:
617             pipe_ctx->numpipes = arg;
618             pipe_ctx->lens = (size_t *)ptr;
619             break;
620
621         case EVP_CTRL_AEAD_SET_MAC_KEY:
622             if (!aeadcapable)
623                 return -1;
624             EVP_CIPHER_CTX_set_cipher_data(ctx, pipe_ctx->inner_cipher_data);
625             ret = EVP_CIPHER_meth_get_ctrl(EVP_aes_128_cbc_hmac_sha1())
626                                           (ctx, type, arg, ptr);
627             EVP_CIPHER_CTX_set_cipher_data(ctx, pipe_ctx);
628             return ret;
629
630         case EVP_CTRL_AEAD_TLS1_AAD:
631         {
632             unsigned char *p = ptr;
633             unsigned int len;
634
635             if (!aeadcapable || arg != EVP_AEAD_TLS1_AAD_LEN)
636                 return -1;
637
638             if (pipe_ctx->aadctr >= SSL_MAX_PIPELINES)
639                 return -1;
640
641             memcpy(pipe_ctx->tlsaad[pipe_ctx->aadctr], ptr,
642                    EVP_AEAD_TLS1_AAD_LEN);
643             pipe_ctx->aadctr++;
644
645             len = p[arg - 2] << 8 | p[arg - 1];
646
647             if (pipe_ctx->enc) {
648                 if ((p[arg - 4] << 8 | p[arg - 3]) >= TLS1_1_VERSION) {
649                     len -= AES_BLOCK_SIZE;
650                 }
651
652                 return ((len + SHA_DIGEST_LENGTH + AES_BLOCK_SIZE)
653                         & -AES_BLOCK_SIZE) - len;
654             } else {
655                 return SHA_DIGEST_LENGTH;
656             }
657         }
658
659         default:
660             return 0;
661     }
662
663     return 1;
664 }
665
666 static int dasync_cipher_init_key_helper(EVP_CIPHER_CTX *ctx,
667                                          const unsigned char *key,
668                                          const unsigned char *iv, int enc,
669                                          const EVP_CIPHER *cipher)
670 {
671     int ret;
672     struct dasync_pipeline_ctx *pipe_ctx =
673         (struct dasync_pipeline_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx);
674
675     if (pipe_ctx->inner_cipher_data == NULL
676             && EVP_CIPHER_impl_ctx_size(cipher) != 0) {
677         pipe_ctx->inner_cipher_data = OPENSSL_zalloc(
678             EVP_CIPHER_impl_ctx_size(cipher));
679         if (pipe_ctx->inner_cipher_data == NULL) {
680             DASYNCerr(DASYNC_F_DASYNC_CIPHER_INIT_KEY_HELPER,
681                         ERR_R_MALLOC_FAILURE);
682             return 0;
683         }
684     }
685
686     pipe_ctx->numpipes = 0;
687     pipe_ctx->aadctr = 0;
688
689     EVP_CIPHER_CTX_set_cipher_data(ctx, pipe_ctx->inner_cipher_data);
690     ret = EVP_CIPHER_meth_get_init(cipher)(ctx, key, iv, enc);
691     EVP_CIPHER_CTX_set_cipher_data(ctx, pipe_ctx);
692
693     return ret;
694 }
695
696 static int dasync_cipher_helper(EVP_CIPHER_CTX *ctx, unsigned char *out,
697                                 const unsigned char *in, size_t inl,
698                                 const EVP_CIPHER *cipher)
699 {
700     int ret = 1;
701     unsigned int i, pipes;
702     struct dasync_pipeline_ctx *pipe_ctx =
703         (struct dasync_pipeline_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx);
704
705     pipes = pipe_ctx->numpipes;
706     EVP_CIPHER_CTX_set_cipher_data(ctx, pipe_ctx->inner_cipher_data);
707     if (pipes == 0) {
708         if (pipe_ctx->aadctr != 0) {
709             if (pipe_ctx->aadctr != 1)
710                 return -1;
711             EVP_CIPHER_meth_get_ctrl(cipher)
712                                     (ctx, EVP_CTRL_AEAD_TLS1_AAD,
713                                      EVP_AEAD_TLS1_AAD_LEN,
714                                      pipe_ctx->tlsaad[0]);
715         }
716         ret = EVP_CIPHER_meth_get_do_cipher(cipher)
717                                            (ctx, out, in, inl);
718     } else {
719         if (pipe_ctx->aadctr > 0 && pipe_ctx->aadctr != pipes)
720             return -1;
721         for (i = 0; i < pipes; i++) {
722             if (pipe_ctx->aadctr > 0) {
723                 EVP_CIPHER_meth_get_ctrl(cipher)
724                                         (ctx, EVP_CTRL_AEAD_TLS1_AAD,
725                                          EVP_AEAD_TLS1_AAD_LEN,
726                                          pipe_ctx->tlsaad[i]);
727             }
728             ret = ret && EVP_CIPHER_meth_get_do_cipher(cipher)
729                                 (ctx, pipe_ctx->outbufs[i], pipe_ctx->inbufs[i],
730                                  pipe_ctx->lens[i]);
731         }
732         pipe_ctx->numpipes = 0;
733     }
734     pipe_ctx->aadctr = 0;
735     EVP_CIPHER_CTX_set_cipher_data(ctx, pipe_ctx);
736     return ret;
737 }
738
739 static int dasync_cipher_cleanup_helper(EVP_CIPHER_CTX *ctx,
740                                         const EVP_CIPHER *cipher)
741 {
742     struct dasync_pipeline_ctx *pipe_ctx =
743         (struct dasync_pipeline_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx);
744
745     OPENSSL_clear_free(pipe_ctx->inner_cipher_data,
746                        EVP_CIPHER_impl_ctx_size(cipher));
747
748     return 1;
749 }
750
751 /*
752  * AES128 CBC Implementation
753  */
754
755 static int dasync_aes128_cbc_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg,
756                                   void *ptr)
757 {
758     return dasync_cipher_ctrl_helper(ctx, type, arg, ptr, 0);
759 }
760
761 static int dasync_aes128_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
762                              const unsigned char *iv, int enc)
763 {
764     return dasync_cipher_init_key_helper(ctx, key, iv, enc, EVP_aes_128_cbc());
765 }
766
767 static int dasync_aes128_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
768                                const unsigned char *in, size_t inl)
769 {
770     return dasync_cipher_helper(ctx, out, in, inl, EVP_aes_128_cbc());
771 }
772
773 static int dasync_aes128_cbc_cleanup(EVP_CIPHER_CTX *ctx)
774 {
775     return dasync_cipher_cleanup_helper(ctx, EVP_aes_128_cbc());
776 }
777
778
779 /*
780  * AES128 CBC HMAC SHA1 Implementation
781  */
782
783 static int dasync_aes128_cbc_hmac_sha1_ctrl(EVP_CIPHER_CTX *ctx, int type,
784                                              int arg, void *ptr)
785 {
786     return dasync_cipher_ctrl_helper(ctx, type, arg, ptr, 1);
787 }
788
789 static int dasync_aes128_cbc_hmac_sha1_init_key(EVP_CIPHER_CTX *ctx,
790                                                 const unsigned char *key,
791                                                 const unsigned char *iv,
792                                                 int enc)
793 {
794     return dasync_cipher_init_key_helper(ctx, key, iv, enc,
795                                          EVP_aes_128_cbc_hmac_sha1());
796 }
797
798 static int dasync_aes128_cbc_hmac_sha1_cipher(EVP_CIPHER_CTX *ctx,
799                                                unsigned char *out,
800                                                const unsigned char *in,
801                                                size_t inl)
802 {
803     return dasync_cipher_helper(ctx, out, in, inl, EVP_aes_128_cbc_hmac_sha1());
804 }
805
806 static int dasync_aes128_cbc_hmac_sha1_cleanup(EVP_CIPHER_CTX *ctx)
807 {
808     return dasync_cipher_cleanup_helper(ctx, EVP_aes_128_cbc_hmac_sha1());
809 }