Update dasync to use size_t for the sha1 update
[openssl.git] / engines / e_dasync.c
1 /* engines/e_dasync.c */
2 /*
3  * Written by Matt Caswell (matt@openssl.org) for the OpenSSL project.
4  */
5 /* ====================================================================
6  * Copyright (c) 2015 The OpenSSL Project.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in
17  *    the documentation and/or other materials provided with the
18  *    distribution.
19  *
20  * 3. All advertising materials mentioning features or use of this
21  *    software must display the following acknowledgment:
22  *    "This product includes software developed by the OpenSSL Project
23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24  *
25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26  *    endorse or promote products derived from this software without
27  *    prior written permission. For written permission, please contact
28  *    licensing@OpenSSL.org.
29  *
30  * 5. Products derived from this software may not be called "OpenSSL"
31  *    nor may "OpenSSL" appear in their names without prior written
32  *    permission of the OpenSSL Project.
33  *
34  * 6. Redistributions of any form whatsoever must retain the following
35  *    acknowledgment:
36  *    "This product includes software developed by the OpenSSL Project
37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38  *
39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50  * OF THE POSSIBILITY OF SUCH DAMAGE.
51  * ====================================================================
52  */
53
54 #include <stdio.h>
55 #include <string.h>
56
57 #include <openssl/engine.h>
58 #include <openssl/sha.h>
59 #include <openssl/rsa.h>
60 #include <openssl/evp.h>
61 #include <openssl/async.h>
62 #include <openssl/bn.h>
63
64 #define DASYNC_LIB_NAME "DASYNC"
65 #include "e_dasync_err.c"
66
67 /* Engine Id and Name */
68 static const char *engine_dasync_id = "dasync";
69 static const char *engine_dasync_name = "Dummy Async engine support";
70
71
72 /* Engine Lifetime functions */
73 static int dasync_destroy(ENGINE *e);
74 static int dasync_init(ENGINE *e);
75 static int dasync_finish(ENGINE *e);
76 void ENGINE_load_dasync(void);
77
78
79 /* Set up digests. Just SHA1 for now */
80 static int dasync_digests(ENGINE *e, const EVP_MD **digest,
81                           const int **nids, int nid);
82
83 static int dasync_digest_nids[] = { NID_sha1, 0 };
84
85 static void dummy_pause_job(void);
86
87 /* SHA1 */
88 static int dasync_sha1_init(EVP_MD_CTX *ctx);
89 static int dasync_sha1_update(EVP_MD_CTX *ctx, const void *data,
90                              size_t count);
91 static int dasync_sha1_final(EVP_MD_CTX *ctx, unsigned char *md);
92
93 static const EVP_MD dasync_sha1 = {
94     NID_sha1,
95     NID_sha1WithRSAEncryption,
96     SHA_DIGEST_LENGTH,
97     EVP_MD_FLAG_PKEY_METHOD_SIGNATURE | EVP_MD_FLAG_DIGALGID_ABSENT,
98     dasync_sha1_init,
99     dasync_sha1_update,
100     dasync_sha1_final,
101     NULL,
102     NULL,
103     EVP_PKEY_NULL_method,
104     SHA_CBLOCK,
105     sizeof(EVP_MD *) + sizeof(SHA_CTX),
106 };
107
108 /* RSA */
109
110 static int dasync_pub_enc(int flen, const unsigned char *from,
111                     unsigned char *to, RSA *rsa, int padding);
112 static int dasync_pub_dec(int flen, const unsigned char *from,
113                     unsigned char *to, RSA *rsa, int padding);
114 static int dasync_rsa_priv_enc(int flen, const unsigned char *from,
115                       unsigned char *to, RSA *rsa, int padding);
116 static int dasync_rsa_priv_dec(int flen, const unsigned char *from,
117                       unsigned char *to, RSA *rsa, int padding);
118 static int dasync_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa,
119                               BN_CTX *ctx);
120
121 static int dasync_rsa_init(RSA *rsa);
122 static int dasync_rsa_finish(RSA *rsa);
123
124 static RSA_METHOD dasync_rsa_method = {
125     "Dummy Async RSA method",
126     dasync_pub_enc,             /* pub_enc */
127     dasync_pub_dec,             /* pub_dec */
128     dasync_rsa_priv_enc,        /* priv_enc */
129     dasync_rsa_priv_dec,        /* priv_dec */
130     dasync_rsa_mod_exp,         /* rsa_mod_exp */
131     BN_mod_exp_mont,            /* bn_mod_exp */
132     dasync_rsa_init,            /* init */
133     dasync_rsa_finish,          /* finish */
134     0,                          /* flags */
135     NULL,                       /* app_data */
136     0,                          /* rsa_sign */
137     0,                          /* rsa_verify */
138     NULL                        /* rsa_keygen */
139 };
140
141
142 static int bind_dasync(ENGINE *e)
143 {
144     /* Ensure the dasync error handling is set up */
145     ERR_load_DASYNC_strings();
146
147     if (!ENGINE_set_id(e, engine_dasync_id)
148         || !ENGINE_set_name(e, engine_dasync_name)
149         || !ENGINE_set_RSA(e, &dasync_rsa_method)
150         || !ENGINE_set_digests(e, dasync_digests)
151         || !ENGINE_set_destroy_function(e, dasync_destroy)
152         || !ENGINE_set_init_function(e, dasync_init)
153         || !ENGINE_set_finish_function(e, dasync_finish)) {
154         DASYNCerr(DASYNC_F_BIND_DASYNC, DASYNC_R_INIT_FAILED);
155         return 0;
156     }
157
158     return 1;
159 }
160
161 # ifndef OPENSSL_NO_DYNAMIC_ENGINE
162 static int bind_helper(ENGINE *e, const char *id)
163 {
164     if (id && (strcmp(id, engine_dasync_id) != 0))
165         return 0;
166     if (!bind_dasync(e))
167         return 0;
168     return 1;
169 }
170
171 IMPLEMENT_DYNAMIC_CHECK_FN()
172     IMPLEMENT_DYNAMIC_BIND_FN(bind_helper)
173 # endif
174
175 static ENGINE *engine_dasync(void)
176 {
177     ENGINE *ret = ENGINE_new();
178     if (!ret)
179         return NULL;
180     if (!bind_dasync(ret)) {
181         ENGINE_free(ret);
182         return NULL;
183     }
184     return ret;
185 }
186
187 void ENGINE_load_dasync(void)
188 {
189     ENGINE *toadd = engine_dasync();
190     if (!toadd)
191         return;
192     ENGINE_add(toadd);
193     ENGINE_free(toadd);
194     ERR_clear_error();
195 }
196
197 static int dasync_init(ENGINE *e)
198 {
199     return 1;
200 }
201
202
203 static int dasync_finish(ENGINE *e)
204 {
205     return 1;
206 }
207
208
209 static int dasync_destroy(ENGINE *e)
210 {
211     ERR_unload_DASYNC_strings();
212     return 1;
213 }
214
215 static int dasync_digests(ENGINE *e, const EVP_MD **digest,
216                           const int **nids, int nid)
217 {
218     int ok = 1;
219     if (!digest) {
220         /* We are returning a list of supported nids */
221         *nids = dasync_digest_nids;
222         return (sizeof(dasync_digest_nids) -
223                 1) / sizeof(dasync_digest_nids[0]);
224     }
225     /* We are being asked for a specific digest */
226     switch (nid) {
227     case NID_sha1:
228         *digest = &dasync_sha1;
229         break;
230     default:
231         ok = 0;
232         *digest = NULL;
233         break;
234     }
235     return ok;
236 }
237
238 static void dummy_pause_job(void) {
239     ASYNC_JOB *job;
240
241     if ((job = ASYNC_get_current_job()) == NULL)
242         return;
243
244     /*
245      * In the Dummy async engine we are cheating. We signal that the job
246      * is complete by waking it before the call to ASYNC_pause_job(). A real
247      * async engine would only wake when the job was actually complete
248      */
249     ASYNC_wake(job);
250
251     /* Ignore errors - we carry on anyway */
252     ASYNC_pause_job();
253
254     ASYNC_clear_wake(job);
255 }
256
257
258 /*
259  * SHA1 implementation. At the moment we just defer to the standard
260  * implementation
261  */
262 #undef data
263 #define data(ctx) ((SHA_CTX *)(ctx)->md_data)
264 static int dasync_sha1_init(EVP_MD_CTX *ctx)
265 {
266     dummy_pause_job();
267
268     return SHA1_Init(data(ctx));
269 }
270
271 static int dasync_sha1_update(EVP_MD_CTX *ctx, const void *data,
272                              size_t count)
273 {
274     dummy_pause_job();
275
276     return SHA1_Update(data(ctx), data, (size_t)count);
277 }
278
279 static int dasync_sha1_final(EVP_MD_CTX *ctx, unsigned char *md)
280 {
281     dummy_pause_job();
282
283     return SHA1_Final(md, data(ctx));
284 }
285
286 /*
287  * RSA implementation
288  */
289
290 static int dasync_pub_enc(int flen, const unsigned char *from,
291                     unsigned char *to, RSA *rsa, int padding) {
292     /* Ignore errors - we carry on anyway */
293     dummy_pause_job();
294     return RSA_PKCS1_OpenSSL()->rsa_pub_enc(flen, from, to, rsa, padding);
295 }
296
297 static int dasync_pub_dec(int flen, const unsigned char *from,
298                     unsigned char *to, RSA *rsa, int padding) {
299     /* Ignore errors - we carry on anyway */
300     dummy_pause_job();
301     return RSA_PKCS1_OpenSSL()->rsa_pub_dec(flen, from, to, rsa, padding);
302 }
303
304 static int dasync_rsa_priv_enc(int flen, const unsigned char *from,
305                       unsigned char *to, RSA *rsa, int padding)
306 {
307     /* Ignore errors - we carry on anyway */
308     dummy_pause_job();
309     return RSA_PKCS1_OpenSSL()->rsa_priv_enc(flen, from, to, rsa, padding);
310 }
311
312 static int dasync_rsa_priv_dec(int flen, const unsigned char *from,
313                       unsigned char *to, RSA *rsa, int padding)
314 {
315     /* Ignore errors - we carry on anyway */
316     dummy_pause_job();
317     return RSA_PKCS1_OpenSSL()->rsa_priv_dec(flen, from, to, rsa, padding);
318 }
319
320 static int dasync_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx)
321 {
322     /* Ignore errors - we carry on anyway */
323     dummy_pause_job();
324     return RSA_PKCS1_OpenSSL()->rsa_mod_exp(r0, I, rsa, ctx);
325 }
326
327 static int dasync_rsa_init(RSA *rsa)
328 {
329     return RSA_PKCS1_OpenSSL()->init(rsa);
330 }
331 static int dasync_rsa_finish(RSA *rsa)
332 {
333     return RSA_PKCS1_OpenSSL()->finish(rsa);
334 }