2 * Copyright 2001-2020 The OpenSSL Project Authors. All Rights Reserved.
3 * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
5 * Licensed under the Apache License 2.0 (the "License"). You may not use
6 * this file except in compliance with the License. You can obtain a copy
7 * in the file LICENSE in the source distribution or at
8 * https://www.openssl.org/source/license.html
11 /* We need to use some engine deprecated APIs */
12 #define OPENSSL_SUPPRESS_DEPRECATED
15 * RC4 and SHA-1 low level APIs and EVP _meth_ APISs are deprecated for public
16 * use, but still ok for internal use.
18 #include "internal/deprecated.h"
21 #include <openssl/crypto.h>
22 #include "internal/cryptlib.h"
23 #include "crypto/engine.h"
24 #include <openssl/pem.h>
25 #include <openssl/evp.h>
26 #include <openssl/rand.h>
27 #include <openssl/rsa.h>
28 #include <openssl/dsa.h>
29 #include <openssl/dh.h>
31 #include <openssl/hmac.h>
32 #include <openssl/x509v3.h>
35 * This testing gunk is implemented (and explained) lower down. It also
36 * assumes the application explicitly calls "ENGINE_load_openssl()" because
37 * this is no longer automatic in ENGINE_load_builtin_engines().
39 #define TEST_ENG_OPENSSL_RC4
40 #ifndef OPENSSL_NO_STDIO
41 # define TEST_ENG_OPENSSL_PKEY
43 /* #define TEST_ENG_OPENSSL_HMAC */
44 /* #define TEST_ENG_OPENSSL_HMAC_INIT */
45 /* #define TEST_ENG_OPENSSL_RC4_OTHERS */
46 #ifndef OPENSSL_NO_STDIO
47 # define TEST_ENG_OPENSSL_RC4_P_INIT
49 /* #define TEST_ENG_OPENSSL_RC4_P_CIPHER */
50 #define TEST_ENG_OPENSSL_SHA
51 /* #define TEST_ENG_OPENSSL_SHA_OTHERS */
52 /* #define TEST_ENG_OPENSSL_SHA_P_INIT */
53 /* #define TEST_ENG_OPENSSL_SHA_P_UPDATE */
54 /* #define TEST_ENG_OPENSSL_SHA_P_FINAL */
56 /* Now check what of those algorithms are actually enabled */
58 # undef TEST_ENG_OPENSSL_RC4
59 # undef TEST_ENG_OPENSSL_RC4_OTHERS
60 # undef TEST_ENG_OPENSSL_RC4_P_INIT
61 # undef TEST_ENG_OPENSSL_RC4_P_CIPHER
64 static int openssl_destroy(ENGINE
*e
);
66 #ifdef TEST_ENG_OPENSSL_RC4
67 static int openssl_ciphers(ENGINE
*e
, const EVP_CIPHER
**cipher
,
68 const int **nids
, int nid
);
70 #ifdef TEST_ENG_OPENSSL_SHA
71 static int openssl_digests(ENGINE
*e
, const EVP_MD
**digest
,
72 const int **nids
, int nid
);
75 #ifdef TEST_ENG_OPENSSL_PKEY
76 static EVP_PKEY
*openssl_load_privkey(ENGINE
*eng
, const char *key_id
,
81 #ifdef TEST_ENG_OPENSSL_HMAC
82 static int ossl_register_hmac_meth(void);
83 static int ossl_pkey_meths(ENGINE
*e
, EVP_PKEY_METHOD
**pmeth
,
84 const int **nids
, int nid
);
87 /* The constants used when creating the ENGINE */
88 static const char *engine_openssl_id
= "openssl";
89 static const char *engine_openssl_name
= "Software engine support";
92 * This internal function is used by ENGINE_openssl() and possibly by the
93 * "dynamic" ENGINE support too
95 static int bind_helper(ENGINE
*e
)
97 if (!ENGINE_set_id(e
, engine_openssl_id
)
98 || !ENGINE_set_name(e
, engine_openssl_name
)
99 || !ENGINE_set_destroy_function(e
, openssl_destroy
)
100 #ifndef TEST_ENG_OPENSSL_NO_ALGORITHMS
101 # ifndef OPENSSL_NO_RSA
102 || !ENGINE_set_RSA(e
, RSA_get_default_method())
104 # ifndef OPENSSL_NO_DSA
105 || !ENGINE_set_DSA(e
, DSA_get_default_method())
107 # ifndef OPENSSL_NO_EC
108 || !ENGINE_set_EC(e
, EC_KEY_OpenSSL())
110 # ifndef OPENSSL_NO_DH
111 || !ENGINE_set_DH(e
, DH_get_default_method())
113 || !ENGINE_set_RAND(e
, RAND_OpenSSL())
114 # ifdef TEST_ENG_OPENSSL_RC4
115 || !ENGINE_set_ciphers(e
, openssl_ciphers
)
117 # ifdef TEST_ENG_OPENSSL_SHA
118 || !ENGINE_set_digests(e
, openssl_digests
)
121 #ifdef TEST_ENG_OPENSSL_PKEY
122 || !ENGINE_set_load_privkey_function(e
, openssl_load_privkey
)
124 #ifdef TEST_ENG_OPENSSL_HMAC
125 || !ossl_register_hmac_meth()
126 || !ENGINE_set_pkey_meths(e
, ossl_pkey_meths
)
131 * If we add errors to this ENGINE, ensure the error handling is setup
134 /* openssl_load_error_strings(); */
138 static ENGINE
*engine_openssl(void)
140 ENGINE
*ret
= ENGINE_new();
143 if (!bind_helper(ret
)) {
150 void engine_load_openssl_int(void)
152 ENGINE
*toadd
= engine_openssl();
159 * If the "add" worked, it gets a structural reference. So either way, we
160 * release our just-created reference.
164 * If the "add" didn't work, it was probably a conflict because it was
165 * already added (eg. someone calling ENGINE_load_blah then calling
166 * ENGINE_load_builtin_engines() perhaps).
172 * This stuff is needed if this ENGINE is being compiled into a
173 * self-contained shared-library.
175 #ifdef ENGINE_DYNAMIC_SUPPORT
176 static int bind_fn(ENGINE
*e
, const char *id
)
178 if (id
&& (strcmp(id
, engine_openssl_id
) != 0))
185 IMPLEMENT_DYNAMIC_CHECK_FN()
186 IMPLEMENT_DYNAMIC_BIND_FN(bind_fn
)
187 #endif /* ENGINE_DYNAMIC_SUPPORT */
188 #ifdef TEST_ENG_OPENSSL_RC4
190 * This section of code compiles an "alternative implementation" of two modes of
191 * RC4 into this ENGINE. The result is that EVP_CIPHER operation for "rc4"
192 * should under normal circumstances go via this support rather than the default
193 * EVP support. There are other symbols to tweak the testing;
194 * TEST_ENC_OPENSSL_RC4_OTHERS - print a one line message to stderr each time
195 * we're asked for a cipher we don't support (should not happen).
196 * TEST_ENG_OPENSSL_RC4_P_INIT - print a one line message to stderr each time
197 * the "init_key" handler is called.
198 * TEST_ENG_OPENSSL_RC4_P_CIPHER - ditto for the "cipher" handler.
200 # include <openssl/rc4.h>
201 # define TEST_RC4_KEY_SIZE 16
203 unsigned char key
[TEST_RC4_KEY_SIZE
];
206 # define test(ctx) ((TEST_RC4_KEY *)EVP_CIPHER_CTX_get_cipher_data(ctx))
207 static int test_rc4_init_key(EVP_CIPHER_CTX
*ctx
, const unsigned char *key
,
208 const unsigned char *iv
, int enc
)
210 const int n
= EVP_CIPHER_CTX_key_length(ctx
);
212 # ifdef TEST_ENG_OPENSSL_RC4_P_INIT
213 fprintf(stderr
, "(TEST_ENG_OPENSSL_RC4) test_init_key() called\n");
217 memcpy(&test(ctx
)->key
[0], key
, n
);
218 RC4_set_key(&test(ctx
)->ks
, n
, test(ctx
)->key
);
222 static int test_rc4_cipher(EVP_CIPHER_CTX
*ctx
, unsigned char *out
,
223 const unsigned char *in
, size_t inl
)
225 # ifdef TEST_ENG_OPENSSL_RC4_P_CIPHER
226 fprintf(stderr
, "(TEST_ENG_OPENSSL_RC4) test_cipher() called\n");
228 RC4(&test(ctx
)->ks
, inl
, in
, out
);
232 static EVP_CIPHER
*r4_cipher
= NULL
;
233 static const EVP_CIPHER
*test_r4_cipher(void)
235 if (r4_cipher
== NULL
) {
238 if ((cipher
= EVP_CIPHER_meth_new(NID_rc4
, 1, TEST_RC4_KEY_SIZE
)) == NULL
239 || !EVP_CIPHER_meth_set_iv_length(cipher
, 0)
240 || !EVP_CIPHER_meth_set_flags(cipher
, EVP_CIPH_VARIABLE_LENGTH
)
241 || !EVP_CIPHER_meth_set_init(cipher
, test_rc4_init_key
)
242 || !EVP_CIPHER_meth_set_do_cipher(cipher
, test_rc4_cipher
)
243 || !EVP_CIPHER_meth_set_impl_ctx_size(cipher
, sizeof(TEST_RC4_KEY
))) {
244 EVP_CIPHER_meth_free(cipher
);
251 static void test_r4_cipher_destroy(void)
253 EVP_CIPHER_meth_free(r4_cipher
);
257 static EVP_CIPHER
*r4_40_cipher
= NULL
;
258 static const EVP_CIPHER
*test_r4_40_cipher(void)
260 if (r4_40_cipher
== NULL
) {
263 if ((cipher
= EVP_CIPHER_meth_new(NID_rc4
, 1, 5 /* 40 bits */)) == NULL
264 || !EVP_CIPHER_meth_set_iv_length(cipher
, 0)
265 || !EVP_CIPHER_meth_set_flags(cipher
, EVP_CIPH_VARIABLE_LENGTH
)
266 || !EVP_CIPHER_meth_set_init(cipher
, test_rc4_init_key
)
267 || !EVP_CIPHER_meth_set_do_cipher(cipher
, test_rc4_cipher
)
268 || !EVP_CIPHER_meth_set_impl_ctx_size(cipher
, sizeof(TEST_RC4_KEY
))) {
269 EVP_CIPHER_meth_free(cipher
);
272 r4_40_cipher
= cipher
;
276 static void test_r4_40_cipher_destroy(void)
278 EVP_CIPHER_meth_free(r4_40_cipher
);
281 static int test_cipher_nids(const int **nids
)
283 static int cipher_nids
[4] = { 0, 0, 0, 0 };
288 const EVP_CIPHER
*cipher
;
289 if ((cipher
= test_r4_cipher()) != NULL
)
290 cipher_nids
[pos
++] = EVP_CIPHER_nid(cipher
);
291 if ((cipher
= test_r4_40_cipher()) != NULL
)
292 cipher_nids
[pos
++] = EVP_CIPHER_nid(cipher
);
293 cipher_nids
[pos
] = 0;
300 static int openssl_ciphers(ENGINE
*e
, const EVP_CIPHER
**cipher
,
301 const int **nids
, int nid
)
304 /* We are returning a list of supported nids */
305 return test_cipher_nids(nids
);
307 /* We are being asked for a specific cipher */
309 *cipher
= test_r4_cipher();
310 else if (nid
== NID_rc4_40
)
311 *cipher
= test_r4_40_cipher();
313 # ifdef TEST_ENG_OPENSSL_RC4_OTHERS
314 fprintf(stderr
, "(TEST_ENG_OPENSSL_RC4) returning NULL for "
324 #ifdef TEST_ENG_OPENSSL_SHA
325 /* Much the same sort of comment as for TEST_ENG_OPENSSL_RC4 */
326 # include <openssl/sha.h>
328 static int test_sha1_init(EVP_MD_CTX
*ctx
)
330 # ifdef TEST_ENG_OPENSSL_SHA_P_INIT
331 fprintf(stderr
, "(TEST_ENG_OPENSSL_SHA) test_sha1_init() called\n");
333 return SHA1_Init(EVP_MD_CTX_md_data(ctx
));
336 static int test_sha1_update(EVP_MD_CTX
*ctx
, const void *data
, size_t count
)
338 # ifdef TEST_ENG_OPENSSL_SHA_P_UPDATE
339 fprintf(stderr
, "(TEST_ENG_OPENSSL_SHA) test_sha1_update() called\n");
341 return SHA1_Update(EVP_MD_CTX_md_data(ctx
), data
, count
);
344 static int test_sha1_final(EVP_MD_CTX
*ctx
, unsigned char *md
)
346 # ifdef TEST_ENG_OPENSSL_SHA_P_FINAL
347 fprintf(stderr
, "(TEST_ENG_OPENSSL_SHA) test_sha1_final() called\n");
349 return SHA1_Final(md
, EVP_MD_CTX_md_data(ctx
));
352 static EVP_MD
*sha1_md
= NULL
;
353 static const EVP_MD
*test_sha_md(void)
355 if (sha1_md
== NULL
) {
358 if ((md
= EVP_MD_meth_new(NID_sha1
, NID_sha1WithRSAEncryption
)) == NULL
359 || !EVP_MD_meth_set_result_size(md
, SHA_DIGEST_LENGTH
)
360 || !EVP_MD_meth_set_input_blocksize(md
, SHA_CBLOCK
)
361 || !EVP_MD_meth_set_app_datasize(md
,
362 sizeof(EVP_MD
*) + sizeof(SHA_CTX
))
363 || !EVP_MD_meth_set_flags(md
, 0)
364 || !EVP_MD_meth_set_init(md
, test_sha1_init
)
365 || !EVP_MD_meth_set_update(md
, test_sha1_update
)
366 || !EVP_MD_meth_set_final(md
, test_sha1_final
)) {
367 EVP_MD_meth_free(md
);
374 static void test_sha_md_destroy(void)
376 EVP_MD_meth_free(sha1_md
);
379 static int test_digest_nids(const int **nids
)
381 static int digest_nids
[2] = { 0, 0 };
387 if ((md
= test_sha_md()) != NULL
)
388 digest_nids
[pos
++] = EVP_MD_type(md
);
389 digest_nids
[pos
] = 0;
396 static int openssl_digests(ENGINE
*e
, const EVP_MD
**digest
,
397 const int **nids
, int nid
)
400 /* We are returning a list of supported nids */
401 return test_digest_nids(nids
);
403 /* We are being asked for a specific digest */
405 *digest
= test_sha_md();
407 # ifdef TEST_ENG_OPENSSL_SHA_OTHERS
408 fprintf(stderr
, "(TEST_ENG_OPENSSL_SHA) returning NULL for "
418 #ifdef TEST_ENG_OPENSSL_PKEY
419 static EVP_PKEY
*openssl_load_privkey(ENGINE
*eng
, const char *key_id
,
420 UI_METHOD
*ui_method
,
425 fprintf(stderr
, "(TEST_ENG_OPENSSL_PKEY)Loading Private key %s\n",
427 in
= BIO_new_file(key_id
, "r");
430 key
= PEM_read_bio_PrivateKey(in
, NULL
, 0, NULL
);
436 #ifdef TEST_ENG_OPENSSL_HMAC
439 * Experimental HMAC redirection implementation: mainly copied from
443 /* HMAC pkey context structure */
446 const EVP_MD
*md
; /* MD for HMAC use */
447 ASN1_OCTET_STRING ktmp
; /* Temp storage for key */
449 } OSSL_HMAC_PKEY_CTX
;
451 static int ossl_hmac_init(EVP_PKEY_CTX
*ctx
)
453 OSSL_HMAC_PKEY_CTX
*hctx
;
455 if ((hctx
= OPENSSL_zalloc(sizeof(*hctx
))) == NULL
) {
456 ERR_raise(ERR_LIB_ENGINE
, ERR_R_MALLOC_FAILURE
);
459 hctx
->ktmp
.type
= V_ASN1_OCTET_STRING
;
460 hctx
->ctx
= HMAC_CTX_new();
461 if (hctx
->ctx
== NULL
) {
465 EVP_PKEY_CTX_set_data(ctx
, hctx
);
466 EVP_PKEY_CTX_set0_keygen_info(ctx
, NULL
, 0);
467 # ifdef TEST_ENG_OPENSSL_HMAC_INIT
468 fprintf(stderr
, "(TEST_ENG_OPENSSL_HMAC) ossl_hmac_init() called\n");
473 static void ossl_hmac_cleanup(EVP_PKEY_CTX
*ctx
);
475 static int ossl_hmac_copy(EVP_PKEY_CTX
*dst
, EVP_PKEY_CTX
*src
)
477 OSSL_HMAC_PKEY_CTX
*sctx
, *dctx
;
479 /* allocate memory for dst->data and a new HMAC_CTX in dst->data->ctx */
480 if (!ossl_hmac_init(dst
))
482 sctx
= EVP_PKEY_CTX_get_data(src
);
483 dctx
= EVP_PKEY_CTX_get_data(dst
);
485 if (!HMAC_CTX_copy(dctx
->ctx
, sctx
->ctx
))
487 if (sctx
->ktmp
.data
) {
488 if (!ASN1_OCTET_STRING_set(&dctx
->ktmp
,
489 sctx
->ktmp
.data
, sctx
->ktmp
.length
))
494 /* release HMAC_CTX in dst->data->ctx and memory allocated for dst->data */
495 ossl_hmac_cleanup(dst
);
499 static void ossl_hmac_cleanup(EVP_PKEY_CTX
*ctx
)
501 OSSL_HMAC_PKEY_CTX
*hctx
= EVP_PKEY_CTX_get_data(ctx
);
504 HMAC_CTX_free(hctx
->ctx
);
505 OPENSSL_clear_free(hctx
->ktmp
.data
, hctx
->ktmp
.length
);
507 EVP_PKEY_CTX_set_data(ctx
, NULL
);
511 static int ossl_hmac_keygen(EVP_PKEY_CTX
*ctx
, EVP_PKEY
*pkey
)
513 ASN1_OCTET_STRING
*hkey
= NULL
;
514 OSSL_HMAC_PKEY_CTX
*hctx
= EVP_PKEY_CTX_get_data(ctx
);
515 if (!hctx
->ktmp
.data
)
517 hkey
= ASN1_OCTET_STRING_dup(&hctx
->ktmp
);
520 EVP_PKEY_assign(pkey
, EVP_PKEY_HMAC
, hkey
);
525 static int ossl_int_update(EVP_MD_CTX
*ctx
, const void *data
, size_t count
)
527 OSSL_HMAC_PKEY_CTX
*hctx
= EVP_PKEY_CTX_get_data(EVP_MD_CTX_pkey_ctx(ctx
));
528 if (!HMAC_Update(hctx
->ctx
, data
, count
))
533 static int ossl_hmac_signctx_init(EVP_PKEY_CTX
*ctx
, EVP_MD_CTX
*mctx
)
535 EVP_MD_CTX_set_flags(mctx
, EVP_MD_CTX_FLAG_NO_INIT
);
536 EVP_MD_CTX_set_update_fn(mctx
, ossl_int_update
);
540 static int ossl_hmac_signctx(EVP_PKEY_CTX
*ctx
, unsigned char *sig
,
541 size_t *siglen
, EVP_MD_CTX
*mctx
)
544 OSSL_HMAC_PKEY_CTX
*hctx
= EVP_PKEY_CTX_get_data(ctx
);
545 int l
= EVP_MD_CTX_size(mctx
);
553 if (!HMAC_Final(hctx
->ctx
, sig
, &hlen
))
555 *siglen
= (size_t)hlen
;
559 static int ossl_hmac_ctrl(EVP_PKEY_CTX
*ctx
, int type
, int p1
, void *p2
)
561 OSSL_HMAC_PKEY_CTX
*hctx
= EVP_PKEY_CTX_get_data(ctx
);
563 ASN1_OCTET_STRING
*key
;
566 case EVP_PKEY_CTRL_SET_MAC_KEY
:
567 if ((!p2
&& p1
> 0) || (p1
< -1))
569 if (!ASN1_OCTET_STRING_set(&hctx
->ktmp
, p2
, p1
))
573 case EVP_PKEY_CTRL_MD
:
577 case EVP_PKEY_CTRL_DIGESTINIT
:
578 pk
= EVP_PKEY_CTX_get0_pkey(ctx
);
579 key
= EVP_PKEY_get0(pk
);
580 if (!HMAC_Init_ex(hctx
->ctx
, key
->data
, key
->length
, hctx
->md
, NULL
))
591 static int ossl_hmac_ctrl_str(EVP_PKEY_CTX
*ctx
,
592 const char *type
, const char *value
)
597 if (strcmp(type
, "key") == 0) {
598 void *p
= (void *)value
;
599 return ossl_hmac_ctrl(ctx
, EVP_PKEY_CTRL_SET_MAC_KEY
, -1, p
);
601 if (strcmp(type
, "hexkey") == 0) {
605 key
= OPENSSL_hexstr2buf(value
, &keylen
);
608 r
= ossl_hmac_ctrl(ctx
, EVP_PKEY_CTRL_SET_MAC_KEY
, keylen
, key
);
615 static EVP_PKEY_METHOD
*ossl_hmac_meth
;
617 static int ossl_register_hmac_meth(void)
619 EVP_PKEY_METHOD
*meth
;
620 meth
= EVP_PKEY_meth_new(EVP_PKEY_HMAC
, 0);
623 EVP_PKEY_meth_set_init(meth
, ossl_hmac_init
);
624 EVP_PKEY_meth_set_copy(meth
, ossl_hmac_copy
);
625 EVP_PKEY_meth_set_cleanup(meth
, ossl_hmac_cleanup
);
627 EVP_PKEY_meth_set_keygen(meth
, 0, ossl_hmac_keygen
);
629 EVP_PKEY_meth_set_signctx(meth
, ossl_hmac_signctx_init
,
632 EVP_PKEY_meth_set_ctrl(meth
, ossl_hmac_ctrl
, ossl_hmac_ctrl_str
);
633 ossl_hmac_meth
= meth
;
637 static int ossl_pkey_meths(ENGINE
*e
, EVP_PKEY_METHOD
**pmeth
,
638 const int **nids
, int nid
)
640 static int ossl_pkey_nids
[] = {
646 *nids
= ossl_pkey_nids
;
650 if (nid
== EVP_PKEY_HMAC
) {
651 *pmeth
= ossl_hmac_meth
;
661 int openssl_destroy(ENGINE
*e
)
663 test_sha_md_destroy();
664 #ifdef TEST_ENG_OPENSSL_RC4
665 test_r4_cipher_destroy();
666 test_r4_40_cipher_destroy();