5ef238ccf1d7eef89e3943ba5068896014f79a80
[openssl.git] / test / keymgmt_internal_test.c
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>
18 #include "internal/core.h"
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
58 /* Array indexes */
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
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 {
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;
148     void *provkey = NULL;
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, };
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
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))
212         || !TEST_ptr(provkey = evp_keymgmt_util_export_to_provider(pk, km2)))
213         goto err;
214
215     if (!TEST_true(evp_keymgmt_export(km2, provkey,
216                                       OSSL_KEYMGMT_SELECT_KEYPAIR,
217                                       &export_cb, keydata)))
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
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     }
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 }