1 /*
2 * Copyright 2015-2024 The OpenSSL Project Authors. All Rights Reserved.
3 *
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
8 */
9
10 /* We need to use some deprecated APIs */
11 #define OPENSSL_SUPPRESS_DEPRECATED
12
13 /*
14 * Really these tests should be in evp_extra_test - but that doesn't
15 * yet support testing with a non-default libctx. Once it does we should move
16 * everything into one file. Consequently some things are duplicated between
17 * the two files.
18 */
19
20 #include <openssl/evp.h>
21 #include <openssl/pem.h>
22 #include <openssl/provider.h>
23 #include <openssl/rsa.h>
24 #include <openssl/dh.h>
25 #include <openssl/core_names.h>
26 #include <openssl/ui.h>
27
28 #include "testutil.h"
29 #include "internal/nelem.h"
30
31 static OSSL_LIB_CTX *mainctx = NULL;
32 static OSSL_PROVIDER *nullprov = NULL;
33
34 /*
35 * kExampleRSAKeyDER is an RSA private key in ASN.1, DER format. Of course, you
36 * should never use this key anywhere but in an example.
37 */
38 static const unsigned char kExampleRSAKeyDER[] = {
39 0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xf8,
40 0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5, 0xb4, 0x59,
41 0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e, 0xd3, 0x37,
42 0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34, 0x75, 0x71,
43 0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde, 0x97, 0x8a,
44 0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8, 0x50, 0xe4,
45 0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b, 0xdc, 0xec,
46 0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83, 0x58, 0x76,
47 0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48, 0x1a, 0xd8,
48 0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a, 0x5c, 0xd7,
49 0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2, 0xa7, 0x2c,
50 0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01, 0x00, 0x01,
51 0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a, 0x6d, 0xc7,
52 0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5, 0x32, 0x85,
53 0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6, 0x5f, 0xee,
54 0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8, 0x66, 0x85,
55 0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6, 0xa4, 0x0a,
56 0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f, 0xc2, 0x15,
57 0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c, 0x5b, 0x83,
58 0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78, 0x80, 0x1b,
59 0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71, 0x99, 0x73,
60 0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60, 0x1f, 0x99,
61 0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d, 0xb1, 0x02,
62 0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3, 0x40, 0x41,
63 0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d, 0x3d, 0x59,
64 0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18, 0xc6, 0xd9,
65 0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d, 0x9f, 0xef,
66 0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32, 0x46, 0x87,
67 0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc, 0x2c, 0xdf,
68 0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63, 0x55, 0xf5,
69 0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05, 0xcd, 0xb5,
70 0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16, 0xb3, 0x62,
71 0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3, 0x9b, 0x64,
72 0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85, 0xfa, 0xb8,
73 0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97, 0xe8, 0xba,
74 0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7, 0xe7, 0xfe,
75 0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99, 0x75, 0xe7,
76 0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4, 0x9d, 0xfe,
77 0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d, 0xf1, 0xdb,
78 0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40, 0x5a, 0x34,
79 0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26, 0x84, 0x27,
80 0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1, 0xe9, 0xc0,
81 0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c, 0xb9, 0xba,
82 0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30, 0x10, 0x06,
83 0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea, 0x52, 0x2c,
84 0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b, 0xc4, 0x1e,
85 0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e, 0x49, 0xaf,
86 0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9, 0xd1, 0x8a,
87 0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae, 0x17, 0x17,
88 0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d, 0x08, 0xf1,
89 0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
90 };
91
92 /*
93 * kExampleRSAKeyPKCS8 is kExampleRSAKeyDER encoded in a PKCS #8
94 * PrivateKeyInfo.
95 */
96 static const unsigned char kExampleRSAKeyPKCS8[] = {
97 0x30, 0x82, 0x02, 0x76, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a,
98 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82,
99 0x02, 0x60, 0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81,
100 0x00, 0xf8, 0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5,
101 0xb4, 0x59, 0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e,
102 0xd3, 0x37, 0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34,
103 0x75, 0x71, 0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde,
104 0x97, 0x8a, 0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8,
105 0x50, 0xe4, 0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b,
106 0xdc, 0xec, 0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83,
107 0x58, 0x76, 0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48,
108 0x1a, 0xd8, 0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a,
109 0x5c, 0xd7, 0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2,
110 0xa7, 0x2c, 0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01,
111 0x00, 0x01, 0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a,
112 0x6d, 0xc7, 0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5,
113 0x32, 0x85, 0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6,
114 0x5f, 0xee, 0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8,
115 0x66, 0x85, 0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6,
116 0xa4, 0x0a, 0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f,
117 0xc2, 0x15, 0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c,
118 0x5b, 0x83, 0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78,
119 0x80, 0x1b, 0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71,
120 0x99, 0x73, 0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60,
121 0x1f, 0x99, 0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d,
122 0xb1, 0x02, 0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3,
123 0x40, 0x41, 0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d,
124 0x3d, 0x59, 0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18,
125 0xc6, 0xd9, 0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d,
126 0x9f, 0xef, 0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32,
127 0x46, 0x87, 0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc,
128 0x2c, 0xdf, 0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63,
129 0x55, 0xf5, 0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05,
130 0xcd, 0xb5, 0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16,
131 0xb3, 0x62, 0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3,
132 0x9b, 0x64, 0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85,
133 0xfa, 0xb8, 0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97,
134 0xe8, 0xba, 0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7,
135 0xe7, 0xfe, 0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99,
136 0x75, 0xe7, 0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4,
137 0x9d, 0xfe, 0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d,
138 0xf1, 0xdb, 0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40,
139 0x5a, 0x34, 0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26,
140 0x84, 0x27, 0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1,
141 0xe9, 0xc0, 0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c,
142 0xb9, 0xba, 0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30,
143 0x10, 0x06, 0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea,
144 0x52, 0x2c, 0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b,
145 0xc4, 0x1e, 0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e,
146 0x49, 0xaf, 0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9,
147 0xd1, 0x8a, 0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae,
148 0x17, 0x17, 0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d,
149 0x08, 0xf1, 0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
150 };
151
152 #ifndef OPENSSL_NO_DH
153 static const unsigned char kExampleDHPrivateKeyDER[] = {
154 0x30, 0x82, 0x02, 0x26, 0x02, 0x01, 0x00, 0x30, 0x82, 0x01, 0x17, 0x06,
155 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x03, 0x01, 0x30, 0x82,
156 0x01, 0x08, 0x02, 0x82, 0x01, 0x01, 0x00, 0xD8, 0x4B, 0x0F, 0x0E, 0x6B,
157 0x79, 0xE9, 0x23, 0x4E, 0xE4, 0xBE, 0x9A, 0x8F, 0x7A, 0x5C, 0xA3, 0x20,
158 0xD0, 0x86, 0x6B, 0x95, 0x78, 0x39, 0x59, 0x7A, 0x11, 0x2A, 0x5B, 0x87,
159 0xA4, 0xFB, 0x2F, 0x99, 0xD0, 0x57, 0xF5, 0xE1, 0xA3, 0xAF, 0x41, 0xD1,
160 0xCD, 0xA3, 0x94, 0xBB, 0xE5, 0x5A, 0x68, 0xE2, 0xEE, 0x69, 0x56, 0x51,
161 0xB2, 0xEE, 0xF2, 0xFE, 0x10, 0xC9, 0x55, 0xE3, 0x82, 0x3C, 0x50, 0x0D,
162 0xF5, 0x82, 0x73, 0xE4, 0xD6, 0x3E, 0x45, 0xB4, 0x89, 0x80, 0xE4, 0xF0,
163 0x99, 0x85, 0x2B, 0x4B, 0xF9, 0xB8, 0xFD, 0x2C, 0x3C, 0x49, 0x2E, 0xB3,
164 0x56, 0x7E, 0x99, 0x07, 0xD3, 0xF7, 0xD9, 0xE4, 0x0C, 0x64, 0xC5, 0x7D,
165 0x03, 0x8E, 0x05, 0x3C, 0x0A, 0x40, 0x17, 0xAD, 0xA8, 0x0F, 0x9B, 0xF4,
166 0x8B, 0xA7, 0xDB, 0x16, 0x4F, 0x4A, 0x57, 0x0B, 0x89, 0x80, 0x0B, 0x9F,
167 0x26, 0x56, 0x3F, 0x1D, 0xFA, 0x52, 0x2D, 0x1A, 0x9E, 0xDC, 0x42, 0xA3,
168 0x2E, 0xA9, 0x87, 0xE3, 0x8B, 0x45, 0x5E, 0xEE, 0x99, 0xB8, 0x30, 0x15,
169 0x58, 0xA3, 0x5F, 0xB5, 0x69, 0xD8, 0x0C, 0xE8, 0x6B, 0x36, 0xD8, 0xAB,
170 0xD8, 0xE4, 0x77, 0x46, 0x13, 0xA2, 0x15, 0xB3, 0x9C, 0xAD, 0x99, 0x91,
171 0xE5, 0xA3, 0x30, 0x7D, 0x40, 0x70, 0xB3, 0x32, 0x5E, 0xAF, 0x96, 0x8D,
172 0xE6, 0x3F, 0x47, 0xA3, 0x18, 0xDA, 0xE1, 0x9A, 0x20, 0x11, 0xE1, 0x49,
173 0x51, 0x45, 0xE3, 0x8C, 0xA5, 0x56, 0x39, 0x67, 0xCB, 0x9D, 0xCF, 0xBA,
174 0xF4, 0x46, 0x4E, 0x0A, 0xB6, 0x0B, 0xA9, 0xB4, 0xF6, 0xF1, 0x6A, 0xC8,
175 0x63, 0xE2, 0xB4, 0xB2, 0x9F, 0x44, 0xAA, 0x0A, 0xDA, 0x53, 0xF7, 0x52,
176 0x14, 0x57, 0xEE, 0x2C, 0x5D, 0x31, 0x9C, 0x27, 0x03, 0x64, 0x9E, 0xC0,
177 0x1E, 0x4B, 0x1B, 0x4F, 0xEE, 0xA6, 0x3F, 0xC1, 0x3E, 0x61, 0x93, 0x02,
178 0x01, 0x02, 0x04, 0x82, 0x01, 0x04, 0x02, 0x82, 0x01, 0x00, 0x7E, 0xC2,
179 0x04, 0xF9, 0x95, 0xC7, 0xEF, 0x96, 0xBE, 0xA0, 0x9D, 0x2D, 0xC3, 0x0C,
180 0x3A, 0x67, 0x02, 0x7C, 0x7D, 0x3B, 0xC9, 0xB1, 0xDE, 0x13, 0x97, 0x64,
181 0xEF, 0x87, 0x80, 0x4F, 0xBF, 0xA2, 0xAC, 0x18, 0x6B, 0xD5, 0xB2, 0x42,
182 0x0F, 0xDA, 0x28, 0x40, 0x93, 0x40, 0xB2, 0x1E, 0x80, 0xB0, 0x6C, 0xDE,
183 0x9C, 0x54, 0xA4, 0xB4, 0x68, 0x29, 0xE0, 0x13, 0x57, 0x1D, 0xC9, 0x87,
184 0xC0, 0xDE, 0x2F, 0x1D, 0x72, 0xF0, 0xC0, 0xE4, 0x4E, 0x04, 0x48, 0xF5,
185 0x2D, 0x8D, 0x9A, 0x1B, 0xE5, 0xEB, 0x06, 0xAB, 0x7C, 0x74, 0x10, 0x3C,
186 0xA8, 0x2D, 0x39, 0xBC, 0xE3, 0x15, 0x3E, 0x63, 0x37, 0x8C, 0x1B, 0xF1,
187 0xB3, 0x99, 0xB6, 0xAE, 0x5A, 0xEB, 0xB3, 0x3D, 0x30, 0x39, 0x69, 0xDB,
188 0xF2, 0x4F, 0x94, 0xB7, 0x71, 0xAF, 0xBA, 0x5C, 0x1F, 0xF8, 0x6B, 0xE5,
189 0xD1, 0xB1, 0x00, 0x81, 0xE2, 0x6D, 0xEC, 0x65, 0xF7, 0x7E, 0xCE, 0x03,
190 0x84, 0x68, 0x42, 0x6A, 0x8B, 0x47, 0x8E, 0x4A, 0x88, 0xDE, 0x82, 0xDD,
191 0xAF, 0xA9, 0x6F, 0x18, 0xF7, 0xC6, 0xE2, 0xB9, 0x97, 0xCE, 0x47, 0x8F,
192 0x85, 0x19, 0x61, 0x42, 0x67, 0x21, 0x7D, 0x13, 0x6E, 0xB5, 0x5A, 0x62,
193 0xF3, 0x08, 0xE2, 0x70, 0x3B, 0x0E, 0x85, 0x3C, 0xA1, 0xD3, 0xED, 0x7A,
194 0x43, 0xD6, 0xDE, 0x30, 0x5C, 0x48, 0xB2, 0x99, 0xAB, 0x3E, 0x65, 0xA6,
195 0x66, 0x80, 0x22, 0xFF, 0x92, 0xC1, 0x42, 0x1C, 0x30, 0x87, 0x74, 0x1E,
196 0x53, 0x57, 0x7C, 0xF8, 0x77, 0x51, 0xF1, 0x74, 0x16, 0xF4, 0x45, 0x26,
197 0x77, 0x0A, 0x05, 0x96, 0x13, 0x12, 0x06, 0x86, 0x2B, 0xB8, 0x49, 0x82,
198 0x69, 0x43, 0x0A, 0x57, 0xA7, 0x30, 0x19, 0x4C, 0xB8, 0x47, 0x82, 0x6E,
199 0x64, 0x7A, 0x06, 0x13, 0x5A, 0x82, 0x98, 0xD6, 0x7A, 0x09, 0xEC, 0x03,
200 0x8D, 0x03
201 };
202 #endif /* OPENSSL_NO_DH */
203
204 #ifndef OPENSSL_NO_EC
205 /*
206 * kExampleECKeyDER is a sample EC private key encoded as an ECPrivateKey
207 * structure.
208 */
209 static const unsigned char kExampleECKeyDER[] = {
210 0x30, 0x77, 0x02, 0x01, 0x01, 0x04, 0x20, 0x07, 0x0f, 0x08, 0x72, 0x7a,
211 0xd4, 0xa0, 0x4a, 0x9c, 0xdd, 0x59, 0xc9, 0x4d, 0x89, 0x68, 0x77, 0x08,
212 0xb5, 0x6f, 0xc9, 0x5d, 0x30, 0x77, 0x0e, 0xe8, 0xd1, 0xc9, 0xce, 0x0a,
213 0x8b, 0xb4, 0x6a, 0xa0, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
214 0x03, 0x01, 0x07, 0xa1, 0x44, 0x03, 0x42, 0x00, 0x04, 0xe6, 0x2b, 0x69,
215 0xe2, 0xbf, 0x65, 0x9f, 0x97, 0xbe, 0x2f, 0x1e, 0x0d, 0x94, 0x8a, 0x4c,
216 0xd5, 0x97, 0x6b, 0xb7, 0xa9, 0x1e, 0x0d, 0x46, 0xfb, 0xdd, 0xa9, 0xa9,
217 0x1e, 0x9d, 0xdc, 0xba, 0x5a, 0x01, 0xe7, 0xd6, 0x97, 0xa8, 0x0a, 0x18,
218 0xf9, 0xc3, 0xc4, 0xa3, 0x1e, 0x56, 0xe2, 0x7c, 0x83, 0x48, 0xdb, 0x16,
219 0x1a, 0x1c, 0xf5, 0x1d, 0x7e, 0xf1, 0x94, 0x2d, 0x4b, 0xcf, 0x72, 0x22,
220 0xc1,
221 };
222
223 /* P-384 sample EC private key in PKCS8 format (no public key) */
224 static const unsigned char kExampleECKey2DER[] = {
225 0x30, 0x4E, 0x02, 0x01, 0x00, 0x30, 0x10, 0x06, 0x07, 0x2A, 0x86, 0x48,
226 0xCE, 0x3D, 0x02, 0x01, 0x06, 0x05, 0x2B, 0x81, 0x04, 0x00, 0x22, 0x04,
227 0x37, 0x30, 0x35, 0x02, 0x01, 0x01, 0x04, 0x30, 0x73, 0xE3, 0x3A, 0x05,
228 0xF2, 0xB6, 0x99, 0x6D, 0x0C, 0x33, 0x7F, 0x15, 0x9E, 0x10, 0xA9, 0x17,
229 0x4C, 0x0A, 0x82, 0x57, 0x71, 0x13, 0x7A, 0xAC, 0x46, 0xA2, 0x5E, 0x1C,
230 0xE0, 0xC7, 0xB2, 0xF8, 0x20, 0x40, 0xC2, 0x27, 0xC8, 0xBE, 0x02, 0x7E,
231 0x96, 0x69, 0xE0, 0x04, 0xCB, 0x89, 0x0B, 0x42
232 };
233
234 # ifndef OPENSSL_NO_ECX
235 static const unsigned char kExampleECXKey2DER[] = {
236 0x30, 0x2E, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x6e,
237 0x04, 0x22, 0x04, 0x20, 0xc8, 0xa9, 0xd5, 0xa9, 0x10, 0x91, 0xad, 0x85,
238 0x1c, 0x66, 0x8b, 0x07, 0x36, 0xc1, 0xc9, 0xa0, 0x29, 0x36, 0xc0, 0xd3,
239 0xad, 0x62, 0x67, 0x08, 0x58, 0x08, 0x80, 0x47, 0xba, 0x05, 0x74, 0x75
240 };
241 # endif
242 #endif
243
244 typedef struct APK_DATA_st {
245 const unsigned char *kder;
246 size_t size;
247 int evptype;
248 } APK_DATA;
249
250 static APK_DATA keydata[] = {
251 {kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER), EVP_PKEY_RSA},
252 {kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8), EVP_PKEY_RSA},
253 #ifndef OPENSSL_NO_EC
254 # ifndef OPENSSL_NO_ECX
255 {kExampleECXKey2DER, sizeof(kExampleECXKey2DER), EVP_PKEY_X25519},
256 # endif
257 {kExampleECKeyDER, sizeof(kExampleECKeyDER), EVP_PKEY_EC},
258 {kExampleECKey2DER, sizeof(kExampleECKey2DER), EVP_PKEY_EC},
259 #endif
260 #ifndef OPENSSL_NO_DH
261 {kExampleDHPrivateKeyDER, sizeof(kExampleDHPrivateKeyDER), EVP_PKEY_DH},
262 #endif
263 };
264
pkey_has_private(EVP_PKEY * key,const char * privtag,int use_octstring)265 static int pkey_has_private(EVP_PKEY *key, const char *privtag,
266 int use_octstring)
267 {
268 int ret = 0;
269
270 if (use_octstring) {
271 unsigned char buf[64];
272
273 ret = EVP_PKEY_get_octet_string_param(key, privtag, buf, sizeof(buf),
274 NULL);
275 } else {
276 BIGNUM *bn = NULL;
277
278 ret = EVP_PKEY_get_bn_param(key, privtag, &bn);
279 BN_free(bn);
280 }
281 return ret;
282 }
283
do_pkey_tofrom_data_select(EVP_PKEY * key,const char * keytype)284 static int do_pkey_tofrom_data_select(EVP_PKEY *key, const char *keytype)
285 {
286 int ret = 0;
287 OSSL_PARAM *pub_params = NULL, *keypair_params = NULL;
288 EVP_PKEY *fromkey = NULL, *fromkeypair = NULL;
289 EVP_PKEY_CTX *fromctx = NULL;
290 const char *privtag = strcmp(keytype, "RSA") == 0 ? "d" : "priv";
291 const int use_octstring = strcmp(keytype, "X25519") == 0;
292
293 /*
294 * Select only the public key component when using EVP_PKEY_todata() and
295 * check that the resulting param array does not contain a private key.
296 */
297 if (!TEST_int_eq(EVP_PKEY_todata(key, EVP_PKEY_PUBLIC_KEY, &pub_params), 1)
298 || !TEST_ptr_null(OSSL_PARAM_locate(pub_params, privtag)))
299 goto end;
300 /*
301 * Select the keypair when using EVP_PKEY_todata() and check that
302 * the param array contains a private key.
303 */
304 if (!TEST_int_eq(EVP_PKEY_todata(key, EVP_PKEY_KEYPAIR, &keypair_params), 1)
305 || !TEST_ptr(OSSL_PARAM_locate(keypair_params, privtag)))
306 goto end;
307
308 /*
309 * Select only the public key when using EVP_PKEY_fromdata() and check that
310 * the resulting key does not contain a private key.
311 */
312 if (!TEST_ptr(fromctx = EVP_PKEY_CTX_new_from_name(mainctx, keytype, NULL))
313 || !TEST_int_eq(EVP_PKEY_fromdata_init(fromctx), 1)
314 || !TEST_int_eq(EVP_PKEY_fromdata(fromctx, &fromkey, EVP_PKEY_PUBLIC_KEY,
315 keypair_params), 1)
316 || !TEST_false(pkey_has_private(fromkey, privtag, use_octstring)))
317 goto end;
318 /*
319 * Select the keypair when using EVP_PKEY_fromdata() and check that
320 * the resulting key contains a private key.
321 */
322 if (!TEST_int_eq(EVP_PKEY_fromdata(fromctx, &fromkeypair,
323 EVP_PKEY_KEYPAIR, keypair_params), 1)
324 || !TEST_true(pkey_has_private(fromkeypair, privtag, use_octstring)))
325 goto end;
326 ret = 1;
327 end:
328 EVP_PKEY_free(fromkeypair);
329 EVP_PKEY_free(fromkey);
330 EVP_PKEY_CTX_free(fromctx);
331 OSSL_PARAM_free(keypair_params);
332 OSSL_PARAM_free(pub_params);
333 return ret;
334 }
335
336 #ifndef OPENSSL_NO_DH
test_dh_tofrom_data_select(void)337 static int test_dh_tofrom_data_select(void)
338 {
339 int ret;
340 OSSL_PARAM params[2];
341 EVP_PKEY *key = NULL;
342 EVP_PKEY_CTX *gctx = NULL;
343 # ifndef OPENSSL_NO_DEPRECATED_3_0
344 const DH *dhkey;
345 const BIGNUM *privkey;
346 # endif
347
348 params[0] = OSSL_PARAM_construct_utf8_string("group", "ffdhe2048", 0);
349 params[1] = OSSL_PARAM_construct_end();
350 ret = TEST_ptr(gctx = EVP_PKEY_CTX_new_from_name(mainctx, "DHX", NULL))
351 && TEST_int_gt(EVP_PKEY_keygen_init(gctx), 0)
352 && TEST_true(EVP_PKEY_CTX_set_params(gctx, params))
353 && TEST_int_gt(EVP_PKEY_generate(gctx, &key), 0)
354 && TEST_true(do_pkey_tofrom_data_select(key, "DHX"));
355 # ifndef OPENSSL_NO_DEPRECATED_3_0
356 ret = ret && TEST_ptr(dhkey = EVP_PKEY_get0_DH(key))
357 && TEST_ptr(privkey = DH_get0_priv_key(dhkey))
358 && TEST_int_le(BN_num_bits(privkey), 225);
359 # endif
360 EVP_PKEY_free(key);
361 EVP_PKEY_CTX_free(gctx);
362 return ret;
363 }
364
test_dh_paramgen(void)365 static int test_dh_paramgen(void)
366 {
367 int ret;
368 OSSL_PARAM params[3];
369 EVP_PKEY *pkey = NULL;
370 EVP_PKEY_CTX *gctx = NULL;
371 unsigned int pbits = 512; /* minimum allowed for speed */
372
373 params[0] = OSSL_PARAM_construct_uint(OSSL_PKEY_PARAM_FFC_PBITS, &pbits);
374 params[1] = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_FFC_TYPE,
375 "generator", 0);
376 params[2] = OSSL_PARAM_construct_end();
377
378 ret = TEST_ptr(gctx = EVP_PKEY_CTX_new_from_name(mainctx, "DH", NULL))
379 && TEST_int_gt(EVP_PKEY_paramgen_init(gctx), 0)
380 && TEST_true(EVP_PKEY_CTX_set_params(gctx, params))
381 && TEST_true(EVP_PKEY_paramgen(gctx, &pkey))
382 && TEST_ptr(pkey);
383
384 EVP_PKEY_CTX_free(gctx);
385 gctx = NULL;
386
387 ret = ret && TEST_ptr(gctx = EVP_PKEY_CTX_new_from_pkey(mainctx, pkey, NULL))
388 && TEST_int_eq(EVP_PKEY_param_check(gctx), 1)
389 && TEST_int_eq(EVP_PKEY_param_check_quick(gctx), 1);
390
391 EVP_PKEY_CTX_free(gctx);
392 EVP_PKEY_free(pkey);
393 return ret;
394 }
395
set_fromdata_string(EVP_PKEY_CTX * ctx,const char * name,char * value)396 static int set_fromdata_string(EVP_PKEY_CTX *ctx, const char *name, char *value)
397 {
398 int ret;
399 OSSL_PARAM params[2];
400 EVP_PKEY *pkey = NULL;
401
402 if (EVP_PKEY_fromdata_init(ctx) != 1)
403 return -1;
404 params[0] = OSSL_PARAM_construct_utf8_string(name, value, 0);
405 params[1] = OSSL_PARAM_construct_end();
406 ret = EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_KEY_PARAMETERS, params);
407 EVP_PKEY_free(pkey);
408 return ret;
409 }
410
set_fromdata_uint(EVP_PKEY_CTX * ctx,const char * name)411 static int set_fromdata_uint(EVP_PKEY_CTX *ctx, const char *name)
412 {
413 int ret;
414 unsigned int tmp = 0;
415 OSSL_PARAM params[2];
416 EVP_PKEY *pkey = NULL;
417
418 if (EVP_PKEY_fromdata_init(ctx) != 1)
419 return -1;
420 params[0] = OSSL_PARAM_construct_uint(name, &tmp);
421 params[1] = OSSL_PARAM_construct_end();
422 ret = EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_KEY_PARAMETERS, params);
423 EVP_PKEY_free(pkey);
424 return ret;
425 }
426
test_dh_paramfromdata(void)427 static int test_dh_paramfromdata(void)
428 {
429 EVP_PKEY_CTX *ctx = NULL;
430 int ret = 0;
431
432 /* Test failure paths for FFC - mainly due to setting the wrong param type */
433 ret = TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(mainctx, "DH", NULL))
434 && TEST_int_eq(set_fromdata_uint(ctx, OSSL_PKEY_PARAM_GROUP_NAME), 0)
435 && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_GROUP_NAME, "bad"), 0)
436 && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_P, "bad"), 0)
437 && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_GINDEX, "bad"), 0)
438 && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_PCOUNTER, "bad"), 0)
439 && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_COFACTOR, "bad"), 0)
440 && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_H, "bad"), 0)
441 && TEST_int_eq(set_fromdata_uint(ctx, OSSL_PKEY_PARAM_FFC_SEED), 0)
442 && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_VALIDATE_PQ, "bad"), 0)
443 && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_VALIDATE_G, "bad"), 0)
444 && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_VALIDATE_LEGACY, "bad"), 0)
445 && TEST_int_eq(set_fromdata_uint(ctx, OSSL_PKEY_PARAM_FFC_DIGEST), 0);
446
447 EVP_PKEY_CTX_free(ctx);
448 return ret;
449 }
450
451 #endif
452
453 #ifndef OPENSSL_NO_EC
454
test_ec_d2i_i2d_pubkey(void)455 static int test_ec_d2i_i2d_pubkey(void)
456 {
457 int ret = 0;
458 FILE *fp = NULL;
459 EVP_PKEY *key = NULL, *outkey = NULL;
460 static const char *filename = "pubkey.der";
461
462 if (!TEST_ptr(fp = fopen(filename, "wb"))
463 || !TEST_ptr(key = EVP_PKEY_Q_keygen(mainctx, NULL, "EC", "P-256"))
464 || !TEST_true(i2d_PUBKEY_fp(fp, key))
465 || !TEST_int_eq(fclose(fp), 0))
466 goto err;
467 fp = NULL;
468
469 if (!TEST_ptr(fp = fopen(filename, "rb"))
470 || !TEST_ptr(outkey = d2i_PUBKEY_ex_fp(fp, NULL, mainctx, NULL))
471 || !TEST_int_eq(EVP_PKEY_eq(key, outkey), 1))
472 goto err;
473
474 ret = 1;
475
476 err:
477 EVP_PKEY_free(outkey);
478 EVP_PKEY_free(key);
479 fclose(fp);
480 return ret;
481 }
482
test_ec_tofrom_data_select(void)483 static int test_ec_tofrom_data_select(void)
484 {
485 int ret;
486 EVP_PKEY *key = NULL;
487
488 ret = TEST_ptr(key = EVP_PKEY_Q_keygen(mainctx, NULL, "EC", "P-256"))
489 && TEST_true(do_pkey_tofrom_data_select(key, "EC"));
490 EVP_PKEY_free(key);
491 return ret;
492 }
493
494 # ifndef OPENSSL_NO_ECX
test_ecx_tofrom_data_select(void)495 static int test_ecx_tofrom_data_select(void)
496 {
497 int ret;
498 EVP_PKEY *key = NULL;
499
500 ret = TEST_ptr(key = EVP_PKEY_Q_keygen(mainctx, NULL, "X25519"))
501 && TEST_true(do_pkey_tofrom_data_select(key, "X25519"));
502 EVP_PKEY_free(key);
503 return ret;
504 }
505 # endif
506 #endif
507
508 #ifndef OPENSSL_NO_SM2
test_sm2_tofrom_data_select(void)509 static int test_sm2_tofrom_data_select(void)
510 {
511 int ret;
512 EVP_PKEY *key = NULL;
513
514 ret = TEST_ptr(key = EVP_PKEY_Q_keygen(mainctx, NULL, "SM2"))
515 && TEST_true(do_pkey_tofrom_data_select(key, "SM2"));
516 EVP_PKEY_free(key);
517 return ret;
518 }
519 #endif
520
test_rsa_tofrom_data_select(void)521 static int test_rsa_tofrom_data_select(void)
522 {
523 int ret;
524 EVP_PKEY *key = NULL;
525 const unsigned char *pdata = kExampleRSAKeyDER;
526 int pdata_len = sizeof(kExampleRSAKeyDER);
527
528 ret = TEST_ptr(key = d2i_AutoPrivateKey_ex(NULL, &pdata, pdata_len,
529 mainctx, NULL))
530 && TEST_true(do_pkey_tofrom_data_select(key, "RSA"));
531 EVP_PKEY_free(key);
532 return ret;
533 }
534
535 /* This is the equivalent of test_d2i_AutoPrivateKey in evp_extra_test */
test_d2i_AutoPrivateKey_ex(int i)536 static int test_d2i_AutoPrivateKey_ex(int i)
537 {
538 int ret = 0;
539 const unsigned char *p;
540 EVP_PKEY *pkey = NULL;
541 const APK_DATA *ak = &keydata[i];
542 const unsigned char *input = ak->kder;
543 size_t input_len = ak->size;
544 int expected_id = ak->evptype;
545 BIGNUM *p_bn = NULL;
546 BIGNUM *g_bn = NULL;
547 BIGNUM *priv_bn = NULL;
548
549 p = input;
550 if (!TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &p, input_len, mainctx,
551 NULL))
552 || !TEST_ptr_eq(p, input + input_len)
553 || !TEST_int_eq(EVP_PKEY_get_id(pkey), expected_id))
554 goto done;
555
556 if (ak->evptype == EVP_PKEY_RSA) {
557 if (!TEST_true(EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_RSA_D,
558 &priv_bn)))
559 goto done;
560 } else if (ak->evptype == EVP_PKEY_X25519) {
561 unsigned char buffer[32];
562 size_t len;
563
564 if (!TEST_true(EVP_PKEY_get_octet_string_param(pkey,
565 OSSL_PKEY_PARAM_PRIV_KEY,
566 buffer, sizeof(buffer),
567 &len)))
568 goto done;
569 } else {
570 if (!TEST_true(EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_PRIV_KEY,
571 &priv_bn)))
572 goto done;
573 }
574
575 if (ak->evptype == EVP_PKEY_DH) {
576 if (!TEST_true(EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_FFC_P, &p_bn))
577 || !TEST_true(EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_FFC_G,
578 &g_bn)))
579 goto done;
580 }
581
582 ret = 1;
583 done:
584 BN_free(p_bn);
585 BN_free(g_bn);
586 BN_free(priv_bn);
587 EVP_PKEY_free(pkey);
588 return ret;
589 }
590
591 #ifndef OPENSSL_NO_DES
test_pkcs8key_nid_bio(void)592 static int test_pkcs8key_nid_bio(void)
593 {
594 int ret;
595 const int nid = NID_pbe_WithSHA1And3_Key_TripleDES_CBC;
596 static const char pwd[] = "PASSWORD";
597 EVP_PKEY *pkey = NULL, *pkey_dec = NULL;
598 BIO *in = NULL, *enc_bio = NULL;
599 char *enc_data = NULL;
600 long enc_datalen = 0;
601 OSSL_PROVIDER *provider = NULL;
602
603 ret = TEST_ptr(provider = OSSL_PROVIDER_load(NULL, "default"))
604 && TEST_ptr(enc_bio = BIO_new(BIO_s_mem()))
605 && TEST_ptr(in = BIO_new_mem_buf(kExampleRSAKeyPKCS8,
606 sizeof(kExampleRSAKeyPKCS8)))
607 && TEST_ptr(pkey = d2i_PrivateKey_ex_bio(in, NULL, NULL, NULL))
608 && TEST_int_eq(i2d_PKCS8PrivateKey_nid_bio(enc_bio, pkey, nid,
609 pwd, sizeof(pwd) - 1,
610 NULL, NULL), 1)
611 && TEST_int_gt(enc_datalen = BIO_get_mem_data(enc_bio, &enc_data), 0)
612 && TEST_ptr(pkey_dec = d2i_PKCS8PrivateKey_bio(enc_bio, NULL, NULL,
613 (void *)pwd))
614 && TEST_true(EVP_PKEY_eq(pkey, pkey_dec));
615
616 EVP_PKEY_free(pkey_dec);
617 EVP_PKEY_free(pkey);
618 BIO_free(in);
619 BIO_free(enc_bio);
620 OSSL_PROVIDER_unload(provider);
621 return ret;
622 }
623 #endif /* OPENSSL_NO_DES */
624
test_alternative_default(void)625 static int test_alternative_default(void)
626 {
627 OSSL_LIB_CTX *oldctx;
628 EVP_MD *sha256;
629 int ok = 0;
630
631 /*
632 * setup_tests() loaded the "null" provider in the current default, so
633 * we know this fetch should fail.
634 */
635 if (!TEST_ptr_null(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
636 goto err;
637
638 /*
639 * Now we switch to our main library context, and try again. Since no
640 * providers are loaded in this one, it should fall back to the default.
641 */
642 if (!TEST_ptr(oldctx = OSSL_LIB_CTX_set0_default(mainctx))
643 || !TEST_ptr(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
644 goto err;
645 EVP_MD_free(sha256);
646 sha256 = NULL;
647
648 /*
649 * Switching back should give us our main library context back, and
650 * fetching SHA2-256 should fail again.
651 */
652 if (!TEST_ptr_eq(OSSL_LIB_CTX_set0_default(oldctx), mainctx)
653 || !TEST_ptr_null(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
654 goto err;
655
656 ok = 1;
657 err:
658 EVP_MD_free(sha256);
659 return ok;
660 }
661
test_provider_unload_effective(int testid)662 static int test_provider_unload_effective(int testid)
663 {
664 EVP_MD *sha256 = NULL;
665 OSSL_PROVIDER *provider = NULL;
666 int ok = 0;
667
668 if (!TEST_ptr(provider = OSSL_PROVIDER_load(NULL, "default"))
669 || !TEST_ptr(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
670 goto err;
671
672 if (testid > 0) {
673 OSSL_PROVIDER_unload(provider);
674 provider = NULL;
675 EVP_MD_free(sha256);
676 sha256 = NULL;
677 } else {
678 EVP_MD_free(sha256);
679 sha256 = NULL;
680 OSSL_PROVIDER_unload(provider);
681 provider = NULL;
682 }
683
684 /*
685 * setup_tests() loaded the "null" provider in the current default, and
686 * we unloaded it above after the load so we know this fetch should fail.
687 */
688 if (!TEST_ptr_null(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
689 goto err;
690
691 ok = 1;
692 err:
693 EVP_MD_free(sha256);
694 OSSL_PROVIDER_unload(provider);
695 return ok;
696 }
697
test_d2i_PrivateKey_ex(int testid)698 static int test_d2i_PrivateKey_ex(int testid)
699 {
700 int ok = 0;
701 OSSL_PROVIDER *provider = NULL;
702 BIO *key_bio = NULL;
703 EVP_PKEY *pkey = NULL;
704 int id = (testid == 0) ? 0 : 2;
705
706 if (!TEST_ptr(provider = OSSL_PROVIDER_load(NULL, "default")))
707 goto err;
708 if (!TEST_ptr(key_bio = BIO_new_mem_buf(keydata[id].kder, keydata[id].size)))
709 goto err;
710 if (!TEST_ptr_null(pkey = PEM_read_bio_PrivateKey(key_bio, NULL, NULL, NULL)))
711 goto err;
712
713 ERR_clear_error();
714 if (!TEST_int_ge(BIO_seek(key_bio, 0), 0))
715 goto err;
716 ok = TEST_ptr(pkey = d2i_PrivateKey_bio(key_bio, NULL));
717 TEST_int_eq(ERR_peek_error(), 0);
718 test_openssl_errors();
719
720 err:
721 EVP_PKEY_free(pkey);
722 BIO_free(key_bio);
723 OSSL_PROVIDER_unload(provider);
724
725 return ok;
726 }
727
test_PEM_read_bio_negative(int testid)728 static int test_PEM_read_bio_negative(int testid)
729 {
730 int ok = 0;
731 OSSL_PROVIDER *provider = NULL;
732 BIO *key_bio = NULL;
733 EVP_PKEY *pkey = NULL;
734
735 if (!TEST_ptr(key_bio = BIO_new_mem_buf(keydata[testid].kder, keydata[testid].size)))
736 goto err;
737 ERR_clear_error();
738 if (!TEST_ptr_null(pkey = PEM_read_bio_PrivateKey(key_bio, NULL, NULL, NULL)))
739 goto err;
740 if (!TEST_int_ne(ERR_peek_error(), 0))
741 goto err;
742 if (!TEST_ptr(provider = OSSL_PROVIDER_load(NULL, "default")))
743 goto err;
744 if (!TEST_int_ge(BIO_seek(key_bio, 0), 0))
745 goto err;
746 ERR_clear_error();
747 if (!TEST_ptr_null(pkey = PEM_read_bio_PrivateKey(key_bio, NULL, NULL, NULL)))
748 goto err;
749 if (!TEST_int_ne(ERR_peek_error(), 0))
750 goto err;
751
752 ok = 1;
753
754 err:
755 test_openssl_errors();
756 EVP_PKEY_free(pkey);
757 BIO_free(key_bio);
758 OSSL_PROVIDER_unload(provider);
759
760 return ok;
761 }
762
test_PEM_read_bio_negative_wrong_password(int testid)763 static int test_PEM_read_bio_negative_wrong_password(int testid)
764 {
765 int ok = 0;
766 OSSL_PROVIDER *provider = OSSL_PROVIDER_load(NULL, "default");
767 EVP_PKEY *read_pkey = NULL;
768 EVP_PKEY *write_pkey = EVP_RSA_gen(1024);
769 BIO *key_bio = BIO_new(BIO_s_mem());
770 const UI_METHOD *undo_ui_method = NULL;
771 const UI_METHOD *ui_method = NULL;
772 if (testid > 0)
773 ui_method = UI_null();
774
775 if (!TEST_ptr(provider))
776 goto err;
777 if (!TEST_ptr(key_bio))
778 goto err;
779 if (!TEST_ptr(write_pkey))
780 goto err;
781 undo_ui_method = UI_get_default_method();
782 UI_set_default_method(ui_method);
783
784 if (/* Output Encrypted private key in PEM form */
785 !TEST_true(PEM_write_bio_PrivateKey(key_bio, write_pkey, EVP_aes_256_cbc(),
786 NULL, 0, NULL, "pass")))
787 goto err;
788
789 ERR_clear_error();
790 read_pkey = PEM_read_bio_PrivateKey(key_bio, NULL, NULL, NULL);
791 if (!TEST_ptr_null(read_pkey))
792 goto err;
793
794 if (!TEST_int_eq(ERR_GET_REASON(ERR_get_error()), PEM_R_PROBLEMS_GETTING_PASSWORD))
795 goto err;
796 ok = 1;
797
798 err:
799 test_openssl_errors();
800 EVP_PKEY_free(read_pkey);
801 EVP_PKEY_free(write_pkey);
802 BIO_free(key_bio);
803 OSSL_PROVIDER_unload(provider);
804 UI_set_default_method(undo_ui_method);
805
806 return ok;
807 }
808
do_fromdata_key_is_equal(const OSSL_PARAM params[],const EVP_PKEY * expected,const char * type)809 static int do_fromdata_key_is_equal(const OSSL_PARAM params[],
810 const EVP_PKEY *expected, const char *type)
811 {
812 EVP_PKEY_CTX *ctx = NULL;
813 EVP_PKEY *pkey = NULL;
814 int ret;
815
816 ret = TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(mainctx, type, NULL))
817 && TEST_int_eq(EVP_PKEY_fromdata_init(ctx), 1)
818 && TEST_int_eq(EVP_PKEY_fromdata(ctx, &pkey,
819 EVP_PKEY_KEYPAIR,
820 (OSSL_PARAM *)params), 1)
821 && TEST_true(EVP_PKEY_eq(pkey, expected));
822 EVP_PKEY_CTX_free(ctx);
823 EVP_PKEY_free(pkey);
824 return ret;
825 }
826
827 #ifndef OPENSSL_NO_DSA
828 /*
829 * This data was generated using:
830 * > openssl genpkey \
831 * -genparam -algorithm DSA -pkeyopt type:fips186_4 -text \
832 * -pkeyopt gindex:5 -out dsa_param.pem
833 * > openssl genpkey \
834 * -paramfile dsa_param.pem -pkeyopt type:fips186_4 -out dsa_priv.pem
835 */
836 static const unsigned char dsa_key[] = {
837 0x30, 0x82, 0x03, 0x4e, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x01, 0x00,
838 0xda, 0xb3, 0x46, 0x4d, 0x54, 0x57, 0xc7, 0xb4, 0x61, 0xa0, 0x6f, 0x66,
839 0x17, 0xda, 0xeb, 0x90, 0xf0, 0xa3, 0xd1, 0x29, 0xc9, 0x5f, 0xf2, 0x21,
840 0x3d, 0x85, 0xa3, 0x4a, 0xf0, 0xf8, 0x36, 0x39, 0x1b, 0xe3, 0xee, 0x37,
841 0x70, 0x06, 0x9b, 0xe8, 0xe3, 0x0a, 0xd2, 0xf1, 0xf6, 0xc4, 0x42, 0x23,
842 0x1f, 0x74, 0x78, 0xc2, 0x16, 0xf5, 0xce, 0xd6, 0xab, 0xa0, 0xc6, 0xe8,
843 0x99, 0x3d, 0xf8, 0x8b, 0xfb, 0x47, 0xf8, 0x5e, 0x05, 0x68, 0x6d, 0x8b,
844 0xa8, 0xad, 0xa1, 0xc2, 0x3a, 0x4e, 0xe0, 0xad, 0xec, 0x38, 0x75, 0x21,
845 0x55, 0x22, 0xce, 0xa2, 0xe9, 0xe5, 0x3b, 0xd7, 0x44, 0xeb, 0x5a, 0x03,
846 0x59, 0xa0, 0xc5, 0x7a, 0x92, 0x59, 0x7d, 0x7a, 0x07, 0x80, 0xfc, 0x4e,
847 0xf8, 0x56, 0x7e, 0xf1, 0x06, 0xe0, 0xba, 0xb2, 0xe7, 0x5b, 0x22, 0x55,
848 0xee, 0x4b, 0x42, 0x61, 0x67, 0x2c, 0x43, 0x9a, 0x38, 0x2b, 0x17, 0xc2,
849 0x62, 0x12, 0x8b, 0x0b, 0x22, 0x8c, 0x0c, 0x1c, 0x1c, 0x92, 0xb1, 0xec,
850 0x70, 0xce, 0x0f, 0x8c, 0xff, 0x8d, 0x21, 0xf9, 0x19, 0x68, 0x4d, 0x32,
851 0x59, 0x78, 0x42, 0x1d, 0x0c, 0xc5, 0x1a, 0xcb, 0x28, 0xe2, 0xc1, 0x1a,
852 0x35, 0xf1, 0x42, 0x0a, 0x19, 0x39, 0xfa, 0x83, 0xd1, 0xb4, 0xaa, 0x69,
853 0x0f, 0xc2, 0x8e, 0xf9, 0x59, 0x2c, 0xee, 0x11, 0xfc, 0x3e, 0x4b, 0x44,
854 0xfb, 0x9a, 0x32, 0xc8, 0x78, 0x23, 0x56, 0x85, 0x49, 0x21, 0x43, 0x12,
855 0x79, 0xbd, 0xa0, 0x70, 0x47, 0x2f, 0xae, 0xb6, 0xd7, 0x6c, 0xc6, 0x07,
856 0x76, 0xa9, 0x8a, 0xa2, 0x16, 0x02, 0x89, 0x1f, 0x1a, 0xd1, 0xa2, 0x96,
857 0x56, 0xd1, 0x1f, 0x10, 0xe1, 0xe5, 0x9f, 0x3f, 0xdd, 0x09, 0x0c, 0x40,
858 0x90, 0x71, 0xef, 0x14, 0x41, 0x02, 0x82, 0x3a, 0x6b, 0xe1, 0xf8, 0x2c,
859 0x5d, 0xbe, 0xfd, 0x1b, 0x02, 0x1d, 0x00, 0xe0, 0x20, 0xe0, 0x7c, 0x02,
860 0x16, 0xa7, 0x6c, 0x6a, 0x19, 0xba, 0xd5, 0x83, 0x73, 0xf3, 0x7d, 0x31,
861 0xef, 0xa7, 0xe1, 0x5d, 0x5b, 0x7f, 0xf3, 0xfc, 0xda, 0x84, 0x31, 0x02,
862 0x82, 0x01, 0x01, 0x00, 0x83, 0xdb, 0xa1, 0xbc, 0x3e, 0xc7, 0x29, 0xa5,
863 0x6a, 0x5c, 0x2c, 0xe8, 0x7a, 0x8c, 0x7e, 0xe8, 0xb8, 0x3e, 0x13, 0x47,
864 0xcd, 0x36, 0x7e, 0x79, 0x30, 0x7a, 0x28, 0x03, 0xd3, 0xd4, 0xd2, 0xe3,
865 0xee, 0x3b, 0x46, 0xda, 0xe0, 0x71, 0xe6, 0xcf, 0x46, 0x86, 0x0a, 0x37,
866 0x57, 0xb6, 0xe9, 0xcf, 0xa1, 0x78, 0x19, 0xb8, 0x72, 0x9f, 0x30, 0x8c,
867 0x2a, 0x04, 0x7c, 0x2f, 0x0c, 0x27, 0xa7, 0xb3, 0x23, 0xe0, 0x46, 0xf2,
868 0x75, 0x0c, 0x03, 0x4c, 0xad, 0xfb, 0xc1, 0xcb, 0x28, 0xcd, 0xa0, 0x63,
869 0xdb, 0x44, 0x88, 0xe0, 0xda, 0x6c, 0x5b, 0x89, 0xb2, 0x5b, 0x40, 0x6d,
870 0xeb, 0x78, 0x7a, 0xd5, 0xaf, 0x40, 0x52, 0x46, 0x63, 0x92, 0x13, 0x0d,
871 0xee, 0xee, 0xf9, 0x53, 0xca, 0x2d, 0x4e, 0x3b, 0x13, 0xd8, 0x0f, 0x50,
872 0xd0, 0x44, 0x57, 0x67, 0x0f, 0x45, 0x8f, 0x21, 0x30, 0x97, 0x9e, 0x80,
873 0xd9, 0xd0, 0x91, 0xb7, 0xc9, 0x5a, 0x69, 0xda, 0xeb, 0xd5, 0xea, 0x37,
874 0xf6, 0xb3, 0xbe, 0x1f, 0x24, 0xf1, 0x55, 0x14, 0x28, 0x05, 0xb5, 0xd8,
875 0x84, 0x0f, 0x62, 0x85, 0xaa, 0xec, 0x77, 0x64, 0xfd, 0x80, 0x7c, 0x41,
876 0x00, 0x88, 0xa3, 0x79, 0x7d, 0x4f, 0x6f, 0xe3, 0x76, 0xf4, 0xb5, 0x97,
877 0xb7, 0xeb, 0x67, 0x28, 0xba, 0x07, 0x1a, 0x59, 0x32, 0xc1, 0x53, 0xd9,
878 0x05, 0x6b, 0x63, 0x93, 0xce, 0xa1, 0xd9, 0x7a, 0xb2, 0xff, 0x1c, 0x12,
879 0x0a, 0x9a, 0xe5, 0x51, 0x1e, 0xba, 0xfc, 0x95, 0x2e, 0x28, 0xa9, 0xfc,
880 0x4c, 0xed, 0x7b, 0x05, 0xca, 0x67, 0xe0, 0x2d, 0xd7, 0x54, 0xb3, 0x05,
881 0x1c, 0x23, 0x2b, 0x35, 0x2e, 0x19, 0x48, 0x59, 0x0e, 0x58, 0xa8, 0x01,
882 0x56, 0xfb, 0x78, 0x90, 0xba, 0x08, 0x77, 0x94, 0x45, 0x05, 0x13, 0xc7,
883 0x6b, 0x96, 0xd2, 0xa3, 0xa6, 0x01, 0x9f, 0x34, 0x02, 0x82, 0x01, 0x00,
884 0x16, 0x1a, 0xb4, 0x6d, 0x9f, 0x16, 0x6c, 0xcc, 0x91, 0x66, 0xfe, 0x30,
885 0xeb, 0x8e, 0x44, 0xba, 0x2b, 0x7a, 0xc9, 0xa8, 0x95, 0xf2, 0xa6, 0x38,
886 0xd8, 0xaf, 0x3e, 0x91, 0x68, 0xe8, 0x52, 0xf3, 0x97, 0x37, 0x70, 0xf2,
887 0x47, 0xa3, 0xf4, 0x62, 0x26, 0xf5, 0x3b, 0x71, 0x52, 0x50, 0x15, 0x9c,
888 0x6d, 0xa6, 0x6d, 0x92, 0x4c, 0x48, 0x76, 0x31, 0x54, 0x48, 0xa5, 0x99,
889 0x7a, 0xd4, 0x61, 0xf7, 0x21, 0x44, 0xe7, 0xd8, 0x82, 0xc3, 0x50, 0xd3,
890 0xd9, 0xd4, 0x66, 0x20, 0xab, 0x70, 0x4c, 0x97, 0x9b, 0x8d, 0xac, 0x1f,
891 0x78, 0x27, 0x1e, 0x47, 0xf8, 0x3b, 0xd1, 0x55, 0x73, 0xf3, 0xb4, 0x8e,
892 0x6d, 0x45, 0x40, 0x54, 0xc6, 0xd8, 0x95, 0x15, 0x27, 0xb7, 0x5f, 0x65,
893 0xaa, 0xcb, 0x24, 0xc9, 0x49, 0x87, 0x32, 0xad, 0xcb, 0xf8, 0x35, 0x63,
894 0x56, 0x72, 0x7c, 0x4e, 0x6c, 0xad, 0x5f, 0x26, 0x8c, 0xd2, 0x80, 0x41,
895 0xaf, 0x88, 0x23, 0x20, 0x03, 0xa4, 0xd5, 0x3c, 0x53, 0x54, 0xb0, 0x3d,
896 0xed, 0x0e, 0x9e, 0x53, 0x0a, 0x63, 0x5f, 0xfd, 0x28, 0x57, 0x09, 0x07,
897 0x73, 0xf4, 0x0c, 0xd4, 0x71, 0x5d, 0x6b, 0xa0, 0xd7, 0x86, 0x99, 0x29,
898 0x9b, 0xca, 0xfb, 0xcc, 0xd6, 0x2f, 0xfe, 0xbe, 0x94, 0xef, 0x1a, 0x0e,
899 0x55, 0x84, 0xa7, 0xaf, 0x7b, 0xfa, 0xed, 0x77, 0x61, 0x28, 0x22, 0xee,
900 0x6b, 0x11, 0xdd, 0xb0, 0x17, 0x1e, 0x06, 0xe4, 0x29, 0x4c, 0xc2, 0x3f,
901 0xd6, 0x75, 0xb6, 0x08, 0x04, 0x55, 0x13, 0x48, 0x4f, 0x44, 0xea, 0x8d,
902 0xaf, 0xcb, 0xac, 0x22, 0xc4, 0x6a, 0xb3, 0x86, 0xe5, 0x47, 0xa9, 0xb5,
903 0x72, 0x17, 0x23, 0x11, 0x81, 0x7f, 0x00, 0x00, 0x67, 0x5c, 0xf4, 0x58,
904 0xcc, 0xe2, 0x46, 0xce, 0xf5, 0x6d, 0xd8, 0x18, 0x91, 0xc4, 0x20, 0xbf,
905 0x07, 0x48, 0x45, 0xfd, 0x02, 0x1c, 0x2f, 0x68, 0x44, 0xcb, 0xfb, 0x6b,
906 0xcb, 0x8d, 0x02, 0x49, 0x7c, 0xee, 0xd2, 0xa6, 0xd3, 0x43, 0xb8, 0xa4,
907 0x09, 0xb7, 0xc1, 0xd4, 0x4b, 0xc3, 0x66, 0xa7, 0xe0, 0x21,
908 };
909 static const unsigned char dsa_p[] = {
910 0x00, 0xda, 0xb3, 0x46, 0x4d, 0x54, 0x57, 0xc7, 0xb4, 0x61, 0xa0, 0x6f, 0x66, 0x17, 0xda,
911 0xeb, 0x90, 0xf0, 0xa3, 0xd1, 0x29, 0xc9, 0x5f, 0xf2, 0x21, 0x3d, 0x85, 0xa3, 0x4a, 0xf0,
912 0xf8, 0x36, 0x39, 0x1b, 0xe3, 0xee, 0x37, 0x70, 0x06, 0x9b, 0xe8, 0xe3, 0x0a, 0xd2, 0xf1,
913 0xf6, 0xc4, 0x42, 0x23, 0x1f, 0x74, 0x78, 0xc2, 0x16, 0xf5, 0xce, 0xd6, 0xab, 0xa0, 0xc6,
914 0xe8, 0x99, 0x3d, 0xf8, 0x8b, 0xfb, 0x47, 0xf8, 0x5e, 0x05, 0x68, 0x6d, 0x8b, 0xa8, 0xad,
915 0xa1, 0xc2, 0x3a, 0x4e, 0xe0, 0xad, 0xec, 0x38, 0x75, 0x21, 0x55, 0x22, 0xce, 0xa2, 0xe9,
916 0xe5, 0x3b, 0xd7, 0x44, 0xeb, 0x5a, 0x03, 0x59, 0xa0, 0xc5, 0x7a, 0x92, 0x59, 0x7d, 0x7a,
917 0x07, 0x80, 0xfc, 0x4e, 0xf8, 0x56, 0x7e, 0xf1, 0x06, 0xe0, 0xba, 0xb2, 0xe7, 0x5b, 0x22,
918 0x55, 0xee, 0x4b, 0x42, 0x61, 0x67, 0x2c, 0x43, 0x9a, 0x38, 0x2b, 0x17, 0xc2, 0x62, 0x12,
919 0x8b, 0x0b, 0x22, 0x8c, 0x0c, 0x1c, 0x1c, 0x92, 0xb1, 0xec, 0x70, 0xce, 0x0f, 0x8c, 0xff,
920 0x8d, 0x21, 0xf9, 0x19, 0x68, 0x4d, 0x32, 0x59, 0x78, 0x42, 0x1d, 0x0c, 0xc5, 0x1a, 0xcb,
921 0x28, 0xe2, 0xc1, 0x1a, 0x35, 0xf1, 0x42, 0x0a, 0x19, 0x39, 0xfa, 0x83, 0xd1, 0xb4, 0xaa,
922 0x69, 0x0f, 0xc2, 0x8e, 0xf9, 0x59, 0x2c, 0xee, 0x11, 0xfc, 0x3e, 0x4b, 0x44, 0xfb, 0x9a,
923 0x32, 0xc8, 0x78, 0x23, 0x56, 0x85, 0x49, 0x21, 0x43, 0x12, 0x79, 0xbd, 0xa0, 0x70, 0x47,
924 0x2f, 0xae, 0xb6, 0xd7, 0x6c, 0xc6, 0x07, 0x76, 0xa9, 0x8a, 0xa2, 0x16, 0x02, 0x89, 0x1f,
925 0x1a, 0xd1, 0xa2, 0x96, 0x56, 0xd1, 0x1f, 0x10, 0xe1, 0xe5, 0x9f, 0x3f, 0xdd, 0x09, 0x0c,
926 0x40, 0x90, 0x71, 0xef, 0x14, 0x41, 0x02, 0x82, 0x3a, 0x6b, 0xe1, 0xf8, 0x2c, 0x5d, 0xbe,
927 0xfd, 0x1b
928 };
929 static const unsigned char dsa_q[] = {
930 0x00, 0xe0, 0x20, 0xe0, 0x7c, 0x02, 0x16, 0xa7, 0x6c, 0x6a, 0x19, 0xba, 0xd5, 0x83, 0x73,
931 0xf3, 0x7d, 0x31, 0xef, 0xa7, 0xe1, 0x5d, 0x5b, 0x7f, 0xf3, 0xfc, 0xda, 0x84, 0x31
932 };
933 static const unsigned char dsa_g[] = {
934 0x00, 0x83, 0xdb, 0xa1, 0xbc, 0x3e, 0xc7, 0x29, 0xa5, 0x6a, 0x5c, 0x2c, 0xe8, 0x7a, 0x8c,
935 0x7e, 0xe8, 0xb8, 0x3e, 0x13, 0x47, 0xcd, 0x36, 0x7e, 0x79, 0x30, 0x7a, 0x28, 0x03, 0xd3,
936 0xd4, 0xd2, 0xe3, 0xee, 0x3b, 0x46, 0xda, 0xe0, 0x71, 0xe6, 0xcf, 0x46, 0x86, 0x0a, 0x37,
937 0x57, 0xb6, 0xe9, 0xcf, 0xa1, 0x78, 0x19, 0xb8, 0x72, 0x9f, 0x30, 0x8c, 0x2a, 0x04, 0x7c,
938 0x2f, 0x0c, 0x27, 0xa7, 0xb3, 0x23, 0xe0, 0x46, 0xf2, 0x75, 0x0c, 0x03, 0x4c, 0xad, 0xfb,
939 0xc1, 0xcb, 0x28, 0xcd, 0xa0, 0x63, 0xdb, 0x44, 0x88, 0xe0, 0xda, 0x6c, 0x5b, 0x89, 0xb2,
940 0x5b, 0x40, 0x6d, 0xeb, 0x78, 0x7a, 0xd5, 0xaf, 0x40, 0x52, 0x46, 0x63, 0x92, 0x13, 0x0d,
941 0xee, 0xee, 0xf9, 0x53, 0xca, 0x2d, 0x4e, 0x3b, 0x13, 0xd8, 0x0f, 0x50, 0xd0, 0x44, 0x57,
942 0x67, 0x0f, 0x45, 0x8f, 0x21, 0x30, 0x97, 0x9e, 0x80, 0xd9, 0xd0, 0x91, 0xb7, 0xc9, 0x5a,
943 0x69, 0xda, 0xeb, 0xd5, 0xea, 0x37, 0xf6, 0xb3, 0xbe, 0x1f, 0x24, 0xf1, 0x55, 0x14, 0x28,
944 0x05, 0xb5, 0xd8, 0x84, 0x0f, 0x62, 0x85, 0xaa, 0xec, 0x77, 0x64, 0xfd, 0x80, 0x7c, 0x41,
945 0x00, 0x88, 0xa3, 0x79, 0x7d, 0x4f, 0x6f, 0xe3, 0x76, 0xf4, 0xb5, 0x97, 0xb7, 0xeb, 0x67,
946 0x28, 0xba, 0x07, 0x1a, 0x59, 0x32, 0xc1, 0x53, 0xd9, 0x05, 0x6b, 0x63, 0x93, 0xce, 0xa1,
947 0xd9, 0x7a, 0xb2, 0xff, 0x1c, 0x12, 0x0a, 0x9a, 0xe5, 0x51, 0x1e, 0xba, 0xfc, 0x95, 0x2e,
948 0x28, 0xa9, 0xfc, 0x4c, 0xed, 0x7b, 0x05, 0xca, 0x67, 0xe0, 0x2d, 0xd7, 0x54, 0xb3, 0x05,
949 0x1c, 0x23, 0x2b, 0x35, 0x2e, 0x19, 0x48, 0x59, 0x0e, 0x58, 0xa8, 0x01, 0x56, 0xfb, 0x78,
950 0x90, 0xba, 0x08, 0x77, 0x94, 0x45, 0x05, 0x13, 0xc7, 0x6b, 0x96, 0xd2, 0xa3, 0xa6, 0x01,
951 0x9f, 0x34
952 };
953 static const unsigned char dsa_priv[] = {
954 0x2f, 0x68, 0x44, 0xcb, 0xfb, 0x6b, 0xcb, 0x8d, 0x02, 0x49, 0x7c, 0xee, 0xd2, 0xa6, 0xd3,
955 0x43, 0xb8, 0xa4, 0x09, 0xb7, 0xc1, 0xd4, 0x4b, 0xc3, 0x66, 0xa7, 0xe0, 0x21
956 };
957 static const unsigned char dsa_pub[] = {
958 0x16, 0x1a, 0xb4, 0x6d, 0x9f, 0x16, 0x6c, 0xcc, 0x91, 0x66, 0xfe, 0x30, 0xeb, 0x8e, 0x44,
959 0xba, 0x2b, 0x7a, 0xc9, 0xa8, 0x95, 0xf2, 0xa6, 0x38, 0xd8, 0xaf, 0x3e, 0x91, 0x68, 0xe8,
960 0x52, 0xf3, 0x97, 0x37, 0x70, 0xf2, 0x47, 0xa3, 0xf4, 0x62, 0x26, 0xf5, 0x3b, 0x71, 0x52,
961 0x50, 0x15, 0x9c, 0x6d, 0xa6, 0x6d, 0x92, 0x4c, 0x48, 0x76, 0x31, 0x54, 0x48, 0xa5, 0x99,
962 0x7a, 0xd4, 0x61, 0xf7, 0x21, 0x44, 0xe7, 0xd8, 0x82, 0xc3, 0x50, 0xd3, 0xd9, 0xd4, 0x66,
963 0x20, 0xab, 0x70, 0x4c, 0x97, 0x9b, 0x8d, 0xac, 0x1f, 0x78, 0x27, 0x1e, 0x47, 0xf8, 0x3b,
964 0xd1, 0x55, 0x73, 0xf3, 0xb4, 0x8e, 0x6d, 0x45, 0x40, 0x54, 0xc6, 0xd8, 0x95, 0x15, 0x27,
965 0xb7, 0x5f, 0x65, 0xaa, 0xcb, 0x24, 0xc9, 0x49, 0x87, 0x32, 0xad, 0xcb, 0xf8, 0x35, 0x63,
966 0x56, 0x72, 0x7c, 0x4e, 0x6c, 0xad, 0x5f, 0x26, 0x8c, 0xd2, 0x80, 0x41, 0xaf, 0x88, 0x23,
967 0x20, 0x03, 0xa4, 0xd5, 0x3c, 0x53, 0x54, 0xb0, 0x3d, 0xed, 0x0e, 0x9e, 0x53, 0x0a, 0x63,
968 0x5f, 0xfd, 0x28, 0x57, 0x09, 0x07, 0x73, 0xf4, 0x0c, 0xd4, 0x71, 0x5d, 0x6b, 0xa0, 0xd7,
969 0x86, 0x99, 0x29, 0x9b, 0xca, 0xfb, 0xcc, 0xd6, 0x2f, 0xfe, 0xbe, 0x94, 0xef, 0x1a, 0x0e,
970 0x55, 0x84, 0xa7, 0xaf, 0x7b, 0xfa, 0xed, 0x77, 0x61, 0x28, 0x22, 0xee, 0x6b, 0x11, 0xdd,
971 0xb0, 0x17, 0x1e, 0x06, 0xe4, 0x29, 0x4c, 0xc2, 0x3f, 0xd6, 0x75, 0xb6, 0x08, 0x04, 0x55,
972 0x13, 0x48, 0x4f, 0x44, 0xea, 0x8d, 0xaf, 0xcb, 0xac, 0x22, 0xc4, 0x6a, 0xb3, 0x86, 0xe5,
973 0x47, 0xa9, 0xb5, 0x72, 0x17, 0x23, 0x11, 0x81, 0x7f, 0x00, 0x00, 0x67, 0x5c, 0xf4, 0x58,
974 0xcc, 0xe2, 0x46, 0xce, 0xf5, 0x6d, 0xd8, 0x18, 0x91, 0xc4, 0x20, 0xbf, 0x07, 0x48, 0x45,
975 0xfd
976 };
977
do_check_params(OSSL_PARAM key_params[],int expected)978 static int do_check_params(OSSL_PARAM key_params[], int expected)
979 {
980 EVP_PKEY_CTX *gen_ctx = NULL, *check_ctx = NULL;
981 EVP_PKEY *pkey = NULL;
982 int ret;
983
984 ret = TEST_ptr(gen_ctx = EVP_PKEY_CTX_new_from_name(mainctx, "DSA", NULL))
985 && TEST_int_eq(EVP_PKEY_fromdata_init(gen_ctx), 1)
986 && TEST_int_eq(EVP_PKEY_fromdata(gen_ctx, &pkey,
987 EVP_PKEY_KEYPAIR, key_params), 1)
988 && TEST_ptr(check_ctx = EVP_PKEY_CTX_new_from_pkey(mainctx, pkey,
989 NULL))
990 && TEST_int_eq(EVP_PKEY_param_check(check_ctx), expected);
991 EVP_PKEY_CTX_free(check_ctx);
992 EVP_PKEY_CTX_free(gen_ctx);
993 EVP_PKEY_free(pkey);
994 return ret;
995 }
996
do_check_bn(OSSL_PARAM params[],const char * key,const unsigned char * expected,size_t expected_len)997 static int do_check_bn(OSSL_PARAM params[], const char *key,
998 const unsigned char *expected, size_t expected_len)
999 {
1000 OSSL_PARAM *p;
1001 BIGNUM *bn = NULL;
1002 unsigned char buffer[256 + 1];
1003 int ret, len;
1004
1005 ret = TEST_ptr(p = OSSL_PARAM_locate(params, key))
1006 && TEST_true(OSSL_PARAM_get_BN(p, &bn))
1007 && TEST_int_gt(len = BN_bn2binpad(bn, buffer, expected_len), 0)
1008 && TEST_mem_eq(expected, expected_len, buffer, len);
1009 BN_free(bn);
1010 return ret;
1011 }
1012
do_check_int(OSSL_PARAM params[],const char * key,int expected)1013 static int do_check_int(OSSL_PARAM params[], const char *key, int expected)
1014 {
1015 OSSL_PARAM *p;
1016 int val = 0;
1017
1018 return TEST_ptr(p = OSSL_PARAM_locate(params, key))
1019 && TEST_true(OSSL_PARAM_get_int(p, &val))
1020 && TEST_int_eq(val, expected);
1021 }
1022
test_dsa_tofrom_data_select(void)1023 static int test_dsa_tofrom_data_select(void)
1024 {
1025 int ret;
1026 EVP_PKEY *key = NULL;
1027 const unsigned char *pkeydata = dsa_key;
1028
1029 ret = TEST_ptr(key = d2i_AutoPrivateKey_ex(NULL, &pkeydata, sizeof(dsa_key),
1030 mainctx, NULL))
1031 && TEST_true(do_pkey_tofrom_data_select(key, "DSA"));
1032
1033 EVP_PKEY_free(key);
1034 return ret;
1035 }
1036
test_dsa_todata(void)1037 static int test_dsa_todata(void)
1038 {
1039 EVP_PKEY *pkey = NULL;
1040 OSSL_PARAM *to_params = NULL, *all_params = NULL;
1041 OSSL_PARAM gen_params[4];
1042 int ret = 0;
1043 const unsigned char *pkeydata = dsa_key;
1044
1045 unsigned char dsa_seed[] = {
1046 0xbc, 0x8a, 0x81, 0x64, 0x9e, 0x9d, 0x63, 0xa7, 0xa3, 0x5d, 0x87, 0xdd,
1047 0x32, 0xf3, 0xc1, 0x9f, 0x18, 0x22, 0xeb, 0x73, 0x63, 0xad, 0x5e, 0x7b,
1048 0x90, 0xc1, 0xe3, 0xe0
1049 };
1050 int dsa_pcounter = 319;
1051 int dsa_gindex = 5;
1052
1053 gen_params[0] = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_FFC_SEED,
1054 (void*)dsa_seed,
1055 sizeof(dsa_seed));
1056 gen_params[1] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_GINDEX,
1057 &dsa_gindex);
1058 gen_params[2] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_PCOUNTER,
1059 &dsa_pcounter);
1060 gen_params[3] = OSSL_PARAM_construct_end();
1061
1062 if (!TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pkeydata, sizeof(dsa_key),
1063 mainctx, NULL))
1064 || !TEST_int_eq(EVP_PKEY_todata(pkey, EVP_PKEY_KEYPAIR, &to_params), 1)
1065 || !do_check_bn(to_params, OSSL_PKEY_PARAM_FFC_P, dsa_p, sizeof(dsa_p))
1066 || !do_check_bn(to_params, OSSL_PKEY_PARAM_FFC_Q, dsa_q, sizeof(dsa_q))
1067 || !do_check_bn(to_params, OSSL_PKEY_PARAM_FFC_G, dsa_g, sizeof(dsa_g))
1068 || !do_check_bn(to_params, OSSL_PKEY_PARAM_PUB_KEY, dsa_pub,
1069 sizeof(dsa_pub))
1070 || !do_check_bn(to_params, OSSL_PKEY_PARAM_PRIV_KEY, dsa_priv,
1071 sizeof(dsa_priv))
1072 || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_GINDEX, -1)
1073 || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_PCOUNTER, -1)
1074 || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_H, 0)
1075 || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_VALIDATE_PQ, 1)
1076 || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_VALIDATE_G, 1)
1077 || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_VALIDATE_LEGACY, 0)
1078 || !TEST_ptr_null(OSSL_PARAM_locate(to_params, OSSL_PKEY_PARAM_FFC_SEED)))
1079 goto err;
1080
1081 if (!do_fromdata_key_is_equal(to_params, pkey, "DSA"))
1082 goto err;
1083
1084 if (!TEST_ptr(all_params = OSSL_PARAM_merge(to_params, gen_params))
1085 || !do_check_params(all_params, 1))
1086 goto err;
1087 gen_params[1] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_GINDEX,
1088 &dsa_gindex);
1089 gen_params[2] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_PCOUNTER,
1090 &dsa_pcounter);
1091 /*
1092 * Check that modifying the shallow copy values used in OSSL_PARAM_merge()
1093 * results in an invalid key. This also verifies that the fips186-4
1094 * validation code is running.
1095 */
1096 dsa_gindex++;
1097 if (!do_check_params(all_params, 0))
1098 goto err;
1099 dsa_gindex--;
1100 dsa_pcounter++;
1101 if (!do_check_params(all_params, 0))
1102 goto err;
1103 dsa_pcounter--;
1104 dsa_seed[0] = 0xb0;
1105 if (!do_check_params(all_params, 0))
1106 goto err;
1107
1108 ret = 1;
1109 err:
1110 EVP_PKEY_free(pkey);
1111 OSSL_PARAM_free(all_params);
1112 OSSL_PARAM_free(to_params);
1113 return ret;
1114 }
1115
1116 /*
1117 * Test that OSSL_PKEY_PARAM_FFC_DIGEST_PROPS is set properly when using fromdata
1118 * This test:
1119 * checks for failure when the property query is bad (tstid == 0)
1120 * checks for success when the property query is valid (tstid == 1)
1121 */
test_dsa_fromdata_digest_prop(int tstid)1122 static int test_dsa_fromdata_digest_prop(int tstid)
1123 {
1124 EVP_PKEY_CTX *ctx = NULL, *gctx = NULL;
1125 EVP_PKEY *pkey = NULL, *pkey2 = NULL;
1126 OSSL_PARAM params[4], *p = params;
1127 int ret = 0;
1128 int expected = (tstid == 0 ? 0 : 1);
1129 unsigned int pbits = 512; /* minimum allowed for speed */
1130
1131 *p++ = OSSL_PARAM_construct_uint(OSSL_PKEY_PARAM_FFC_PBITS, &pbits);
1132 *p++ = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_FFC_DIGEST, "SHA512", 0);
1133 /* Setting a bad prop query here should fail during paramgen - when it tries to do a fetch */
1134 *p++ = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_FFC_DIGEST_PROPS,
1135 tstid == 0 ? "provider=unknown" : "provider=default", 0);
1136 *p++ = OSSL_PARAM_construct_end();
1137
1138 if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(mainctx, "DSA", NULL))
1139 || !TEST_int_eq(EVP_PKEY_fromdata_init(ctx), 1)
1140 || !TEST_int_eq(EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_KEY_PARAMETERS, params), 1))
1141 goto err;
1142
1143 if (!TEST_ptr(gctx = EVP_PKEY_CTX_new_from_pkey(mainctx, pkey, NULL))
1144 || !TEST_int_eq(EVP_PKEY_paramgen_init(gctx), 1)
1145 || !TEST_int_eq(EVP_PKEY_paramgen(gctx, &pkey2), expected))
1146 goto err;
1147
1148 ret = 1;
1149 err:
1150 EVP_PKEY_free(pkey2);
1151 EVP_PKEY_free(pkey);
1152 EVP_PKEY_CTX_free(ctx);
1153 EVP_PKEY_CTX_free(gctx);
1154 return ret;
1155 }
1156 #endif /* OPENSSL_NO_DSA */
1157
test_pkey_todata_null(void)1158 static int test_pkey_todata_null(void)
1159 {
1160 OSSL_PARAM *params = NULL;
1161 EVP_PKEY *pkey = NULL;
1162 int ret = 0;
1163 const unsigned char *pdata = keydata[0].kder;
1164
1165 ret = TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, keydata[0].size,
1166 mainctx, NULL))
1167 && TEST_int_eq(EVP_PKEY_todata(NULL, EVP_PKEY_KEYPAIR, ¶ms), 0)
1168 && TEST_int_eq(EVP_PKEY_todata(pkey, EVP_PKEY_KEYPAIR, NULL), 0);
1169 EVP_PKEY_free(pkey);
1170 return ret;
1171 }
1172
1173 static OSSL_CALLBACK test_pkey_export_cb;
1174
test_pkey_export_cb(const OSSL_PARAM params[],void * arg)1175 static int test_pkey_export_cb(const OSSL_PARAM params[], void *arg)
1176 {
1177 if (arg == NULL)
1178 return 0;
1179 return do_fromdata_key_is_equal(params, (EVP_PKEY *)arg, "RSA");
1180 }
1181
test_pkey_export_null(void)1182 static int test_pkey_export_null(void)
1183 {
1184 EVP_PKEY *pkey = NULL;
1185 int ret = 0;
1186 const unsigned char *pdata = keydata[0].kder;
1187
1188 ret = TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, keydata[0].size,
1189 mainctx, NULL))
1190 && TEST_int_eq(EVP_PKEY_export(NULL, EVP_PKEY_KEYPAIR,
1191 test_pkey_export_cb, NULL), 0)
1192 && TEST_int_eq(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR, NULL, NULL), 0);
1193 EVP_PKEY_free(pkey);
1194 return ret;
1195 }
1196
test_pkey_export(void)1197 static int test_pkey_export(void)
1198 {
1199 EVP_PKEY *pkey = NULL;
1200 #ifndef OPENSSL_NO_DEPRECATED_3_0
1201 RSA *rsa = NULL;
1202 #endif
1203 int ret = 1;
1204 const unsigned char *pdata = keydata[0].kder;
1205 int pdata_len = keydata[0].size;
1206
1207 if (!TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, pdata_len,
1208 mainctx, NULL))
1209 || !TEST_true(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR,
1210 test_pkey_export_cb, pkey))
1211 || !TEST_false(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR,
1212 test_pkey_export_cb, NULL)))
1213 ret = 0;
1214 EVP_PKEY_free(pkey);
1215
1216 #ifndef OPENSSL_NO_DEPRECATED_3_0
1217 /* Now, try with a legacy key */
1218 pdata = keydata[0].kder;
1219 pdata_len = keydata[0].size;
1220 if (!TEST_ptr(rsa = d2i_RSAPrivateKey(NULL, &pdata, pdata_len))
1221 || !TEST_ptr(pkey = EVP_PKEY_new())
1222 || !TEST_true(EVP_PKEY_assign_RSA(pkey, rsa))
1223 || !TEST_true(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR,
1224 test_pkey_export_cb, pkey))
1225 || !TEST_false(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR,
1226 test_pkey_export_cb, NULL)))
1227 ret = 0;
1228 EVP_PKEY_free(pkey);
1229 #endif
1230 return ret;
1231 }
1232
test_rsa_pss_sign(void)1233 static int test_rsa_pss_sign(void)
1234 {
1235 EVP_PKEY *pkey = NULL;
1236 EVP_PKEY_CTX *pctx = NULL;
1237 int ret = 0;
1238 const unsigned char *pdata = keydata[0].kder;
1239 const char *mdname = "SHA2-256";
1240 OSSL_PARAM sig_params[3];
1241 unsigned char mdbuf[256 / 8] = { 0 };
1242 int padding = RSA_PKCS1_PSS_PADDING;
1243 unsigned char *sig = NULL;
1244 size_t sig_len = 0;
1245
1246 sig_params[0] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_PAD_MODE,
1247 &padding);
1248 sig_params[1] = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
1249 (char *)mdname, 0);
1250 sig_params[2] = OSSL_PARAM_construct_end();
1251
1252 ret = TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, keydata[0].size,
1253 mainctx, NULL))
1254 && TEST_ptr(pctx = EVP_PKEY_CTX_new_from_pkey(mainctx, pkey, NULL))
1255 && TEST_int_gt(EVP_PKEY_sign_init_ex(pctx, sig_params), 0)
1256 && TEST_int_gt(EVP_PKEY_sign(pctx, NULL, &sig_len, mdbuf,
1257 sizeof(mdbuf)), 0)
1258 && TEST_int_gt(sig_len, 0)
1259 && TEST_ptr(sig = OPENSSL_malloc(sig_len))
1260 && TEST_int_gt(EVP_PKEY_sign(pctx, sig, &sig_len, mdbuf,
1261 sizeof(mdbuf)), 0);
1262
1263 EVP_PKEY_CTX_free(pctx);
1264 OPENSSL_free(sig);
1265 EVP_PKEY_free(pkey);
1266
1267 return ret;
1268 }
1269
test_evp_md_ctx_dup(void)1270 static int test_evp_md_ctx_dup(void)
1271 {
1272 EVP_MD_CTX *mdctx;
1273 EVP_MD_CTX *copyctx = NULL;
1274 int ret;
1275
1276 /* test copying freshly initialized context */
1277 ret = TEST_ptr(mdctx = EVP_MD_CTX_new())
1278 && TEST_ptr(copyctx = EVP_MD_CTX_dup(mdctx));
1279
1280 EVP_MD_CTX_free(mdctx);
1281 EVP_MD_CTX_free(copyctx);
1282 return ret;
1283 }
1284
test_evp_md_ctx_copy(void)1285 static int test_evp_md_ctx_copy(void)
1286 {
1287 EVP_MD_CTX *mdctx = NULL;
1288 EVP_MD_CTX *copyctx = NULL;
1289 int ret;
1290
1291 /* test copying freshly initialized context */
1292 ret = TEST_ptr(mdctx = EVP_MD_CTX_new())
1293 && TEST_ptr(copyctx = EVP_MD_CTX_new())
1294 && TEST_true(EVP_MD_CTX_copy_ex(copyctx, mdctx));
1295
1296 EVP_MD_CTX_free(mdctx);
1297 EVP_MD_CTX_free(copyctx);
1298 return ret;
1299 }
1300
1301 #if !defined OPENSSL_NO_DES && !defined OPENSSL_NO_MD5
test_evp_pbe_alg_add(void)1302 static int test_evp_pbe_alg_add(void)
1303 {
1304 int ret = 0;
1305 int cipher_nid = 0, md_nid = 0;
1306 EVP_PBE_KEYGEN_EX *keygen_ex = NULL;
1307 EVP_PBE_KEYGEN *keygen = NULL;
1308
1309 if (!TEST_true(EVP_PBE_alg_add(NID_pbeWithMD5AndDES_CBC, EVP_des_cbc(), EVP_md5(),
1310 PKCS5_PBE_keyivgen)))
1311 goto err;
1312
1313 if (!TEST_true(EVP_PBE_find_ex(EVP_PBE_TYPE_OUTER, NID_pbeWithMD5AndDES_CBC,
1314 &cipher_nid, &md_nid, &keygen, &keygen_ex)))
1315 goto err;
1316
1317 if (!TEST_true(keygen != NULL))
1318 goto err;
1319 if (!TEST_true(keygen_ex == NULL))
1320 goto err;
1321
1322 ret = 1;
1323
1324 err:
1325 return ret;
1326 }
1327 #endif
1328
1329 /*
1330 * Currently, EVP_<OBJ>_fetch doesn't support
1331 * colon separated alternative names for lookup
1332 * so add a test here to ensure that when one is provided
1333 * libcrypto returns an error
1334 */
evp_test_name_parsing(void)1335 static int evp_test_name_parsing(void)
1336 {
1337 EVP_MD *md;
1338
1339 if (!TEST_ptr_null(md = EVP_MD_fetch(mainctx, "SHA256:BogusName", NULL))) {
1340 EVP_MD_free(md);
1341 return 0;
1342 }
1343
1344 return 1;
1345 }
1346
setup_tests(void)1347 int setup_tests(void)
1348 {
1349 if (!test_get_libctx(&mainctx, &nullprov, NULL, NULL, NULL)) {
1350 OSSL_LIB_CTX_free(mainctx);
1351 mainctx = NULL;
1352 return 0;
1353 }
1354
1355 ADD_TEST(evp_test_name_parsing);
1356 ADD_TEST(test_alternative_default);
1357 ADD_ALL_TESTS(test_d2i_AutoPrivateKey_ex, OSSL_NELEM(keydata));
1358 #ifndef OPENSSL_NO_EC
1359 ADD_ALL_TESTS(test_d2i_PrivateKey_ex, 2);
1360 ADD_TEST(test_ec_tofrom_data_select);
1361 # ifndef OPENSSL_NO_ECX
1362 ADD_TEST(test_ecx_tofrom_data_select);
1363 # endif
1364 ADD_TEST(test_ec_d2i_i2d_pubkey);
1365 #else
1366 ADD_ALL_TESTS(test_d2i_PrivateKey_ex, 1);
1367 #endif
1368 #ifndef OPENSSL_NO_SM2
1369 ADD_TEST(test_sm2_tofrom_data_select);
1370 #endif
1371 #ifndef OPENSSL_NO_DSA
1372 ADD_TEST(test_dsa_todata);
1373 ADD_TEST(test_dsa_tofrom_data_select);
1374 ADD_ALL_TESTS(test_dsa_fromdata_digest_prop, 2);
1375 #endif
1376 #ifndef OPENSSL_NO_DH
1377 ADD_TEST(test_dh_tofrom_data_select);
1378 ADD_TEST(test_dh_paramgen);
1379 ADD_TEST(test_dh_paramfromdata);
1380 #endif
1381 ADD_TEST(test_rsa_tofrom_data_select);
1382
1383 ADD_TEST(test_pkey_todata_null);
1384 ADD_TEST(test_pkey_export_null);
1385 ADD_TEST(test_pkey_export);
1386 #ifndef OPENSSL_NO_DES
1387 ADD_TEST(test_pkcs8key_nid_bio);
1388 #endif
1389 ADD_ALL_TESTS(test_PEM_read_bio_negative, OSSL_NELEM(keydata));
1390 ADD_ALL_TESTS(test_PEM_read_bio_negative_wrong_password, 2);
1391 ADD_TEST(test_rsa_pss_sign);
1392 ADD_TEST(test_evp_md_ctx_dup);
1393 ADD_TEST(test_evp_md_ctx_copy);
1394 ADD_ALL_TESTS(test_provider_unload_effective, 2);
1395 #if !defined OPENSSL_NO_DES && !defined OPENSSL_NO_MD5
1396 ADD_TEST(test_evp_pbe_alg_add);
1397 #endif
1398 return 1;
1399 }
1400
cleanup_tests(void)1401 void cleanup_tests(void)
1402 {
1403 OSSL_LIB_CTX_free(mainctx);
1404 OSSL_PROVIDER_unload(nullprov);
1405 }
1406
