Remove legacy sign/verify from EVP_MD.
[openssl.git] / engines / e_ossltest.c
1 /* engines/e_ossltest.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 /*
55  * This is the OSSLTEST engine. It provides deliberately crippled digest
56  * implementations for test purposes. It is highly insecure and must NOT be
57  * used for any purpose except testing
58  */
59
60 #include <stdio.h>
61 #include <string.h>
62
63 #include <openssl/engine.h>
64 #include <openssl/sha.h>
65 #include <openssl/md5.h>
66 #include <openssl/rsa.h>
67 #include <openssl/evp.h>
68 #include <openssl/modes.h>
69 #include <openssl/aes.h>
70
71 #define OSSLTEST_LIB_NAME "OSSLTEST"
72 #include "e_ossltest_err.c"
73
74 /* Engine Id and Name */
75 static const char *engine_ossltest_id = "ossltest";
76 static const char *engine_ossltest_name = "OpenSSL Test engine support";
77
78
79 /* Engine Lifetime functions */
80 static int ossltest_destroy(ENGINE *e);
81 static int ossltest_init(ENGINE *e);
82 static int ossltest_finish(ENGINE *e);
83 void ENGINE_load_ossltest(void);
84
85
86 /* Set up digests */
87 static int ossltest_digests(ENGINE *e, const EVP_MD **digest,
88                           const int **nids, int nid);
89
90 static int ossltest_digest_nids[] = {
91     NID_md5, NID_sha1, NID_sha256, NID_sha384, NID_sha512, 0
92 };
93
94 /* MD5 */
95 static int digest_md5_init(EVP_MD_CTX *ctx);
96 static int digest_md5_update(EVP_MD_CTX *ctx, const void *data,
97                              size_t count);
98 static int digest_md5_final(EVP_MD_CTX *ctx, unsigned char *md);
99
100 static const EVP_MD digest_md5 = {
101     NID_md5,
102     NID_md5WithRSAEncryption,
103     MD5_DIGEST_LENGTH,
104     0,
105     digest_md5_init,
106     digest_md5_update,
107     digest_md5_final,
108     NULL,
109     NULL,
110     MD5_CBLOCK,
111     sizeof(EVP_MD *) + sizeof(MD5_CTX),
112 };
113
114 /* SHA1 */
115 static int digest_sha1_init(EVP_MD_CTX *ctx);
116 static int digest_sha1_update(EVP_MD_CTX *ctx, const void *data,
117                               size_t count);
118 static int digest_sha1_final(EVP_MD_CTX *ctx, unsigned char *md);
119
120 static const EVP_MD digest_sha1 = {
121     NID_sha1,
122     NID_sha1WithRSAEncryption,
123     SHA_DIGEST_LENGTH,
124     EVP_MD_FLAG_DIGALGID_ABSENT,
125     digest_sha1_init,
126     digest_sha1_update,
127     digest_sha1_final,
128     NULL,
129     NULL,
130     SHA_CBLOCK,
131     sizeof(EVP_MD *) + sizeof(SHA_CTX),
132 };
133
134 /* SHA256 */
135 static int digest_sha256_init(EVP_MD_CTX *ctx);
136 static int digest_sha256_update(EVP_MD_CTX *ctx, const void *data,
137                                 size_t count);
138 static int digest_sha256_final(EVP_MD_CTX *ctx, unsigned char *md);
139
140 static const EVP_MD digest_sha256 = {
141     NID_sha256,
142     NID_sha256WithRSAEncryption,
143     SHA256_DIGEST_LENGTH,
144     EVP_MD_FLAG_DIGALGID_ABSENT,
145     digest_sha256_init,
146     digest_sha256_update,
147     digest_sha256_final,
148     NULL,
149     NULL,
150     SHA256_CBLOCK,
151     sizeof(EVP_MD *) + sizeof(SHA256_CTX),
152 };
153
154 /* SHA384/SHA512 */
155 static int digest_sha384_init(EVP_MD_CTX *ctx);
156 static int digest_sha512_init(EVP_MD_CTX *ctx);
157 static int digest_sha512_update(EVP_MD_CTX *ctx, const void *data,
158                                 size_t count);
159 static int digest_sha384_final(EVP_MD_CTX *ctx, unsigned char *md);
160 static int digest_sha512_final(EVP_MD_CTX *ctx, unsigned char *md);
161
162 static const EVP_MD digest_sha384 = {
163     NID_sha384,
164     NID_sha384WithRSAEncryption,
165     SHA384_DIGEST_LENGTH,
166     EVP_MD_FLAG_DIGALGID_ABSENT,
167     digest_sha384_init,
168     digest_sha512_update,
169     digest_sha384_final,
170     NULL,
171     NULL,
172     SHA512_CBLOCK,
173     sizeof(EVP_MD *) + sizeof(SHA512_CTX),
174 };
175
176 static const EVP_MD digest_sha512 = {
177     NID_sha512,
178     NID_sha512WithRSAEncryption,
179     SHA512_DIGEST_LENGTH,
180     EVP_MD_FLAG_DIGALGID_ABSENT,
181     digest_sha512_init,
182     digest_sha512_update,
183     digest_sha512_final,
184     NULL,
185     NULL,
186     SHA512_CBLOCK,
187     sizeof(EVP_MD *) + sizeof(SHA512_CTX),
188 };
189
190 /* Setup ciphers */
191 static int ossltest_ciphers(ENGINE *, const EVP_CIPHER **,
192                             const int **, int);
193
194 static int ossltest_cipher_nids[] = {
195     NID_aes_128_cbc, 0
196 };
197
198 /* AES128 */
199
200 int ossltest_aes128_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
201                              const unsigned char *iv, int enc);
202 int ossltest_aes128_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
203                                const unsigned char *in, size_t inl);
204
205 static const EVP_CIPHER ossltest_aes_128_cbc = { \
206     NID_aes_128_cbc,
207     16, /* block size */
208     16, /* key len */
209     16, /* iv len */
210     EVP_CIPH_FLAG_DEFAULT_ASN1 | EVP_CIPH_CBC_MODE,
211     ossltest_aes128_init_key,
212     ossltest_aes128_cbc_cipher,
213     NULL,
214     0, /* We don't know the size of cipher_data at compile time */
215     NULL,NULL,NULL,NULL
216 };
217
218
219 static int bind_ossltest(ENGINE *e)
220 {
221     /* Ensure the ossltest error handling is set up */
222     ERR_load_OSSLTEST_strings();
223
224     if (!ENGINE_set_id(e, engine_ossltest_id)
225         || !ENGINE_set_name(e, engine_ossltest_name)
226         || !ENGINE_set_digests(e, ossltest_digests)
227         || !ENGINE_set_ciphers(e, ossltest_ciphers)
228         || !ENGINE_set_destroy_function(e, ossltest_destroy)
229         || !ENGINE_set_init_function(e, ossltest_init)
230         || !ENGINE_set_finish_function(e, ossltest_finish)) {
231         OSSLTESTerr(OSSLTEST_F_BIND_OSSLTEST, OSSLTEST_R_INIT_FAILED);
232         return 0;
233     }
234
235     return 1;
236 }
237
238 #ifndef OPENSSL_NO_DYNAMIC_ENGINE
239 static int bind_helper(ENGINE *e, const char *id)
240 {
241     if (id && (strcmp(id, engine_ossltest_id) != 0))
242         return 0;
243     if (!bind_ossltest(e))
244         return 0;
245     return 1;
246 }
247
248 IMPLEMENT_DYNAMIC_CHECK_FN()
249     IMPLEMENT_DYNAMIC_BIND_FN(bind_helper)
250 #endif
251
252 static ENGINE *engine_ossltest(void)
253 {
254     ENGINE *ret = ENGINE_new();
255     if (ret == NULL)
256         return NULL;
257     if (!bind_ossltest(ret)) {
258         ENGINE_free(ret);
259         return NULL;
260     }
261     return ret;
262 }
263
264 void ENGINE_load_ossltest(void)
265 {
266     /* Copied from eng_[openssl|dyn].c */
267     ENGINE *toadd = engine_ossltest();
268     if (!toadd)
269         return;
270     ENGINE_add(toadd);
271     ENGINE_free(toadd);
272     ERR_clear_error();
273 }
274
275
276 static int ossltest_init(ENGINE *e)
277 {
278     return 1;
279 }
280
281
282 static int ossltest_finish(ENGINE *e)
283 {
284     return 1;
285 }
286
287
288 static int ossltest_destroy(ENGINE *e)
289 {
290     ERR_unload_OSSLTEST_strings();
291     return 1;
292 }
293
294 static int ossltest_digests(ENGINE *e, const EVP_MD **digest,
295                           const int **nids, int nid)
296 {
297     int ok = 1;
298     if (!digest) {
299         /* We are returning a list of supported nids */
300         *nids = ossltest_digest_nids;
301         return (sizeof(ossltest_digest_nids) -
302                 1) / sizeof(ossltest_digest_nids[0]);
303     }
304     /* We are being asked for a specific digest */
305     switch (nid) {
306     case NID_md5:
307         *digest = &digest_md5;
308         break;
309     case NID_sha1:
310         *digest = &digest_sha1;
311         break;
312     case NID_sha256:
313         *digest = &digest_sha256;
314         break;
315     case NID_sha384:
316         *digest = &digest_sha384;
317         break;
318     case NID_sha512:
319         *digest = &digest_sha512;
320         break;
321     default:
322         ok = 0;
323         *digest = NULL;
324         break;
325     }
326     return ok;
327 }
328
329 static int ossltest_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
330                           const int **nids, int nid)
331 {
332     int ok = 1;
333     if (!cipher) {
334         /* We are returning a list of supported nids */
335         *nids = ossltest_cipher_nids;
336         return (sizeof(ossltest_cipher_nids) - 1)
337                / sizeof(ossltest_cipher_nids[0]);
338     }
339     /* We are being asked for a specific cipher */
340     switch (nid) {
341     case NID_aes_128_cbc:
342         *cipher = &ossltest_aes_128_cbc;
343         break;
344     default:
345         ok = 0;
346         *cipher = NULL;
347         break;
348     }
349     return ok;
350 }
351
352 static void fill_known_data(unsigned char *md, unsigned int len)
353 {
354     unsigned int i;
355
356     for (i=0; i<len; i++) {
357         md[i] = (unsigned char)(i & 0xff);
358     }
359 }
360
361 /*
362  * MD5 implementation. We go through the motions of doing MD5 by deferring to
363  * the standard implementation. Then we overwrite the result with a will defined
364  * value, so that all "MD5" digests using the test engine always end up with
365  * the same value.
366  */
367 #undef data
368 #define data(ctx) ((MD5_CTX *)(ctx)->md_data)
369 static int digest_md5_init(EVP_MD_CTX *ctx)
370 {
371     return MD5_Init(data(ctx));
372 }
373
374 static int digest_md5_update(EVP_MD_CTX *ctx, const void *data,
375                              size_t count)
376 {
377     return MD5_Update(data(ctx), data, (size_t)count);
378 }
379
380 static int digest_md5_final(EVP_MD_CTX *ctx, unsigned char *md)
381 {
382     int ret;
383     ret = MD5_Final(md, data(ctx));
384
385     if (ret > 0) {
386         fill_known_data(md, MD5_DIGEST_LENGTH);
387     }
388     return ret;
389 }
390
391 /*
392  * SHA1 implementation.
393  */
394 #undef data
395 #define data(ctx) ((SHA_CTX *)(ctx)->md_data)
396 static int digest_sha1_init(EVP_MD_CTX *ctx)
397 {
398     return SHA1_Init(data(ctx));
399 }
400
401 static int digest_sha1_update(EVP_MD_CTX *ctx, const void *data,
402                               size_t count)
403 {
404     return SHA1_Update(data(ctx), data, (size_t)count);
405 }
406
407 static int digest_sha1_final(EVP_MD_CTX *ctx, unsigned char *md)
408 {
409     int ret;
410     ret = SHA1_Final(md, data(ctx));
411
412     if (ret > 0) {
413         fill_known_data(md, SHA_DIGEST_LENGTH);
414     }
415     return ret;
416 }
417
418 /*
419  * SHA256 implementation.
420  */
421 #undef data
422 #define data(ctx) ((SHA256_CTX *)(ctx)->md_data)
423 static int digest_sha256_init(EVP_MD_CTX *ctx)
424 {
425     return SHA256_Init(data(ctx));
426 }
427
428 static int digest_sha256_update(EVP_MD_CTX *ctx, const void *data,
429                                 size_t count)
430 {
431     return SHA256_Update(data(ctx), data, (size_t)count);
432 }
433
434 static int digest_sha256_final(EVP_MD_CTX *ctx, unsigned char *md)
435 {
436     int ret;
437     ret = SHA256_Final(md, data(ctx));
438
439     if (ret > 0) {
440         fill_known_data(md, SHA256_DIGEST_LENGTH);
441     }
442     return ret;
443 }
444
445 /*
446  * SHA384/512 implementation.
447  */
448 #undef data
449 #define data(ctx) ((SHA512_CTX *)(ctx)->md_data)
450 static int digest_sha384_init(EVP_MD_CTX *ctx)
451 {
452     return SHA384_Init(data(ctx));
453 }
454
455 static int digest_sha512_init(EVP_MD_CTX *ctx)
456 {
457     return SHA512_Init(data(ctx));
458 }
459
460 static int digest_sha512_update(EVP_MD_CTX *ctx, const void *data,
461                                 size_t count)
462 {
463     return SHA512_Update(data(ctx), data, (size_t)count);
464 }
465
466 static int digest_sha384_final(EVP_MD_CTX *ctx, unsigned char *md)
467 {
468     int ret;
469     /* Actually uses SHA512_Final! */
470     ret = SHA512_Final(md, data(ctx));
471
472     if (ret > 0) {
473         fill_known_data(md, SHA384_DIGEST_LENGTH);
474     }
475     return ret;
476 }
477
478 static int digest_sha512_final(EVP_MD_CTX *ctx, unsigned char *md)
479 {
480     int ret;
481     ret = SHA512_Final(md, data(ctx));
482
483     if (ret > 0) {
484         fill_known_data(md, SHA512_DIGEST_LENGTH);
485     }
486     return ret;
487 }
488
489 /*
490  * AES128 Implementation
491  */
492
493 int ossltest_aes128_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
494                              const unsigned char *iv, int enc)
495 {
496     if (ctx->cipher_data == NULL) {
497         /*
498          * Normally cipher_data is allocated automatically for an engine but
499          * we don't know the ctx_size as compile time so we have to do it at
500          * run time
501          */
502         ctx->cipher_data = OPENSSL_zalloc(EVP_aes_128_cbc()->ctx_size);
503         if (ctx->cipher_data == NULL) {
504             OSSLTESTerr(OSSLTEST_F_OSSLTEST_AES128_INIT_KEY,
505                         ERR_R_MALLOC_FAILURE);
506             return 0;
507         }
508     }
509     return EVP_aes_128_cbc()->init(ctx, key, iv, enc);
510 }
511
512 int ossltest_aes128_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
513                                const unsigned char *in, size_t inl)
514 {
515     unsigned char *tmpbuf;
516     int ret;
517
518     tmpbuf = OPENSSL_malloc(inl);
519     if (tmpbuf == NULL)
520         return -1;
521
522     /* Remember what we were asked to encrypt */
523     memcpy(tmpbuf, in, inl);
524
525     /* Go through the motions of encrypting it */
526     ret = EVP_aes_128_cbc()->do_cipher(ctx, out, in, inl);
527
528     /* Throw it all away and just use the plaintext as the output */
529     memcpy(out, tmpbuf, inl);
530     OPENSSL_free(tmpbuf);
531
532     return ret;
533 }