2 * Copyright 2020 The OpenSSL Project Authors. All Rights Reserved.
4 * Licensed under the Apache License 2.0 (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
11 #include <openssl/evp.h>
12 #include <openssl/pem.h>
13 #include <openssl/rsa.h>
14 #include <openssl/x509.h>
15 #include <openssl/params.h>
16 #include <openssl/encoder.h>
17 #include <openssl/decoder.h>
19 #include "internal/pem.h" /* For PVK and "blob" PEM headers */
20 #include "internal/cryptlib.h" /* ossl_assert */
25 * TODO(3.0) Modify PEM_write_bio_PrivateKey_traditional() to handle
26 * provider side EVP_PKEYs (which don't necessarily have an ameth)
28 * In the mean time, we use separate "downgraded" EVP_PKEYs to test
29 * encoding/decoding with "traditional" keys.
32 static EVP_PKEY
*make_template(const char *type
, OSSL_PARAM
*genparams
)
34 EVP_PKEY
*pkey
= NULL
;
35 EVP_PKEY_CTX
*ctx
= EVP_PKEY_CTX_new_from_name(NULL
, type
, NULL
);
38 * No real need to check the errors other than for the cascade
39 * effect. |pkey| will simply remain NULL if something goes wrong.
42 && EVP_PKEY_paramgen_init(ctx
) > 0
44 || EVP_PKEY_CTX_set_params(ctx
, genparams
) > 0)
45 && EVP_PKEY_gen(ctx
, &pkey
) > 0);
46 EVP_PKEY_CTX_free(ctx
);
51 static EVP_PKEY
*make_key(const char *type
, EVP_PKEY
*template,
52 OSSL_PARAM
*genparams
, int make_legacy
)
54 EVP_PKEY
*pkey
= NULL
;
57 ? EVP_PKEY_CTX_new(template, NULL
)
58 : EVP_PKEY_CTX_new_from_name(NULL
, type
, NULL
);
61 * No real need to check the errors other than for the cascade
62 * effect. |pkey| will simply remain NULL if something goes wrong.
65 && EVP_PKEY_keygen_init(ctx
) > 0
67 || EVP_PKEY_CTX_set_params(ctx
, genparams
) > 0)
68 && EVP_PKEY_keygen(ctx
, &pkey
) > 0);
69 EVP_PKEY_CTX_free(ctx
);
70 if (make_legacy
&& EVP_PKEY_get0(pkey
) == NULL
) {
79 /* Main test driver */
82 * TODO(3.0) For better error output, changed the callbacks to take __FILE__
83 * and __LINE__ as first two arguments, and have them use the lower case
84 * functions, such as test_strn_eq(), rather than the uppercase macros
85 * (TEST_strn2_eq(), for example).
88 typedef int (encoder
)(void **encoded
, long *encoded_len
,
89 void *object
, const char *pass
, const char *pcipher
,
90 const char *encoder_propq
);
91 typedef int (decoder
)(void **object
,
92 void *encoded
, long encoded_len
,
94 typedef int (tester
)(const void *data1
, size_t data1_len
,
95 const void *data2
, size_t data2_len
);
96 typedef int (checker
)(const char *type
, const void *data
, size_t data_len
);
97 typedef void (dumper
)(const char *label
, const void *data
, size_t data_len
);
99 static int test_encode_decode(const char *type
, EVP_PKEY
*pkey
,
100 const char *pass
, const char *pcipher
,
104 checker
*check_cb
, dumper
*dump_cb
,
105 const char *encoder_propq
, int make_legacy
)
107 void *encoded
= NULL
;
108 long encoded_len
= 0;
109 EVP_PKEY
*pkey2
= NULL
;
110 void *encoded2
= NULL
;
111 long encoded2_len
= 0;
114 if (!encode_cb(&encoded
, &encoded_len
, pkey
,
115 pass
, pcipher
, encoder_propq
)
116 || !check_cb(type
, encoded
, encoded_len
)
117 || !decode_cb((void **)&pkey2
, encoded
, encoded_len
,
119 || !TEST_int_eq(EVP_PKEY_eq(pkey
, pkey2
), 1))
123 * TODO(3.0) Remove this when PEM_write_bio_PrivateKey_traditional()
124 * handles provider side keys.
127 && !TEST_ptr(EVP_PKEY_get0(pkey2
)))
131 * Double check the encoding, but only for unprotected keys,
132 * as protected keys have a random component, which makes the output
135 if ((pass
== NULL
&& pcipher
== NULL
)
136 && (!encode_cb(&encoded2
, &encoded2_len
, pkey2
,
137 pass
, pcipher
, encoder_propq
)
138 || !test_cb(encoded
, encoded_len
,
139 encoded2
, encoded2_len
)))
145 if (encoded
!= NULL
&& encoded_len
!= 0)
146 dump_cb("encoded result", encoded
, encoded_len
);
147 if (encoded2
!= NULL
&& encoded2_len
!= 0)
148 dump_cb("re-encoded result", encoded2
, encoded2_len
);
151 OPENSSL_free(encoded
);
152 OPENSSL_free(encoded2
);
153 EVP_PKEY_free(pkey2
);
157 /* Encoding and desencoding methods */
159 static int encode_EVP_PKEY_prov(void **encoded
, long *encoded_len
,
161 const char *pass
, const char *pcipher
,
162 const char *encoder_propq
)
164 EVP_PKEY
*pkey
= object
;
165 OSSL_ENCODER_CTX
*ectx
= NULL
;
167 BUF_MEM
*mem_buf
= NULL
;
168 const unsigned char *upass
= (const unsigned char *)pass
;
171 if (!TEST_ptr(ectx
= OSSL_ENCODER_CTX_new_by_EVP_PKEY(pkey
, encoder_propq
))
173 && !TEST_true(OSSL_ENCODER_CTX_set_passphrase(ectx
, upass
,
176 && !TEST_true(OSSL_ENCODER_CTX_set_cipher(ectx
, pcipher
, NULL
)))
177 || !TEST_ptr(mem_ser
= BIO_new(BIO_s_mem()))
178 || !TEST_true(OSSL_ENCODER_to_bio(ectx
, mem_ser
))
179 || !TEST_true(BIO_get_mem_ptr(mem_ser
, &mem_buf
) > 0)
180 || !TEST_ptr(*encoded
= mem_buf
->data
)
181 || !TEST_long_gt(*encoded_len
= mem_buf
->length
, 0))
184 /* Detach the encoded output */
185 mem_buf
->data
= NULL
;
190 OSSL_ENCODER_CTX_free(ectx
);
194 static int decode_EVP_PKEY_prov(void **object
,
195 void *encoded
, long encoded_len
,
198 EVP_PKEY
*pkey
= NULL
;
199 OSSL_DECODER_CTX
*dctx
= NULL
;
200 BIO
*mem_deser
= NULL
;
201 const unsigned char *upass
= (const unsigned char *)pass
;
204 if (!TEST_ptr(dctx
= OSSL_DECODER_CTX_new_by_EVP_PKEY(&pkey
, NULL
,
207 && !OSSL_DECODER_CTX_set_passphrase(dctx
, upass
,
209 || !TEST_ptr(mem_deser
= BIO_new_mem_buf(encoded
, encoded_len
))
210 || !TEST_true(OSSL_DECODER_from_bio(dctx
, mem_deser
)))
216 OSSL_DECODER_CTX_free(dctx
);
220 static int encode_EVP_PKEY_legacy_PEM(void **encoded
,
223 const char *pass
, const char *pcipher
,
224 ossl_unused
const char *encoder_propq
)
226 EVP_PKEY
*pkey
= object
;
227 EVP_CIPHER
*cipher
= NULL
;
229 BUF_MEM
*mem_buf
= NULL
;
230 const unsigned char *upass
= (const unsigned char *)pass
;
234 if (pcipher
!= NULL
&& pass
!= NULL
) {
235 passlen
= strlen(pass
);
236 if (!TEST_ptr(cipher
= EVP_CIPHER_fetch(NULL
, pcipher
, NULL
)))
239 if (!TEST_ptr(mem_ser
= BIO_new(BIO_s_mem()))
240 || !TEST_true(PEM_write_bio_PrivateKey_traditional(mem_ser
, pkey
,
244 || !TEST_true(BIO_get_mem_ptr(mem_ser
, &mem_buf
) > 0)
245 || !TEST_ptr(*encoded
= mem_buf
->data
)
246 || !TEST_long_gt(*encoded_len
= mem_buf
->length
, 0))
249 /* Detach the encoded output */
250 mem_buf
->data
= NULL
;
255 EVP_CIPHER_free(cipher
);
259 #ifndef OPENSSL_NO_DSA
260 static int encode_EVP_PKEY_MSBLOB(void **encoded
,
263 ossl_unused
const char *pass
,
264 ossl_unused
const char *pcipher
,
265 ossl_unused
const char *encoder_propq
)
267 EVP_PKEY
*pkey
= object
;
269 BUF_MEM
*mem_buf
= NULL
;
272 if (!TEST_ptr(mem_ser
= BIO_new(BIO_s_mem()))
273 || !TEST_int_ge(i2b_PrivateKey_bio(mem_ser
, pkey
), 0)
274 || !TEST_true(BIO_get_mem_ptr(mem_ser
, &mem_buf
) > 0)
275 || !TEST_ptr(*encoded
= mem_buf
->data
)
276 || !TEST_long_gt(*encoded_len
= mem_buf
->length
, 0))
279 /* Detach the encoded output */
280 mem_buf
->data
= NULL
;
288 static int encode_public_EVP_PKEY_MSBLOB(void **encoded
,
291 ossl_unused
const char *pass
,
292 ossl_unused
const char *pcipher
,
293 ossl_unused
const char *encoder_propq
)
295 EVP_PKEY
*pkey
= object
;
297 BUF_MEM
*mem_buf
= NULL
;
300 if (!TEST_ptr(mem_ser
= BIO_new(BIO_s_mem()))
301 || !TEST_int_ge(i2b_PublicKey_bio(mem_ser
, pkey
), 0)
302 || !TEST_true(BIO_get_mem_ptr(mem_ser
, &mem_buf
) > 0)
303 || !TEST_ptr(*encoded
= mem_buf
->data
)
304 || !TEST_long_gt(*encoded_len
= mem_buf
->length
, 0))
307 /* Detach the encoded output */
308 mem_buf
->data
= NULL
;
316 # ifndef OPENSSL_NO_RC4
317 static pem_password_cb pass_pw
;
318 static int pass_pw(char *buf
, int size
, int rwflag
, void *userdata
)
320 OPENSSL_strlcpy(buf
, userdata
, size
);
321 return strlen(userdata
);
324 static int encode_EVP_PKEY_PVK(void **encoded
, long *encoded_len
,
327 ossl_unused
const char *pcipher
,
328 ossl_unused
const char *encoder_propq
)
330 EVP_PKEY
*pkey
= object
;
332 BUF_MEM
*mem_buf
= NULL
;
333 int enc
= (pass
!= NULL
);
336 if (!TEST_ptr(mem_ser
= BIO_new(BIO_s_mem()))
337 || !TEST_int_ge(i2b_PVK_bio(mem_ser
, pkey
, enc
,
338 pass_pw
, (void *)pass
), 0)
339 || !TEST_true(BIO_get_mem_ptr(mem_ser
, &mem_buf
) > 0)
340 || !TEST_ptr(*encoded
= mem_buf
->data
)
341 || !TEST_long_gt(*encoded_len
= mem_buf
->length
, 0))
344 /* Detach the encoded output */
345 mem_buf
->data
= NULL
;
355 static int test_text(const void *data1
, size_t data1_len
,
356 const void *data2
, size_t data2_len
)
358 return TEST_strn2_eq(data1
, data1_len
, data2
, data2_len
);
361 static int test_mem(const void *data1
, size_t data1_len
,
362 const void *data2
, size_t data2_len
)
364 return TEST_mem_eq(data1
, data1_len
, data2
, data2_len
);
367 /* Test cases and their dumpers / checkers */
369 static void dump_der(const char *label
, const void *data
, size_t data_len
)
371 test_output_memory(label
, data
, data_len
);
374 static void dump_pem(const char *label
, const void *data
, size_t data_len
)
376 test_output_string(label
, data
, data_len
- 1);
379 static int check_unprotected_PKCS8_DER(const char *type
,
380 const void *data
, size_t data_len
)
382 const unsigned char *datap
= data
;
383 PKCS8_PRIV_KEY_INFO
*p8inf
=
384 d2i_PKCS8_PRIV_KEY_INFO(NULL
, &datap
, data_len
);
387 if (TEST_ptr(p8inf
)) {
388 EVP_PKEY
*pkey
= EVP_PKCS82PKEY(p8inf
);
390 ok
= (TEST_ptr(pkey
) && TEST_true(EVP_PKEY_is_a(pkey
, type
)));
393 PKCS8_PRIV_KEY_INFO_free(p8inf
);
397 static int test_unprotected_via_DER(const char *type
, EVP_PKEY
*key
)
399 return test_encode_decode(type
, key
, NULL
, NULL
,
400 encode_EVP_PKEY_prov
,
401 decode_EVP_PKEY_prov
,
403 check_unprotected_PKCS8_DER
, dump_der
,
404 OSSL_ENCODER_PrivateKey_TO_DER_PQ
,
408 static int check_unprotected_PKCS8_PEM(const char *type
,
409 const void *data
, size_t data_len
)
411 static const char pem_header
[] = "-----BEGIN " PEM_STRING_PKCS8INF
"-----";
413 return TEST_strn_eq(data
, pem_header
, sizeof(pem_header
) - 1);
416 static int test_unprotected_via_PEM(const char *type
, EVP_PKEY
*key
)
418 return test_encode_decode(type
, key
, NULL
, NULL
,
419 encode_EVP_PKEY_prov
,
420 decode_EVP_PKEY_prov
,
422 check_unprotected_PKCS8_PEM
, dump_pem
,
423 OSSL_ENCODER_PrivateKey_TO_PEM_PQ
,
427 static int check_unprotected_legacy_PEM(const char *type
,
428 const void *data
, size_t data_len
)
430 static char pem_header
[80];
433 TEST_int_gt(BIO_snprintf(pem_header
, sizeof(pem_header
),
434 "-----BEGIN %s PRIVATE KEY-----", type
), 0)
435 && TEST_strn_eq(data
, pem_header
, strlen(pem_header
));
438 static int test_unprotected_via_legacy_PEM(const char *type
, EVP_PKEY
*key
)
440 return test_encode_decode(type
, key
, NULL
, NULL
,
441 encode_EVP_PKEY_legacy_PEM
,
442 decode_EVP_PKEY_prov
,
444 check_unprotected_legacy_PEM
, dump_pem
,
448 #ifndef OPENSSL_NO_DSA
449 static int check_MSBLOB(const char *type
, const void *data
, size_t data_len
)
451 const unsigned char *datap
= data
;
452 EVP_PKEY
*pkey
= b2i_PrivateKey(&datap
, data_len
);
453 int ok
= TEST_ptr(pkey
);
459 static int test_unprotected_via_MSBLOB(const char *type
, EVP_PKEY
*key
)
461 return test_encode_decode(type
, key
, NULL
, NULL
,
462 encode_EVP_PKEY_MSBLOB
,
463 decode_EVP_PKEY_prov
,
465 check_MSBLOB
, dump_der
,
469 # ifndef OPENSSL_NO_RC4
470 static int check_PVK(const char *type
, const void *data
, size_t data_len
)
472 const unsigned char *in
= data
;
473 unsigned int saltlen
= 0, keylen
= 0;
474 int ok
= ossl_do_PVK_header(&in
, data_len
, 0, &saltlen
, &keylen
);
479 static int test_unprotected_via_PVK(const char *type
, EVP_PKEY
*key
)
481 return test_encode_decode(type
, key
, NULL
, NULL
,
483 decode_EVP_PKEY_prov
,
491 static const char *pass_cipher
= "AES-256-CBC";
492 static const char *pass
= "the holy handgrenade of antioch";
494 static int check_protected_PKCS8_DER(const char *type
,
495 const void *data
, size_t data_len
)
497 const unsigned char *datap
= data
;
498 X509_SIG
*p8
= d2i_X509_SIG(NULL
, &datap
, data_len
);
499 int ok
= TEST_ptr(p8
);
505 static int test_protected_via_DER(const char *type
, EVP_PKEY
*key
)
507 return test_encode_decode(type
, key
, pass
, pass_cipher
,
508 encode_EVP_PKEY_prov
,
509 decode_EVP_PKEY_prov
,
511 check_protected_PKCS8_DER
, dump_der
,
512 OSSL_ENCODER_PrivateKey_TO_DER_PQ
,
516 static int check_protected_PKCS8_PEM(const char *type
,
517 const void *data
, size_t data_len
)
519 static const char pem_header
[] = "-----BEGIN " PEM_STRING_PKCS8
"-----";
521 return TEST_strn_eq(data
, pem_header
, sizeof(pem_header
) - 1);
524 static int test_protected_via_PEM(const char *type
, EVP_PKEY
*key
)
526 return test_encode_decode(type
, key
, pass
, pass_cipher
,
527 encode_EVP_PKEY_prov
,
528 decode_EVP_PKEY_prov
,
530 check_protected_PKCS8_PEM
, dump_pem
,
531 OSSL_ENCODER_PrivateKey_TO_PEM_PQ
,
535 static int check_protected_legacy_PEM(const char *type
,
536 const void *data
, size_t data_len
)
538 static char pem_header
[80];
541 TEST_int_gt(BIO_snprintf(pem_header
, sizeof(pem_header
),
542 "-----BEGIN %s PRIVATE KEY-----", type
), 0)
543 && TEST_strn_eq(data
, pem_header
, strlen(pem_header
))
544 && TEST_ptr(strstr(data
, "\nDEK-Info: "));
547 static int test_protected_via_legacy_PEM(const char *type
, EVP_PKEY
*key
)
549 return test_encode_decode(type
, key
, pass
, pass_cipher
,
550 encode_EVP_PKEY_legacy_PEM
,
551 decode_EVP_PKEY_prov
,
553 check_protected_legacy_PEM
, dump_pem
,
557 #if !defined(OPENSSL_NO_DSA) && !defined(OPENSSL_NO_RC4)
558 static int test_protected_via_PVK(const char *type
, EVP_PKEY
*key
)
560 return test_encode_decode(type
, key
, pass
, NULL
,
562 decode_EVP_PKEY_prov
,
569 static int check_public_DER(const char *type
, const void *data
, size_t data_len
)
571 const unsigned char *datap
= data
;
572 EVP_PKEY
*pkey
= d2i_PUBKEY(NULL
, &datap
, data_len
);
573 int ok
= (TEST_ptr(pkey
) && TEST_true(EVP_PKEY_is_a(pkey
, type
)));
579 static int test_public_via_DER(const char *type
, EVP_PKEY
*key
)
581 return test_encode_decode(type
, key
, NULL
, NULL
,
582 encode_EVP_PKEY_prov
,
583 decode_EVP_PKEY_prov
,
585 check_public_DER
, dump_der
,
586 OSSL_ENCODER_PUBKEY_TO_DER_PQ
,
590 static int check_public_PEM(const char *type
, const void *data
, size_t data_len
)
592 static const char pem_header
[] = "-----BEGIN " PEM_STRING_PUBLIC
"-----";
595 TEST_strn_eq(data
, pem_header
, sizeof(pem_header
) - 1);
598 static int test_public_via_PEM(const char *type
, EVP_PKEY
*key
)
600 return test_encode_decode(type
, key
, NULL
, NULL
,
601 encode_EVP_PKEY_prov
,
602 decode_EVP_PKEY_prov
,
604 check_public_PEM
, dump_pem
,
605 OSSL_ENCODER_PUBKEY_TO_PEM_PQ
,
609 #ifndef OPENSSL_NO_DSA
610 static int check_public_MSBLOB(const char *type
,
611 const void *data
, size_t data_len
)
613 const unsigned char *datap
= data
;
614 EVP_PKEY
*pkey
= b2i_PublicKey(&datap
, data_len
);
615 int ok
= TEST_ptr(pkey
);
621 static int test_public_via_MSBLOB(const char *type
, EVP_PKEY
*key
)
623 return test_encode_decode(type
, key
, NULL
, NULL
,
624 encode_public_EVP_PKEY_MSBLOB
,
625 decode_EVP_PKEY_prov
,
627 check_public_MSBLOB
, dump_der
,
632 #define KEYS(KEYTYPE) \
633 static EVP_PKEY *key_##KEYTYPE = NULL; \
634 static EVP_PKEY *legacy_key_##KEYTYPE = NULL
635 #define MAKE_KEYS(KEYTYPE, KEYTYPEstr, params) \
637 && TEST_ptr(key_##KEYTYPE = \
638 make_key(KEYTYPEstr, NULL, params, 0)) \
639 && TEST_ptr(legacy_key_##KEYTYPE = \
640 make_key(KEYTYPEstr, NULL, params, 1))
641 #define FREE_KEYS(KEYTYPE) \
642 EVP_PKEY_free(key_##KEYTYPE); \
643 EVP_PKEY_free(legacy_key_##KEYTYPE)
645 #define DOMAIN_KEYS(KEYTYPE) \
646 static EVP_PKEY *template_##KEYTYPE = NULL; \
647 static EVP_PKEY *key_##KEYTYPE = NULL; \
648 static EVP_PKEY *legacy_key_##KEYTYPE = NULL
649 #define MAKE_DOMAIN_KEYS(KEYTYPE, KEYTYPEstr, params) \
651 && TEST_ptr(template_##KEYTYPE = \
652 make_template(KEYTYPEstr, params)) \
653 && TEST_ptr(key_##KEYTYPE = \
654 make_key(KEYTYPEstr, template_##KEYTYPE, NULL, 0)) \
655 && TEST_ptr(legacy_key_##KEYTYPE = \
656 make_key(KEYTYPEstr, template_##KEYTYPE, NULL, 1))
657 #define FREE_DOMAIN_KEYS(KEYTYPE) \
658 EVP_PKEY_free(template_##KEYTYPE); \
659 EVP_PKEY_free(key_##KEYTYPE); \
660 EVP_PKEY_free(legacy_key_##KEYTYPE)
662 #define IMPLEMENT_TEST_SUITE(KEYTYPE, KEYTYPEstr) \
663 static int test_unprotected_##KEYTYPE##_via_DER(void) \
665 return test_unprotected_via_DER(KEYTYPEstr, key_##KEYTYPE); \
667 static int test_unprotected_##KEYTYPE##_via_PEM(void) \
669 return test_unprotected_via_PEM(KEYTYPEstr, key_##KEYTYPE); \
671 static int test_unprotected_##KEYTYPE##_via_legacy_PEM(void) \
673 return test_unprotected_via_legacy_PEM(KEYTYPEstr, \
674 legacy_key_##KEYTYPE); \
676 static int test_protected_##KEYTYPE##_via_DER(void) \
678 return test_protected_via_DER(KEYTYPEstr, key_##KEYTYPE); \
680 static int test_protected_##KEYTYPE##_via_PEM(void) \
682 return test_protected_via_PEM(KEYTYPEstr, key_##KEYTYPE); \
684 static int test_protected_##KEYTYPE##_via_legacy_PEM(void) \
686 return test_protected_via_legacy_PEM(KEYTYPEstr, \
687 legacy_key_##KEYTYPE); \
689 static int test_public_##KEYTYPE##_via_DER(void) \
691 return test_public_via_DER(KEYTYPEstr, key_##KEYTYPE); \
693 static int test_public_##KEYTYPE##_via_PEM(void) \
695 return test_public_via_PEM(KEYTYPEstr, key_##KEYTYPE); \
698 #define ADD_TEST_SUITE(KEYTYPE) \
699 ADD_TEST(test_unprotected_##KEYTYPE##_via_DER); \
700 ADD_TEST(test_unprotected_##KEYTYPE##_via_PEM); \
701 ADD_TEST(test_unprotected_##KEYTYPE##_via_legacy_PEM); \
702 ADD_TEST(test_protected_##KEYTYPE##_via_DER); \
703 ADD_TEST(test_protected_##KEYTYPE##_via_PEM); \
704 ADD_TEST(test_protected_##KEYTYPE##_via_legacy_PEM); \
705 ADD_TEST(test_public_##KEYTYPE##_via_DER); \
706 ADD_TEST(test_public_##KEYTYPE##_via_PEM)
708 #ifndef OPENSSL_NO_DSA
709 # define IMPLEMENT_TEST_SUITE_MSBLOB(KEYTYPE, KEYTYPEstr) \
710 static int test_unprotected_##KEYTYPE##_via_MSBLOB(void) \
712 return test_unprotected_via_MSBLOB(KEYTYPEstr, key_##KEYTYPE); \
714 static int test_public_##KEYTYPE##_via_MSBLOB(void) \
716 return test_public_via_MSBLOB(KEYTYPEstr, key_##KEYTYPE); \
719 # define ADD_TEST_SUITE_MSBLOB(KEYTYPE) \
720 ADD_TEST(test_unprotected_##KEYTYPE##_via_MSBLOB); \
721 ADD_TEST(test_public_##KEYTYPE##_via_MSBLOB)
723 # ifndef OPENSSL_NO_RC4
724 # define IMPLEMENT_TEST_SUITE_PVK(KEYTYPE, KEYTYPEstr) \
725 static int test_unprotected_##KEYTYPE##_via_PVK(void) \
727 return test_unprotected_via_PVK(KEYTYPEstr, key_##KEYTYPE); \
729 static int test_protected_##KEYTYPE##_via_PVK(void) \
731 return test_protected_via_PVK(KEYTYPEstr, key_##KEYTYPE); \
734 # define ADD_TEST_SUITE_PVK(KEYTYPE) \
735 ADD_TEST(test_unprotected_##KEYTYPE##_via_PVK); \
736 ADD_TEST(test_protected_##KEYTYPE##_via_PVK)
740 #ifndef OPENSSL_NO_DH
742 IMPLEMENT_TEST_SUITE(DH
, "DH")
744 IMPLEMENT_TEST_SUITE(DHX
, "X9.42 DH")
746 #ifndef OPENSSL_NO_DSA
748 IMPLEMENT_TEST_SUITE(DSA
, "DSA")
749 IMPLEMENT_TEST_SUITE_MSBLOB(DSA
, "DSA")
750 # ifndef OPENSSL_NO_RC4
751 IMPLEMENT_TEST_SUITE_PVK(DSA
, "DSA")
754 #ifndef OPENSSL_NO_EC
756 IMPLEMENT_TEST_SUITE(EC
, "EC")
758 IMPLEMENT_TEST_SUITE(ED25519
, "ED25519")
760 IMPLEMENT_TEST_SUITE(ED448
, "ED448")
762 IMPLEMENT_TEST_SUITE(X25519
, "X25519")
764 IMPLEMENT_TEST_SUITE(X448
, "X448")
767 IMPLEMENT_TEST_SUITE(RSA
, "RSA")
769 IMPLEMENT_TEST_SUITE(RSA_PSS
, "RSA-PSS")
770 #ifndef OPENSSL_NO_DSA
771 IMPLEMENT_TEST_SUITE_MSBLOB(RSA
, "RSA")
772 # ifndef OPENSSL_NO_RC4
773 IMPLEMENT_TEST_SUITE_PVK(RSA
, "RSA")
777 int setup_tests(void)
781 #ifndef OPENSSL_NO_DSA
782 static size_t qbits
= 160; /* PVK only tolerates 160 Q bits */
783 static size_t pbits
= 1024; /* With 160 Q bits, we MUST use 1024 P bits */
784 OSSL_PARAM DSA_params
[] = {
785 OSSL_PARAM_size_t("pbits", &pbits
),
786 OSSL_PARAM_size_t("qbits", &qbits
),
791 #ifndef OPENSSL_NO_EC
792 static char groupname
[] = "prime256v1";
793 OSSL_PARAM EC_params
[] = {
794 OSSL_PARAM_utf8_string("group", groupname
, sizeof(groupname
) - 1),
799 /* 7 is the default magic number */
800 static unsigned int rsapss_min_saltlen
= 7;
801 OSSL_PARAM RSA_PSS_params
[] = {
802 OSSL_PARAM_uint("saltlen", &rsapss_min_saltlen
),
806 TEST_info("Generating keys...");
807 #ifndef OPENSSL_NO_DH
808 MAKE_DOMAIN_KEYS(DH
, "DH", NULL
);
809 MAKE_DOMAIN_KEYS(DHX
, "X9.42 DH", NULL
);
811 #ifndef OPENSSL_NO_DSA
812 MAKE_DOMAIN_KEYS(DSA
, "DSA", DSA_params
);
814 #ifndef OPENSSL_NO_EC
815 MAKE_DOMAIN_KEYS(EC
, "EC", EC_params
);
816 MAKE_KEYS(ED25519
, "ED25519", NULL
);
817 MAKE_KEYS(ED448
, "ED448", NULL
);
818 MAKE_KEYS(X25519
, "X25519", NULL
);
819 MAKE_KEYS(X448
, "X448", NULL
);
821 MAKE_KEYS(RSA
, "RSA", NULL
);
822 MAKE_KEYS(RSA_PSS
, "RSA-PSS", RSA_PSS_params
);
823 TEST_info("Generating key... done");
826 #ifndef OPENSSL_NO_DH
830 #ifndef OPENSSL_NO_DSA
832 ADD_TEST_SUITE_MSBLOB(DSA
);
833 # ifndef OPENSSL_NO_RC4
834 ADD_TEST_SUITE_PVK(DSA
);
837 #ifndef OPENSSL_NO_EC
839 ADD_TEST_SUITE(ED25519
);
840 ADD_TEST_SUITE(ED448
);
841 ADD_TEST_SUITE(X25519
);
842 ADD_TEST_SUITE(X448
);
845 ADD_TEST_SUITE(RSA_PSS
);
846 #ifndef OPENSSL_NO_DSA
847 ADD_TEST_SUITE_MSBLOB(RSA
);
848 # ifndef OPENSSL_NO_RC4
849 ADD_TEST_SUITE_PVK(RSA
);
857 void cleanup_tests(void)
859 #ifndef OPENSSL_NO_DH
860 FREE_DOMAIN_KEYS(DH
);
861 FREE_DOMAIN_KEYS(DHX
);
863 #ifndef OPENSSL_NO_DSA
864 FREE_DOMAIN_KEYS(DSA
);
866 #ifndef OPENSSL_NO_EC
867 FREE_DOMAIN_KEYS(EC
);