]>
Commit | Line | Data |
---|---|---|
5a02d13d RL |
1 | /* |
2 | * Copyright 2019 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 | #include <string.h> | |
11 | ||
12 | #include <openssl/bio.h> | |
13 | #include <openssl/bn.h> | |
14 | #include <openssl/rsa.h> | |
15 | #include <openssl/evp.h> | |
16 | #include <openssl/provider.h> | |
17 | #include <openssl/core_names.h> | |
1640d48c | 18 | #include "internal/core.h" |
5a02d13d RL |
19 | #include "internal/nelem.h" |
20 | #include "crypto/evp.h" /* For the internal API */ | |
21 | #include "testutil.h" | |
22 | ||
23 | typedef struct { | |
24 | OPENSSL_CTX *ctx1; | |
25 | OSSL_PROVIDER *prov1; | |
26 | OPENSSL_CTX *ctx2; | |
27 | OSSL_PROVIDER *prov2; | |
28 | } FIXTURE; | |
29 | ||
30 | static void tear_down(FIXTURE *fixture) | |
31 | { | |
32 | if (fixture != NULL) { | |
33 | OSSL_PROVIDER_unload(fixture->prov1); | |
34 | OSSL_PROVIDER_unload(fixture->prov2); | |
35 | OPENSSL_CTX_free(fixture->ctx1); | |
36 | OPENSSL_CTX_free(fixture->ctx2); | |
37 | OPENSSL_free(fixture); | |
38 | } | |
39 | } | |
40 | ||
41 | static FIXTURE *set_up(const char *testcase_name) | |
42 | { | |
43 | FIXTURE *fixture; | |
44 | ||
45 | if (!TEST_ptr(fixture = OPENSSL_zalloc(sizeof(*fixture))) | |
46 | || !TEST_ptr(fixture->ctx1 = OPENSSL_CTX_new()) | |
47 | || !TEST_ptr(fixture->prov1 = OSSL_PROVIDER_load(fixture->ctx1, | |
48 | "default")) | |
49 | || !TEST_ptr(fixture->ctx2 = OPENSSL_CTX_new()) | |
50 | || !TEST_ptr(fixture->prov2 = OSSL_PROVIDER_load(fixture->ctx2, | |
51 | "default"))) { | |
52 | tear_down(fixture); | |
53 | return NULL; | |
54 | } | |
55 | return fixture; | |
56 | } | |
57 | ||
1640d48c | 58 | /* Array indexes */ |
5a02d13d RL |
59 | #define N 0 |
60 | #define E 1 | |
61 | #define D 2 | |
62 | #define P 3 | |
63 | #define Q 4 | |
64 | #define F3 5 /* Extra factor */ | |
65 | #define DP 6 | |
66 | #define DQ 7 | |
67 | #define E3 8 /* Extra exponent */ | |
68 | #define QINV 9 | |
69 | #define C3 10 /* Extra coefficient */ | |
70 | ||
1640d48c RL |
71 | /* |
72 | * We have to do this because OSSL_PARAM_get_ulong() can't handle params | |
73 | * holding data that isn't exactly sizeof(uint32_t) or sizeof(uint64_t), | |
74 | * and because the other end deals with BIGNUM, the resulting param might | |
75 | * be any size. In this particular test, we know that the expected data | |
76 | * fits within an unsigned long, and we want to get the data in that form | |
77 | * to make testing of values easier. | |
78 | */ | |
79 | static int get_ulong_via_BN(const OSSL_PARAM *p, unsigned long *goal) | |
80 | { | |
81 | BIGNUM *n = NULL; | |
82 | int ret = 1; /* Ever so hopeful */ | |
83 | ||
84 | if (!TEST_true(OSSL_PARAM_get_BN(p, &n)) | |
85 | || !TEST_true(BN_bn2nativepad(n, (unsigned char *)goal, sizeof(*goal)))) | |
86 | ret = 0; | |
87 | BN_free(n); | |
88 | return ret; | |
89 | } | |
90 | ||
91 | static int export_cb(const OSSL_PARAM *params, void *arg) | |
92 | { | |
93 | unsigned long *keydata = arg; | |
94 | const OSSL_PARAM *p = NULL; | |
95 | int factors_idx; | |
96 | int exponents_idx; | |
97 | int coefficients_idx; | |
98 | int ret = 1; /* Ever so hopeful */ | |
99 | ||
100 | if (keydata == NULL) | |
101 | return 0; | |
102 | ||
103 | if (!TEST_ptr(p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_N)) | |
104 | || !TEST_true(get_ulong_via_BN(p, &keydata[N])) | |
105 | || !TEST_ptr(p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_E)) | |
106 | || !TEST_true(get_ulong_via_BN(p, &keydata[E])) | |
107 | || !TEST_ptr(p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_D)) | |
108 | || !TEST_true(get_ulong_via_BN(p, &keydata[D]))) | |
109 | ret = 0; | |
110 | ||
111 | for (p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_FACTOR), | |
112 | factors_idx = P; | |
113 | p != NULL && factors_idx <= F3; | |
114 | p = OSSL_PARAM_locate_const(p + 1, OSSL_PKEY_PARAM_RSA_FACTOR), | |
115 | factors_idx++) | |
116 | if (!TEST_true(get_ulong_via_BN(p, &keydata[factors_idx]))) | |
117 | ret = 0; | |
118 | for (p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_EXPONENT), | |
119 | exponents_idx = DP; | |
120 | p != NULL && exponents_idx <= E3; | |
121 | p = OSSL_PARAM_locate_const(p + 1, OSSL_PKEY_PARAM_RSA_EXPONENT), | |
122 | exponents_idx++) | |
123 | if (!TEST_true(get_ulong_via_BN(p, &keydata[exponents_idx]))) | |
124 | ret = 0; | |
125 | for (p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_COEFFICIENT), | |
126 | coefficients_idx = QINV; | |
127 | p != NULL && coefficients_idx <= C3; | |
128 | p = OSSL_PARAM_locate_const(p + 1, OSSL_PKEY_PARAM_RSA_COEFFICIENT), | |
129 | coefficients_idx++) | |
130 | if (!TEST_true(get_ulong_via_BN(p, &keydata[coefficients_idx]))) | |
131 | ret = 0; | |
132 | ||
133 | if (!TEST_int_le(factors_idx, F3) | |
134 | || !TEST_int_le(exponents_idx, E3) | |
135 | || !TEST_int_le(coefficients_idx, C3)) | |
136 | ret = 0; | |
137 | return ret; | |
138 | } | |
139 | ||
140 | static int test_pass_rsa(FIXTURE *fixture) | |
141 | { | |
5a02d13d RL |
142 | size_t i; |
143 | int ret = 0; | |
144 | RSA *rsa = NULL; | |
145 | BIGNUM *bn1 = NULL, *bn2 = NULL, *bn3 = NULL; | |
146 | EVP_PKEY *pk = NULL; | |
147 | EVP_KEYMGMT *km1 = NULL, *km2 = NULL; | |
72ec9648 | 148 | void *provkey = NULL; |
5a02d13d RL |
149 | /* |
150 | * 32-bit RSA key, extracted from this command, | |
151 | * executed with OpenSSL 1.0.2: | |
152 | * | |
153 | * openssl genrsa 32 | openssl rsa -text | |
154 | */ | |
155 | static BN_ULONG expected[] = { | |
156 | 0xbc747fc5, /* N */ | |
157 | 0x10001, /* E */ | |
158 | 0x7b133399, /* D */ | |
159 | 0xe963, /* P */ | |
160 | 0xceb7, /* Q */ | |
161 | 0, /* F3 */ | |
162 | 0x8599, /* DP */ | |
163 | 0xbd87, /* DQ */ | |
164 | 0, /* E3 */ | |
165 | 0xcc3b, /* QINV */ | |
166 | 0, /* C3 */ | |
167 | 0 /* Extra, should remain zero */ | |
168 | }; | |
169 | static unsigned long keydata[OSSL_NELEM(expected)] = { 0, }; | |
5a02d13d RL |
170 | |
171 | if (!TEST_ptr(rsa = RSA_new())) | |
172 | goto err; | |
173 | ||
174 | if (!TEST_ptr(bn1 = BN_new()) | |
175 | || !TEST_true(BN_set_word(bn1, expected[N])) | |
176 | || !TEST_ptr(bn2 = BN_new()) | |
177 | || !TEST_true(BN_set_word(bn2, expected[E])) | |
178 | || !TEST_ptr(bn3 = BN_new()) | |
179 | || !TEST_true(BN_set_word(bn3, expected[D])) | |
180 | || !TEST_true(RSA_set0_key(rsa, bn1, bn2, bn3))) | |
181 | goto err; | |
182 | ||
183 | if (!TEST_ptr(bn1 = BN_new()) | |
184 | || !TEST_true(BN_set_word(bn1, expected[P])) | |
185 | || !TEST_ptr(bn2 = BN_new()) | |
186 | || !TEST_true(BN_set_word(bn2, expected[Q])) | |
187 | || !TEST_true(RSA_set0_factors(rsa, bn1, bn2))) | |
188 | goto err; | |
189 | ||
190 | if (!TEST_ptr(bn1 = BN_new()) | |
191 | || !TEST_true(BN_set_word(bn1, expected[DP])) | |
192 | || !TEST_ptr(bn2 = BN_new()) | |
193 | || !TEST_true(BN_set_word(bn2, expected[DQ])) | |
194 | || !TEST_ptr(bn3 = BN_new()) | |
195 | || !TEST_true(BN_set_word(bn3, expected[QINV])) | |
196 | || !TEST_true(RSA_set0_crt_params(rsa, bn1, bn2, bn3))) | |
197 | goto err; | |
198 | bn1 = bn2 = bn3 = NULL; | |
199 | ||
200 | if (!TEST_ptr(pk = EVP_PKEY_new()) | |
201 | || !TEST_true(EVP_PKEY_assign_RSA(pk, rsa))) | |
202 | goto err; | |
203 | rsa = NULL; | |
204 | ||
205 | if (!TEST_ptr(km1 = EVP_KEYMGMT_fetch(fixture->ctx1, "RSA", NULL)) | |
206 | || !TEST_ptr(km2 = EVP_KEYMGMT_fetch(fixture->ctx2, "RSA", NULL)) | |
207 | || !TEST_ptr_ne(km1, km2)) | |
208 | goto err; | |
209 | ||
badf51c8 RL |
210 | if (!TEST_ptr(evp_pkey_export_to_provider(pk, NULL, &km1, NULL)) |
211 | || !TEST_ptr(evp_pkey_upgrade_to_provider(pk, NULL, &km1, NULL)) | |
72ec9648 | 212 | || !TEST_ptr(provkey = evp_keymgmt_util_export_to_provider(pk, km2))) |
5a02d13d RL |
213 | goto err; |
214 | ||
72ec9648 RL |
215 | if (!TEST_true(evp_keymgmt_export(km2, provkey, |
216 | OSSL_KEYMGMT_SELECT_KEYPAIR, | |
217 | &export_cb, keydata))) | |
5a02d13d RL |
218 | goto err; |
219 | ||
220 | /* | |
221 | * At this point, the hope is that keydata will have all the numbers | |
222 | * from the key. | |
223 | */ | |
224 | ||
1640d48c RL |
225 | for (i = 0; i < OSSL_NELEM(expected); i++) { |
226 | int rv = TEST_int_eq(expected[i], keydata[i]); | |
227 | ||
228 | if (!rv) | |
229 | TEST_info("i = %zu", i); | |
230 | else | |
231 | ret++; | |
232 | } | |
5a02d13d RL |
233 | |
234 | ret = (ret == OSSL_NELEM(expected)); | |
235 | ||
236 | err: | |
237 | RSA_free(rsa); | |
238 | BN_free(bn1); | |
239 | BN_free(bn2); | |
240 | BN_free(bn3); | |
241 | EVP_PKEY_free(pk); | |
242 | EVP_KEYMGMT_free(km1); | |
243 | EVP_KEYMGMT_free(km2); | |
244 | ||
245 | return ret; | |
246 | } | |
247 | ||
248 | static int (*tests[])(FIXTURE *) = { | |
249 | test_pass_rsa | |
250 | }; | |
251 | ||
252 | static int test_pass_key(int n) | |
253 | { | |
254 | SETUP_TEST_FIXTURE(FIXTURE, set_up); | |
255 | EXECUTE_TEST(tests[n], tear_down); | |
256 | return result; | |
257 | } | |
258 | ||
259 | int setup_tests(void) | |
260 | { | |
261 | ADD_ALL_TESTS(test_pass_key, 1); | |
262 | return 1; | |
263 | } |