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