Add ACVP fips module tests
[openssl.git] / test / acvp_test.c
1 /*
2  * Copyright 2020 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 /*
11  * A set of tests demonstrating uses cases for CAVS/ACVP testing.
12  *
13  * For examples of testing KDF's, Digests, KeyAgreement & DRBG's refer to
14  * providers/fips/self_test_kats.c
15  */
16
17 #include <openssl/opensslconf.h> /* To see if OPENSSL_NO_EC is defined */
18 #include <openssl/core_names.h>
19 #include <openssl/evp.h>
20 #include <openssl/ec.h>
21 #include <openssl/dh.h>
22 #include <openssl/dsa.h>
23 #include <openssl/rsa.h>
24 #include <openssl/param_build.h>
25 #include <openssl/provider.h>
26 #include "testutil.h"
27 #include "testutil/output.h"
28 #include "acvp_test.inc"
29 #include "internal/nelem.h"
30
31 static OSSL_PROVIDER *prov_null = NULL;
32 static OPENSSL_CTX *libctx = NULL;
33
34 typedef enum OPTION_choice {
35     OPT_ERR = -1,
36     OPT_EOF = 0,
37     OPT_CONFIG_FILE,
38     OPT_TEST_ENUM
39 } OPTION_CHOICE;
40
41 const OPTIONS *test_get_options(void)
42 {
43     static const OPTIONS test_options[] = {
44         OPT_TEST_OPTIONS_DEFAULT_USAGE,
45         { "config", OPT_CONFIG_FILE, '<',
46           "The configuration file to use for the libctx" },
47         { NULL }
48     };
49     return test_options;
50 }
51
52 #if !defined(OPENSSL_NO_EC) || !defined(OPENSSL_NO_DSA)                       \
53     || !defined(OPENSSL_NO_DH) || !defined(OPENSSL_NO_RSA)
54 static int pkey_get_bn_bytes(EVP_PKEY *pkey, const char *name,
55                              unsigned char **out, size_t *out_len)
56 {
57     unsigned char *buf = NULL;
58     BIGNUM *bn = NULL;
59     int sz;
60
61     if (!EVP_PKEY_get_bn_param(pkey, name, &bn))
62         goto err;
63     sz = BN_num_bytes(bn);
64     buf = OPENSSL_zalloc(sz);
65     if (buf == NULL)
66         goto err;
67     if (!BN_bn2binpad(bn, buf, sz))
68         goto err;
69
70     *out_len = sz;
71     *out = buf;
72     BN_free(bn);
73     return 1;
74 err:
75     OPENSSL_free(buf);
76     BN_free(bn);
77     return 0;
78 }
79 #endif
80
81 #if !defined(OPENSSL_NO_EC) || !defined(OPENSSL_NO_DSA)                        \
82     || !defined(OPENSSL_NO_RSA)
83 static int sig_gen(EVP_PKEY *pkey, OSSL_PARAM *params, const char *digest_name,
84                    const unsigned char *msg, size_t msg_len,
85                    unsigned char **sig_out, size_t *sig_out_len)
86 {
87     int ret = 0;
88     EVP_MD_CTX *md_ctx = NULL;
89     unsigned char *sig = NULL;
90     size_t sig_len;
91     size_t sz = EVP_PKEY_size(pkey);
92
93     if (!TEST_ptr(sig = OPENSSL_malloc(sz))
94         || !TEST_ptr(md_ctx = EVP_MD_CTX_new())
95         || !TEST_int_eq(EVP_DigestSignInit_ex(md_ctx, NULL, digest_name, NULL,
96                                               pkey, libctx), 1)
97         || !TEST_int_gt(EVP_DigestSign(md_ctx, sig, &sig_len, msg, msg_len), 0))
98         goto err;
99     *sig_out = sig;
100     *sig_out_len = sig_len;
101     sig = NULL;
102     ret = 1;
103 err:
104     OPENSSL_free(sig);
105     EVP_MD_CTX_free(md_ctx);
106     return ret;
107 }
108 #endif
109
110 #ifndef OPENSSL_NO_EC
111 static int ecdsa_keygen_test(int id)
112 {
113     int ret = 0;
114     EVP_PKEY_CTX *ctx = NULL;
115     EVP_PKEY *pkey = NULL;
116     unsigned char *priv = NULL;
117     unsigned char *pubx = NULL, *puby = NULL;
118     size_t priv_len = 0, pubx_len = 0, puby_len = 0;
119     const struct ecdsa_keygen_st *tst = &ecdsa_keygen_data[id];
120
121     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "EC", NULL))
122         || !TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
123         || !TEST_true(EVP_PKEY_CTX_set_ec_paramgen_curve_name(ctx,
124                                                               tst->curve_name))
125         || !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0)
126         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_PRIV_KEY, &priv,
127                                         &priv_len))
128         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_EC_PUB_X, &pubx,
129                                         &pubx_len))
130         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_EC_PUB_Y, &puby,
131                                         &puby_len)))
132         goto err;
133
134     test_output_memory("qy", puby, puby_len);
135     test_output_memory("qx", pubx, pubx_len);
136     test_output_memory("d", priv, priv_len);
137     ret = 1;
138 err:
139     OPENSSL_clear_free(priv, priv_len);
140     OPENSSL_free(pubx);
141     OPENSSL_free(puby);
142     EVP_PKEY_free(pkey);
143     EVP_PKEY_CTX_free(ctx);
144     return ret;
145 }
146
147 static int ecdsa_create_pkey(EVP_PKEY **pkey, const char *curve_name,
148                              const unsigned char *pub, size_t pub_len,
149                              int expected)
150 {
151     int ret = 0;
152     EVP_PKEY_CTX *ctx = NULL;
153     OSSL_PARAM_BLD *bld = NULL;
154     OSSL_PARAM *params = NULL;
155
156     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
157         || (curve_name != NULL
158             && !TEST_true(OSSL_PARAM_BLD_push_utf8_string(
159                               bld, OSSL_PKEY_PARAM_EC_NAME, curve_name, 0) > 0))
160         || !TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
161                                                        OSSL_PKEY_PARAM_PUB_KEY,
162                                                        pub, pub_len) > 0)
163         || !TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
164         || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "EC", NULL))
165         || !TEST_true(EVP_PKEY_key_fromdata_init(ctx))
166         || !TEST_int_eq(EVP_PKEY_fromdata(ctx, pkey, params), expected))
167     goto err;
168
169     ret = 1;
170 err:
171     OSSL_PARAM_BLD_free_params(params);
172     OSSL_PARAM_BLD_free(bld);
173     EVP_PKEY_CTX_free(ctx);
174     return ret;
175 }
176
177 static int ecdsa_pub_verify_test(int id)
178 {
179     const struct ecdsa_pub_verify_st *tst = &ecdsa_pv_data[id];
180
181     int ret = 0;
182     EVP_PKEY_CTX *key_ctx = NULL;
183     EVP_PKEY *pkey = NULL;
184
185     if (!TEST_true(ecdsa_create_pkey(&pkey, tst->curve_name,
186                                      tst->pub, tst->pub_len, tst->pass)))
187         goto err;
188
189     if (tst->pass) {
190         if (!TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, ""))
191             || !TEST_int_eq(EVP_PKEY_public_check(key_ctx), tst->pass))
192             goto err;
193     }
194     ret = 1;
195 err:
196     EVP_PKEY_free(pkey);
197     EVP_PKEY_CTX_free(key_ctx);
198     return ret;
199 }
200
201 /* Extract r and s  from a ecdsa signature */
202 static int get_ecdsa_sig_rs_bytes(const unsigned char *sig, size_t sig_len,
203                                   unsigned char **r, unsigned char **s,
204                                   size_t *rlen, size_t *slen)
205 {
206     int ret = 0;
207     unsigned char *rbuf = NULL, *sbuf = NULL;
208     size_t r1_len, s1_len;
209     const BIGNUM *r1, *s1;
210     ECDSA_SIG *sign = d2i_ECDSA_SIG(NULL, &sig, sig_len);
211
212     if (sign == NULL)
213         return 0;
214     r1 = ECDSA_SIG_get0_r(sign);
215     s1 = ECDSA_SIG_get0_s(sign);
216     if (r1 == NULL || s1 == NULL)
217         return 0;
218
219     r1_len = BN_num_bytes(r1);
220     s1_len = BN_num_bytes(s1);
221     rbuf = OPENSSL_zalloc(r1_len);
222     sbuf = OPENSSL_zalloc(s1_len);
223     if (rbuf == NULL || sbuf == NULL)
224         goto err;
225     if (BN_bn2binpad(r1, rbuf, r1_len) <= 0)
226         goto err;
227     if (BN_bn2binpad(s1, sbuf, s1_len) <= 0)
228         goto err;
229     *r = rbuf;
230     *s = sbuf;
231     *rlen = r1_len;
232     *slen = s1_len;
233     ret = 1;
234 err:
235     if (ret == 0) {
236         OPENSSL_free(rbuf);
237         OPENSSL_free(sbuf);
238     }
239     ECDSA_SIG_free(sign);
240     return ret;
241 }
242
243 static int ecdsa_siggen_test(int id)
244 {
245     int ret = 0;
246     EVP_PKEY_CTX *ctx = NULL, *key_ctx = NULL;
247     EVP_PKEY *pkey = NULL;
248     size_t sig_len = 0, rlen = 0, slen = 0;
249     unsigned char *sig = NULL;
250     unsigned char *r = NULL, *s = NULL;
251     const struct ecdsa_siggen_st *tst = &ecdsa_siggen_data[id];
252
253     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "EC", NULL))
254         || !TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
255         || !TEST_true(EVP_PKEY_CTX_set_ec_paramgen_curve_name(ctx,
256                                                               tst->curve_name))
257         || !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0))
258         goto err;
259
260     if (!TEST_true(sig_gen(pkey, NULL, tst->digest_alg, tst->msg, tst->msg_len,
261                            &sig, &sig_len))
262         || !TEST_true(get_ecdsa_sig_rs_bytes(sig, sig_len, &r, &s, &rlen, &slen)))
263         goto err;
264     test_output_memory("r", r, rlen);
265     test_output_memory("s", s, slen);
266     ret = 1;
267 err:
268     OPENSSL_free(r);
269     OPENSSL_free(s);
270     OPENSSL_free(sig);
271     EVP_PKEY_free(pkey);
272     EVP_PKEY_CTX_free(key_ctx);
273     EVP_PKEY_CTX_free(ctx);
274     return ret;
275 }
276
277 static int ecdsa_sigver_test(int id)
278 {
279     int ret = 0;
280     EVP_MD_CTX *md_ctx = NULL;
281     EVP_PKEY *pkey = NULL;
282     ECDSA_SIG *sign = NULL;
283     size_t sig_len;
284     unsigned char *sig = NULL;
285     BIGNUM *rbn = NULL, *sbn = NULL;
286     const struct ecdsa_sigver_st *tst = &ecdsa_sigver_data[id];
287
288     if (!TEST_true(ecdsa_create_pkey(&pkey, tst->curve_name,
289                                      tst->pub, tst->pub_len, 1)))
290         goto err;
291
292     if (!TEST_ptr(sign = ECDSA_SIG_new())
293         || !TEST_ptr(rbn = BN_bin2bn(tst->r, tst->r_len, NULL))
294         || !TEST_ptr(sbn = BN_bin2bn(tst->s, tst->s_len, NULL))
295         || !TEST_true(ECDSA_SIG_set0(sign, rbn, sbn)))
296         goto err;
297     rbn = sbn = NULL;
298
299     ret = TEST_int_gt((sig_len = i2d_ECDSA_SIG(sign, &sig)), 0)
300           && TEST_ptr(md_ctx = EVP_MD_CTX_new())
301           && TEST_true(EVP_DigestVerifyInit_ex(md_ctx, NULL, tst->digest_alg,
302                                                NULL, pkey, libctx)
303           && TEST_int_eq(EVP_DigestVerify(md_ctx, sig, sig_len,
304                                           tst->msg, tst->msg_len), tst->pass));
305 err:
306     BN_free(rbn);
307     BN_free(sbn);
308     OPENSSL_free(sig);
309     ECDSA_SIG_free(sign);
310     EVP_PKEY_free(pkey);
311     EVP_MD_CTX_free(md_ctx);
312     return ret;
313
314 }
315 #endif /* OPENSSL_NO_EC */
316
317 #ifndef OPENSSL_NO_DSA
318 static int pkey_get_octet_bytes(EVP_PKEY *pkey, const char *name,
319                                 unsigned char **out, size_t *out_len)
320 {
321     size_t len = 0;
322     unsigned char *buf = NULL;
323
324     if (!EVP_PKEY_get_octet_string_param(pkey, name, NULL, 0, &len))
325         goto err;
326
327     buf = OPENSSL_zalloc(len);
328     if (buf == NULL)
329         goto err;
330
331     if (!EVP_PKEY_get_octet_string_param(pkey, name, buf, len, out_len))
332         goto err;
333     *out = buf;
334     return 1;
335 err:
336     OPENSSL_free(buf);
337     return 0;
338 }
339
340 static EVP_PKEY *dsa_paramgen(int L, int N)
341 {
342     EVP_PKEY_CTX *paramgen_ctx = NULL;
343     EVP_PKEY *param_key = NULL;
344
345     if (!TEST_ptr(paramgen_ctx = EVP_PKEY_CTX_new_from_name(libctx, "DSA", NULL))
346         || !TEST_true(EVP_PKEY_paramgen_init(paramgen_ctx))
347         || !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_bits(paramgen_ctx, L))
348         || !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_q_bits(paramgen_ctx, N))
349         || !TEST_true(EVP_PKEY_paramgen(paramgen_ctx, &param_key)))
350         return NULL;
351     EVP_PKEY_CTX_free(paramgen_ctx);
352     return param_key;
353 }
354
355 static EVP_PKEY *dsa_keygen(int L, int N)
356 {
357     EVP_PKEY *param_key = NULL, *key = NULL;
358     EVP_PKEY_CTX *keygen_ctx = NULL;
359
360     if (!TEST_ptr(param_key = dsa_paramgen(L, N))
361         || !TEST_ptr(keygen_ctx = EVP_PKEY_CTX_new_from_pkey(libctx, param_key,
362                                                              NULL))
363         || !TEST_int_gt(EVP_PKEY_keygen_init(keygen_ctx), 0)
364         || !TEST_int_gt(EVP_PKEY_keygen(keygen_ctx, &key), 0))
365         goto err;
366 err:
367     EVP_PKEY_free(param_key);
368     EVP_PKEY_CTX_free(keygen_ctx);
369     return key;
370 }
371
372 static int dsa_keygen_test(int id)
373 {
374     int ret = 0, i;
375     EVP_PKEY_CTX *paramgen_ctx = NULL, *keygen_ctx = NULL;
376     EVP_PKEY *param_key = NULL, *key = NULL;
377     unsigned char *priv = NULL, *pub = NULL;
378     size_t priv_len = 0, pub_len = 0;
379     const struct dsa_paramgen_st *tst = &dsa_keygen_data[id];
380
381     if (!TEST_ptr(param_key = dsa_paramgen(tst->L, tst->N))
382         || !TEST_ptr(keygen_ctx = EVP_PKEY_CTX_new_from_pkey(libctx, param_key,
383                                                              NULL))
384         || !TEST_int_gt(EVP_PKEY_keygen_init(keygen_ctx), 0))
385         goto err;
386     for (i = 0; i < 2; ++i) {
387         if (!TEST_int_gt(EVP_PKEY_keygen(keygen_ctx, &key), 0)
388             || !TEST_true(pkey_get_bn_bytes(key, OSSL_PKEY_PARAM_PRIV_KEY,
389                                             &priv, &priv_len))
390             || !TEST_true(pkey_get_bn_bytes(key, OSSL_PKEY_PARAM_PUB_KEY,
391                                             &pub, &pub_len)))
392             goto err;
393         test_output_memory("y", pub, pub_len);
394         test_output_memory("x", priv, priv_len);
395         EVP_PKEY_free(key);
396         OPENSSL_clear_free(priv, priv_len);
397         OPENSSL_free(pub);
398         key = NULL;
399         pub = priv = NULL;
400     }
401     ret = 1;
402 err:
403     OPENSSL_clear_free(priv, priv_len);
404     OPENSSL_free(pub);
405     EVP_PKEY_free(param_key);
406     EVP_PKEY_free(key);
407     EVP_PKEY_CTX_free(keygen_ctx);
408     EVP_PKEY_CTX_free(paramgen_ctx);
409     return ret;
410 }
411
412 static int dsa_paramgen_test(int id)
413 {
414     int ret = 0, counter = 0;
415     EVP_PKEY_CTX *paramgen_ctx = NULL;
416     EVP_PKEY *param_key = NULL;
417     unsigned char *p = NULL, *q = NULL, *seed = NULL;
418     size_t plen = 0, qlen = 0, seedlen = 0;
419     const struct dsa_paramgen_st *tst = &dsa_paramgen_data[id];
420
421     if (!TEST_ptr(paramgen_ctx = EVP_PKEY_CTX_new_from_name(libctx, "DSA", NULL))
422         || !TEST_true(EVP_PKEY_paramgen_init(paramgen_ctx))
423         || !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_bits(paramgen_ctx, tst->L))
424         || !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_q_bits(paramgen_ctx, tst->N))
425         || !TEST_true(EVP_PKEY_paramgen(paramgen_ctx, &param_key))
426         || !TEST_true(pkey_get_bn_bytes(param_key, OSSL_PKEY_PARAM_FFC_P,
427                                         &p, &plen))
428         || !TEST_true(pkey_get_bn_bytes(param_key, OSSL_PKEY_PARAM_FFC_Q,
429                                         &q, &qlen))
430         || !TEST_true(pkey_get_octet_bytes(param_key, OSSL_PKEY_PARAM_FFC_SEED,
431                                            &seed, &seedlen))
432         || !TEST_true(EVP_PKEY_get_int_param(param_key,
433                                              OSSL_PKEY_PARAM_FFC_PCOUNTER,
434                                              &counter)))
435         goto err;
436
437     test_output_memory("p", p, plen);
438     test_output_memory("q", q, qlen);
439     test_output_memory("domainSeed", seed, seedlen);
440     test_printf_stderr("%s: %d\n", "counter", counter);
441     ret = 1;
442 err:
443     OPENSSL_free(p);
444     OPENSSL_free(q);
445     OPENSSL_free(seed);
446     EVP_PKEY_free(param_key);
447     EVP_PKEY_CTX_free(paramgen_ctx);
448     return ret;
449 }
450
451 static int dsa_create_pkey(EVP_PKEY **pkey,
452                            const unsigned char *p, size_t p_len,
453                            const unsigned char *q, size_t q_len,
454                            const unsigned char *g, size_t g_len,
455                            const unsigned char *seed, size_t seed_len,
456                            int counter,
457                            const char *validate_type,
458                            const unsigned char *pub, size_t pub_len,
459                            BN_CTX *bn_ctx)
460 {
461     int ret = 0;
462     EVP_PKEY_CTX *ctx = NULL;
463     OSSL_PARAM_BLD *bld = NULL;
464     OSSL_PARAM *params = NULL;
465     BIGNUM *p_bn = NULL, *q_bn = NULL, *g_bn = NULL, *pub_bn = NULL;
466
467     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
468         || !TEST_ptr(p_bn = BN_CTX_get(bn_ctx))
469         || !TEST_ptr(BN_bin2bn(p, p_len, p_bn))
470         || !TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld,
471                          OSSL_PKEY_PARAM_FFC_VALIDATE_TYPE,
472                          validate_type, 0))
473         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_P, p_bn))
474         || !TEST_ptr(q_bn = BN_CTX_get(bn_ctx))
475         || !TEST_ptr(BN_bin2bn(q, q_len, q_bn))
476         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_Q, q_bn)))
477         goto err;
478
479      if (g != NULL) {
480          if (!TEST_ptr(g_bn = BN_CTX_get(bn_ctx))
481              || !TEST_ptr(BN_bin2bn(g, g_len, g_bn))
482              || !TEST_true(OSSL_PARAM_BLD_push_BN(bld,
483                                                   OSSL_PKEY_PARAM_FFC_G, g_bn)))
484              goto err;
485      }
486      if (seed != NULL) {
487          if (!TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
488                             OSSL_PKEY_PARAM_FFC_SEED, seed, seed_len)))
489              goto err;
490      }
491      if (counter != -1) {
492          if (!TEST_true(OSSL_PARAM_BLD_push_int(bld,
493                                                 OSSL_PKEY_PARAM_FFC_PCOUNTER,
494                                                 counter)))
495              goto err;
496      }
497      if (pub != NULL) {
498          if (!TEST_ptr(pub_bn = BN_CTX_get(bn_ctx))
499              || !TEST_ptr(BN_bin2bn(pub, pub_len, pub_bn))
500              || !TEST_true(OSSL_PARAM_BLD_push_BN(bld,
501                                                   OSSL_PKEY_PARAM_PUB_KEY,
502                                                   pub_bn)))
503              goto err;
504      }
505      if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
506          || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "DSA", NULL))
507          || !TEST_true(EVP_PKEY_key_fromdata_init(ctx))
508          || !TEST_true(EVP_PKEY_fromdata(ctx, pkey, params)))
509          goto err;
510
511     ret = 1;
512 err:
513     OSSL_PARAM_BLD_free_params(params);
514     OSSL_PARAM_BLD_free(bld);
515     EVP_PKEY_CTX_free(ctx);
516     return ret;
517 }
518
519 static int dsa_pqver_test(int id)
520 {
521     int ret = 0;
522     BN_CTX *bn_ctx = NULL;
523     EVP_PKEY_CTX *key_ctx = NULL;
524     EVP_PKEY *param_key = NULL;
525     const struct dsa_pqver_st *tst = &dsa_pqver_data[id];
526
527     if (!TEST_ptr(bn_ctx = BN_CTX_new_ex(libctx))
528         || !TEST_true(dsa_create_pkey(&param_key, tst->p, tst->p_len,
529                                       tst->q, tst->q_len, NULL, 0,
530                                       tst->seed, tst->seed_len, tst->counter,
531                                       OSSL_FFC_PARAM_VALIDATE_PQ,
532                                       NULL, 0,
533                                       bn_ctx))
534         || !TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(libctx, param_key,
535                                                           NULL))
536         || !TEST_int_eq(EVP_PKEY_param_check(key_ctx), tst->pass))
537         goto err;
538
539     ret = 1;
540 err:
541     BN_CTX_free(bn_ctx);
542     EVP_PKEY_free(param_key);
543     EVP_PKEY_CTX_free(key_ctx);
544     return ret;
545 }
546
547 /* Extract r and s from a dsa signature */
548 static int get_dsa_sig_rs_bytes(const unsigned char *sig, size_t sig_len,
549                                 unsigned char **r, unsigned char **s,
550                                 size_t *r_len, size_t *s_len)
551 {
552     int ret = 0;
553     unsigned char *rbuf = NULL, *sbuf = NULL;
554     size_t r1_len, s1_len;
555     const BIGNUM *r1, *s1;
556     DSA_SIG *sign = d2i_DSA_SIG(NULL, &sig, sig_len);
557
558     if (sign == NULL)
559         return 0;
560     DSA_SIG_get0(sign, &r1, &s1);
561     if (r1 == NULL || s1 == NULL)
562         return 0;
563
564     r1_len = BN_num_bytes(r1);
565     s1_len = BN_num_bytes(s1);
566     rbuf = OPENSSL_zalloc(r1_len);
567     sbuf = OPENSSL_zalloc(s1_len);
568     if (rbuf == NULL || sbuf == NULL)
569         goto err;
570     if (BN_bn2binpad(r1, rbuf, r1_len) <= 0)
571         goto err;
572     if (BN_bn2binpad(s1, sbuf, s1_len) <= 0)
573         goto err;
574     *r = rbuf;
575     *s = sbuf;
576     *r_len = r1_len;
577     *s_len = s1_len;
578     ret = 1;
579 err:
580     if (ret == 0) {
581         OPENSSL_free(rbuf);
582         OPENSSL_free(sbuf);
583     }
584     DSA_SIG_free(sign);
585     return ret;
586 }
587
588 static int dsa_siggen_test(int id)
589 {
590     int ret = 0;
591     EVP_PKEY *pkey = NULL;
592     unsigned char *sig = NULL, *r = NULL, *s = NULL;
593     size_t sig_len = 0, rlen = 0, slen = 0;
594     const struct dsa_siggen_st *tst = &dsa_siggen_data[id];
595
596     if (!TEST_ptr(pkey = dsa_keygen(tst->L, tst->N)))
597         goto err;
598
599     if (!TEST_true(sig_gen(pkey, NULL, tst->digest_alg, tst->msg, tst->msg_len,
600                            &sig, &sig_len))
601         || !TEST_true(get_dsa_sig_rs_bytes(sig, sig_len, &r, &s, &rlen, &slen)))
602         goto err;
603     test_output_memory("r", r, rlen);
604     test_output_memory("s", s, slen);
605     ret = 1;
606 err:
607     OPENSSL_free(r);
608     OPENSSL_free(s);
609     OPENSSL_free(sig);
610     EVP_PKEY_free(pkey);
611     return ret;
612 }
613
614 static int dsa_sigver_test(int id)
615 {
616     int ret = 0;
617     EVP_PKEY_CTX *ctx = NULL;
618     EVP_PKEY *pkey = NULL;
619     DSA_SIG *sign = NULL;
620     size_t sig_len;
621     unsigned char *sig = NULL;
622     BIGNUM *rbn = NULL, *sbn = NULL;
623     EVP_MD *md = NULL;
624     unsigned char digest[EVP_MAX_MD_SIZE];
625     unsigned int digest_len;
626     BN_CTX *bn_ctx = NULL;
627     const struct dsa_sigver_st *tst  = &dsa_sigver_data[id];
628
629     if (!TEST_ptr(bn_ctx = BN_CTX_new())
630         || !TEST_true(dsa_create_pkey(&pkey, tst->p, tst->p_len,
631                                       tst->q, tst->q_len, tst->g, tst->g_len,
632                                       NULL, 0, 0, "", tst->pub, tst->pub_len,
633                                       bn_ctx)))
634         goto err;
635
636     if (!TEST_ptr(sign = DSA_SIG_new())
637         || !TEST_ptr(rbn = BN_bin2bn(tst->r, tst->r_len, NULL))
638         || !TEST_ptr(sbn = BN_bin2bn(tst->s, tst->s_len, NULL))
639         || !TEST_true(DSA_SIG_set0(sign, rbn, sbn)))
640         goto err;
641     rbn = sbn = NULL;
642
643     if (!TEST_ptr(md = EVP_MD_fetch(libctx, tst->digest_alg, ""))
644         || !TEST_true(EVP_Digest(tst->msg, tst->msg_len,
645                                  digest, &digest_len, md, NULL)))
646         goto err;
647
648     if (!TEST_int_gt((sig_len = i2d_DSA_SIG(sign, &sig)), 0)
649         || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, ""))
650         || !TEST_int_gt(EVP_PKEY_verify_init(ctx), 0)
651         || !TEST_int_eq(EVP_PKEY_verify(ctx, sig, sig_len, digest, digest_len),
652                         tst->pass))
653         goto err;
654     ret = 1;
655 err:
656     EVP_PKEY_CTX_free(ctx);
657     OPENSSL_free(sig);
658     EVP_MD_free(md);
659     DSA_SIG_free(sign);
660     EVP_PKEY_free(pkey);
661     BN_free(rbn);
662     BN_free(sbn);
663     BN_CTX_free(bn_ctx);
664     return ret;
665 }
666 #endif /* OPENSSL_NO_DSA */
667
668
669 /* cipher encrypt/decrypt */
670 static int cipher_enc(const char *alg,
671                       const unsigned char *pt, size_t pt_len,
672                       const unsigned char *key, size_t key_len,
673                       const unsigned char *iv, size_t iv_len,
674                       const unsigned char *ct, size_t ct_len,
675                       int enc)
676 {
677     int ret = 0, out_len = 0, len = 0;
678     EVP_CIPHER_CTX *ctx = NULL;
679     EVP_CIPHER *cipher = NULL;
680     unsigned char out[256] = { 0 };
681
682     TEST_note("%s : %s", alg, enc ? "encrypt" : "decrypt");
683     if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())
684         || !TEST_ptr(cipher = EVP_CIPHER_fetch(libctx, alg, ""))
685         || !TEST_true(EVP_CipherInit_ex(ctx, cipher, NULL, key, iv, enc))
686         || !TEST_true(EVP_CIPHER_CTX_set_padding(ctx, 0))
687         || !TEST_true(EVP_CipherUpdate(ctx, out, &len, pt, pt_len))
688         || !TEST_true(EVP_CipherFinal_ex(ctx, out + len, &out_len)))
689         goto err;
690     out_len += len;
691     if (!TEST_mem_eq(out, out_len, ct, ct_len))
692         goto err;
693     ret = 1;
694 err:
695     EVP_CIPHER_free(cipher);
696     EVP_CIPHER_CTX_free(ctx);
697     return ret;
698 }
699
700 static int cipher_enc_dec_test(int id)
701 {
702     const struct cipher_st *tst = &cipher_enc_data[id];
703     const int enc = 1;
704
705     return TEST_true(cipher_enc(tst->alg, tst->pt, tst->pt_len,
706                                 tst->key, tst->key_len,
707                                 tst->iv, tst->iv_len,
708                                 tst->ct, tst->ct_len, enc))
709            && TEST_true(cipher_enc(tst->alg, tst->ct, tst->ct_len,
710                                    tst->key, tst->key_len,
711                                    tst->iv, tst->iv_len,
712                                    tst->pt, tst->pt_len, !enc));
713 }
714
715 static int aes_ccm_enc_dec(const char *alg,
716                            const unsigned char *pt, size_t pt_len,
717                            const unsigned char *key, size_t key_len,
718                            const unsigned char *iv, size_t iv_len,
719                            const unsigned char *aad, size_t aad_len,
720                            const unsigned char *ct, size_t ct_len,
721                            const unsigned char *tag, size_t tag_len,
722                            int enc, int pass)
723 {
724     int ret = 0;
725     EVP_CIPHER_CTX *ctx;
726     EVP_CIPHER *cipher = NULL;
727     int out_len, len;
728     unsigned char out[1024];
729
730     TEST_note("%s : %s : expected to %s", alg, enc ? "encrypt" : "decrypt",
731               pass ? "pass" : "fail");
732
733     if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())
734         || !TEST_ptr(cipher = EVP_CIPHER_fetch(libctx, alg, ""))
735         || !TEST_true(EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, enc))
736         || !TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, iv_len,
737                                           NULL))
738         || !TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, tag_len,
739                                           enc ? NULL : (void *)tag))
740         || !TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, key, iv, enc))
741         || !TEST_true(EVP_CIPHER_CTX_set_padding(ctx, 0))
742         || !TEST_true(EVP_CipherUpdate(ctx, NULL, &len, NULL, pt_len))
743         || !TEST_true(EVP_CipherUpdate(ctx, NULL, &len, aad, aad_len))
744         || !TEST_int_eq(EVP_CipherUpdate(ctx, out, &len, pt, pt_len), pass))
745         goto err;
746
747     if (!pass) {
748         ret = 1;
749         goto err;
750     }
751     if (!TEST_true(EVP_CipherFinal_ex(ctx, out + len, &out_len)))
752         goto err;
753     if (enc) {
754         out_len += len;
755         if (!TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG,
756                                            tag_len, out + out_len))
757             || !TEST_mem_eq(out, out_len, ct, ct_len)
758             || !TEST_mem_eq(out + out_len, tag_len, tag, tag_len))
759             goto err;
760     } else {
761         if (!TEST_mem_eq(out, out_len + len, ct, ct_len))
762             goto err;
763     }
764
765     ret = 1;
766 err:
767     EVP_CIPHER_free(cipher);
768     EVP_CIPHER_CTX_free(ctx);
769     return ret;
770 }
771
772 static int aes_ccm_enc_dec_test(int id)
773 {
774     const struct cipher_ccm_st *tst = &aes_ccm_enc_data[id];
775
776     /* The tag is on the end of the cipher text */
777     const size_t tag_len = tst->ct_len - tst->pt_len;
778     const size_t ct_len = tst->ct_len - tag_len;
779     const unsigned char *tag = tst->ct + ct_len;
780     const int enc = 1;
781     const int pass = 1;
782
783     if (ct_len < 1)
784         return 0;
785
786     return aes_ccm_enc_dec(tst->alg, tst->pt, tst->pt_len,
787                            tst->key, tst->key_len,
788                            tst->iv, tst->iv_len, tst->aad, tst->aad_len,
789                            tst->ct, ct_len, tag, tag_len, enc, pass)
790             && aes_ccm_enc_dec(tst->alg, tst->ct, ct_len,
791                                tst->key, tst->key_len,
792                                tst->iv, tst->iv_len, tst->aad, tst->aad_len,
793                                tst->pt, tst->pt_len, tag, tag_len, !enc, pass)
794             /* test that it fails if the tag is incorrect */
795             && aes_ccm_enc_dec(tst->alg, tst->ct, ct_len,
796                                tst->key, tst->key_len,
797                                tst->iv, tst->iv_len, tst->aad, tst->aad_len,
798                                tst->pt, tst->pt_len,
799                                tag - 1, tag_len, !enc, !pass);
800 }
801
802 static int aes_gcm_enc_dec(const char *alg,
803                            const unsigned char *pt, size_t pt_len,
804                            const unsigned char *key, size_t key_len,
805                            const unsigned char *iv, size_t iv_len,
806                            const unsigned char *aad, size_t aad_len,
807                            const unsigned char *ct, size_t ct_len,
808                            const unsigned char *tag, size_t tag_len,
809                            int enc, int pass)
810 {
811     int ret = 0;
812     EVP_CIPHER_CTX *ctx;
813     EVP_CIPHER *cipher = NULL;
814     int out_len, len;
815     unsigned char out[1024];
816
817     TEST_note("%s : %s : expected to %s", alg, enc ? "encrypt" : "decrypt",
818               pass ? "pass" : "fail");
819
820     if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())
821         || !TEST_ptr(cipher = EVP_CIPHER_fetch(libctx, alg, ""))
822         || !TEST_true(EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, enc))
823         || !TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, iv_len,
824                                           NULL)))
825         goto err;
826
827     if (!enc) {
828         if (!TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, tag_len,
829                                            (void *)tag)))
830             goto err;
831     }
832     /*
833      * TODO(3.0): The IV should not be set outside the boundary as it is now.
834      * It needs to be fed in via a dummy entropy source for this test.
835      */
836     if (!TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, key, iv, enc))
837         || !TEST_true(EVP_CIPHER_CTX_set_padding(ctx, 0))
838         || !TEST_true(EVP_CipherUpdate(ctx, NULL, &len, aad, aad_len))
839         || !TEST_true(EVP_CipherUpdate(ctx, out, &len, pt, pt_len)))
840         goto err;
841
842     if (!TEST_int_eq(EVP_CipherFinal_ex(ctx, out + len, &out_len), pass))
843         goto err;
844     if (!pass) {
845         ret = 1;
846         goto err;
847     }
848     out_len += len;
849     if (enc) {
850         if (!TEST_mem_eq(out, out_len, ct, ct_len)
851             || !TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG,
852                                               tag_len, out + out_len))
853             || !TEST_mem_eq(out + out_len, tag_len, tag, tag_len))
854                     goto err;
855     } else {
856         if (!TEST_mem_eq(out, out_len, ct, ct_len))
857             goto err;
858     }
859
860     ret = 1;
861 err:
862     EVP_CIPHER_free(cipher);
863     EVP_CIPHER_CTX_free(ctx);
864     return ret;
865 }
866
867 static int aes_gcm_enc_dec_test(int id)
868 {
869     const struct cipher_gcm_st *tst = &aes_gcm_enc_data[id];
870     int enc = 1;
871     int pass = 1;
872
873     return aes_gcm_enc_dec(tst->alg, tst->pt, tst->pt_len,
874                            tst->key, tst->key_len,
875                            tst->iv, tst->iv_len, tst->aad, tst->aad_len,
876                            tst->ct, tst->ct_len, tst->tag, tst->tag_len,
877                            enc, pass)
878             && aes_gcm_enc_dec(tst->alg, tst->ct, tst->ct_len,
879                                tst->key, tst->key_len,
880                                tst->iv, tst->iv_len, tst->aad, tst->aad_len,
881                                tst->pt, tst->pt_len, tst->tag, tst->tag_len,
882                                !enc, pass)
883             /* Fail if incorrect tag passed to decrypt */
884             && aes_gcm_enc_dec(tst->alg, tst->ct, tst->ct_len,
885                                tst->key, tst->key_len,
886                                tst->iv, tst->iv_len, tst->aad, tst->aad_len,
887                                tst->pt, tst->pt_len, tst->aad, tst->tag_len,
888                                !enc, !pass);
889 }
890
891 #ifndef OPENSSL_NO_DH
892 static int dh_create_pkey(EVP_PKEY **pkey, const char *group_name,
893                           const unsigned char *pub, size_t pub_len,
894                           const unsigned char *priv, size_t priv_len,
895                           BN_CTX *bn_ctx, int pass)
896 {
897     int ret = 0;
898     EVP_PKEY_CTX *ctx = NULL;
899     OSSL_PARAM_BLD *bld = NULL;
900     OSSL_PARAM *params = NULL;
901     BIGNUM *pub_bn = NULL, *priv_bn = NULL;
902
903     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
904         || (group_name != NULL
905             && !TEST_int_gt(OSSL_PARAM_BLD_push_utf8_string(
906                               bld, OSSL_PKEY_PARAM_DH_GROUP,
907                               group_name, 0), 0)))
908         goto err;
909
910     if (pub != NULL) {
911         if (!TEST_ptr(pub_bn = BN_CTX_get(bn_ctx))
912             || !TEST_ptr(BN_bin2bn(pub, pub_len, pub_bn))
913             || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PUB_KEY,
914                                                  pub_bn)))
915             goto err;
916     }
917     if (priv != NULL) {
918         if (!TEST_ptr(priv_bn = BN_CTX_get(bn_ctx))
919             || !TEST_ptr(BN_bin2bn(priv, priv_len, priv_bn))
920             || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY,
921                                                  priv_bn)))
922             goto err;
923     }
924
925     if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
926         || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "DH", NULL))
927         || !TEST_true(EVP_PKEY_key_fromdata_init(ctx))
928         || !TEST_int_eq(EVP_PKEY_fromdata(ctx, pkey, params), pass))
929     goto err;
930
931     ret = 1;
932 err:
933     OSSL_PARAM_BLD_free_params(params);
934     OSSL_PARAM_BLD_free(bld);
935     EVP_PKEY_CTX_free(ctx);
936     return ret;
937 }
938
939 static int dh_safe_prime_keygen_test(int id)
940 {
941     int ret = 0;
942     EVP_PKEY_CTX *ctx = NULL;
943     EVP_PKEY *pkey = NULL;
944     unsigned char *priv = NULL;
945     unsigned char *pub = NULL;
946     size_t priv_len = 0, pub_len = 0;
947     OSSL_PARAM params[2];
948     const struct dh_safe_prime_keygen_st *tst = &dh_safe_prime_keygen_data[id];
949
950     params[0] = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_DH_GROUP,
951                                                  (char *)tst->group_name, 0);
952     params[1] = OSSL_PARAM_construct_end();
953
954     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "DH", NULL))
955         || !TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
956         || !TEST_true(EVP_PKEY_CTX_set_params(ctx, params))
957         || !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0)
958         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_PRIV_KEY,
959                                         &priv, &priv_len))
960         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_PUB_KEY,
961                                         &pub, &pub_len)))
962         goto err;
963
964     test_output_memory("x", priv, priv_len);
965     test_output_memory("y", pub, pub_len);
966     ret = 1;
967 err:
968     OPENSSL_clear_free(priv, priv_len);
969     OPENSSL_free(pub);
970     EVP_PKEY_free(pkey);
971     EVP_PKEY_CTX_free(ctx);
972     return ret;
973 }
974
975 static int dh_safe_prime_keyver_test(int id)
976 {
977     int ret = 0;
978     BN_CTX *bn_ctx = NULL;
979     EVP_PKEY_CTX *key_ctx = NULL;
980     EVP_PKEY *pkey = NULL;
981     const struct dh_safe_prime_keyver_st *tst = &dh_safe_prime_keyver_data[id];
982
983     if (!TEST_ptr(bn_ctx = BN_CTX_new_ex(libctx))
984         || !TEST_true(dh_create_pkey(&pkey, tst->group_name,
985                                      tst->pub, tst->pub_len,
986                                      tst->priv, tst->priv_len, bn_ctx, 1))
987         || !TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, ""))
988         || !TEST_int_eq(EVP_PKEY_check(key_ctx), tst->pass))
989         goto err;
990
991     ret = 1;
992 err:
993     EVP_PKEY_free(pkey);
994     EVP_PKEY_CTX_free(key_ctx);
995     BN_CTX_free(bn_ctx);
996     return ret;
997 }
998 #endif /* OPENSSL_NO_DH */
999
1000
1001 #ifndef OPENSSL_NO_RSA
1002 static EVP_PKEY *rsa_keygen(int bits)
1003 {
1004     EVP_PKEY *key = NULL;
1005     EVP_PKEY_CTX *keygen_ctx = NULL;
1006
1007     if (!TEST_ptr(keygen_ctx = EVP_PKEY_CTX_new_from_name(libctx, "RSA", NULL))
1008         || !TEST_int_gt(EVP_PKEY_keygen_init(keygen_ctx), 0)
1009         || !TEST_true(EVP_PKEY_CTX_set_rsa_keygen_bits(keygen_ctx, bits))
1010         || !TEST_int_gt(EVP_PKEY_keygen(keygen_ctx, &key), 0))
1011         goto err;
1012 err:
1013     EVP_PKEY_CTX_free(keygen_ctx);
1014     return key;
1015 }
1016
1017 static int rsa_create_pkey(EVP_PKEY **pkey,
1018                            const unsigned char *n, size_t n_len,
1019                            const unsigned char *e, size_t e_len,
1020                            const unsigned char *d, size_t d_len,
1021                            BN_CTX *bn_ctx)
1022 {
1023     int ret = 0;
1024     EVP_PKEY_CTX *ctx = NULL;
1025     OSSL_PARAM_BLD *bld = NULL;
1026     OSSL_PARAM *params = NULL;
1027     BIGNUM *e_bn = NULL, *d_bn = NULL, *n_bn = NULL;
1028
1029     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
1030         || !TEST_ptr(n_bn = BN_CTX_get(bn_ctx))
1031         || !TEST_ptr(BN_bin2bn(n, n_len, n_bn))
1032         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, n_bn)))
1033         goto err;
1034
1035     if (e != NULL) {
1036         if (!TEST_ptr(e_bn = BN_CTX_get(bn_ctx))
1037             || !TEST_ptr(BN_bin2bn(e, e_len, e_bn))
1038             || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E,
1039                           e_bn)))
1040             goto err;
1041     }
1042     if (d != NULL) {
1043         if (!TEST_ptr(d_bn = BN_CTX_get(bn_ctx))
1044             || !TEST_ptr(BN_bin2bn(d, d_len, d_bn))
1045             || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_D,
1046                           d_bn)))
1047             goto err;
1048     }
1049     if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
1050         || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "RSA", NULL))
1051         || !TEST_true(EVP_PKEY_key_fromdata_init(ctx))
1052         || !TEST_true(EVP_PKEY_fromdata(ctx, pkey, params)))
1053         goto err;
1054
1055     ret = 1;
1056 err:
1057     OSSL_PARAM_BLD_free_params(params);
1058     OSSL_PARAM_BLD_free(bld);
1059     EVP_PKEY_CTX_free(ctx);
1060     return ret;
1061 }
1062
1063 static int rsa_keygen_test(int id)
1064 {
1065     int ret = 0;
1066     EVP_PKEY_CTX *ctx = NULL;
1067     EVP_PKEY *pkey = NULL;
1068     BIGNUM *e_bn = NULL;
1069     BIGNUM *xp1_bn = NULL, *xp2_bn = NULL, *xp_bn = NULL;
1070     BIGNUM *xq1_bn = NULL, *xq2_bn = NULL, *xq_bn = NULL;
1071     unsigned char *n = NULL, *d = NULL;
1072     unsigned char *p = NULL, *p1 = NULL, *p2 = NULL;
1073     unsigned char *q = NULL, *q1 = NULL, *q2 = NULL;
1074     size_t n_len = 0, d_len = 0;
1075     size_t p_len = 0, p1_len = 0, p2_len = 0;
1076     size_t q_len = 0, q1_len = 0, q2_len = 0;
1077     OSSL_PARAM_BLD *bld = NULL;
1078     OSSL_PARAM *params = NULL;
1079     const struct rsa_keygen_st *tst = &rsa_keygen_data[id];
1080
1081     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
1082         || !TEST_ptr(xp1_bn = BN_bin2bn(tst->xp1, tst->xp1_len, NULL))
1083         || !TEST_ptr(xp2_bn = BN_bin2bn(tst->xp2, tst->xp2_len, NULL))
1084         || !TEST_ptr(xp_bn = BN_bin2bn(tst->xp, tst->xp_len, NULL))
1085         || !TEST_ptr(xq1_bn = BN_bin2bn(tst->xq1, tst->xq1_len, NULL))
1086         || !TEST_ptr(xq2_bn = BN_bin2bn(tst->xq2, tst->xq2_len, NULL))
1087         || !TEST_ptr(xq_bn = BN_bin2bn(tst->xq, tst->xq_len, NULL))
1088         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XP1,
1089                                              xp1_bn))
1090         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XP2,
1091                                              xp2_bn))
1092         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XP,
1093                                              xp_bn))
1094         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XQ1,
1095                                              xq1_bn))
1096         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XQ2,
1097                                              xq2_bn))
1098         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XQ,
1099                                              xq_bn))
1100         || !TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld)))
1101         goto err;
1102
1103     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "RSA", NULL))
1104         || !TEST_ptr(e_bn = BN_bin2bn(tst->e, tst->e_len, NULL))
1105         || !TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
1106         || !TEST_true(EVP_PKEY_CTX_set_params(ctx, params))
1107         || !TEST_true(EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, tst->mod))
1108         || !TEST_true(EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx, e_bn))
1109         || !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0)
1110         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_TEST_P1,
1111                                         &p1, &p1_len))
1112         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_TEST_P2,
1113                                         &p2, &p2_len))
1114         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_TEST_Q1,
1115                                         &q1, &q1_len))
1116         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_TEST_Q2,
1117                                         &q2, &q2_len))
1118         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_FACTOR1,
1119                                         &p, &p_len))
1120         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_FACTOR2,
1121                                         &q, &q_len))
1122         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_N,
1123                                         &n, &n_len))
1124         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_D,
1125                                         &d, &d_len)))
1126         goto err;
1127
1128     if (!TEST_mem_eq(tst->p1, tst->p1_len, p1, p1_len)
1129         || !TEST_mem_eq(tst->p2, tst->p2_len, p2, p2_len)
1130         || !TEST_mem_eq(tst->p, tst->p_len, p, p_len)
1131         || !TEST_mem_eq(tst->q1, tst->q1_len, q1, q1_len)
1132         || !TEST_mem_eq(tst->q2, tst->q2_len, q2, q2_len)
1133         || !TEST_mem_eq(tst->q, tst->q_len, q, q_len)
1134         || !TEST_mem_eq(tst->n, tst->n_len, n, n_len)
1135         || !TEST_mem_eq(tst->d, tst->d_len, d, d_len))
1136         goto err;
1137
1138     test_output_memory("p1", p1, p1_len);
1139     test_output_memory("p2", p2, p2_len);
1140     test_output_memory("p", p, p_len);
1141     test_output_memory("q1", q1, q1_len);
1142     test_output_memory("q2", q2, q2_len);
1143     test_output_memory("q", q, q_len);
1144     test_output_memory("n", n, n_len);
1145     test_output_memory("d", d, d_len);
1146     ret = 1;
1147 err:
1148     BN_free(xp1_bn);
1149     BN_free(xp2_bn);
1150     BN_free(xp_bn);
1151     BN_free(xq1_bn);
1152     BN_free(xq2_bn);
1153     BN_free(xq_bn);
1154     BN_free(e_bn);
1155     OPENSSL_free(p1);
1156     OPENSSL_free(p2);
1157     OPENSSL_free(q1);
1158     OPENSSL_free(q2);
1159     OPENSSL_free(p);
1160     OPENSSL_free(q);
1161     OPENSSL_free(n);
1162     OPENSSL_free(d);
1163     EVP_PKEY_free(pkey);
1164     EVP_PKEY_CTX_free(ctx);
1165     OSSL_PARAM_BLD_free_params(params);
1166     OSSL_PARAM_BLD_free(bld);
1167     return ret;
1168 }
1169
1170 static int rsa_siggen_test(int id)
1171 {
1172     int ret = 0;
1173     EVP_PKEY *pkey = NULL;
1174     unsigned char *sig = NULL, *n = NULL, *e = NULL;
1175     size_t sig_len = 0, n_len = 0, e_len = 0;
1176     OSSL_PARAM params[4], *p;
1177     const struct rsa_siggen_st *tst = &rsa_siggen_data[id];
1178
1179     TEST_note("RSA %s signature generation", tst->sig_pad_mode);
1180
1181     p = params;
1182     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_PAD_MODE,
1183                                             (char *)tst->sig_pad_mode, 0);
1184     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
1185                                             (char *)tst->digest_alg, 0);
1186     if (tst->pss_salt_len >= 0) {
1187         int salt_len = tst->pss_salt_len;
1188
1189         *p++ = OSSL_PARAM_construct_int(OSSL_SIGNATURE_PARAM_PSS_SALTLEN,
1190                                         &salt_len);
1191     }
1192     *p++ = OSSL_PARAM_construct_end();
1193
1194     if (!TEST_ptr(pkey = rsa_keygen(tst->mod))
1195        || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_N, &n, &n_len))
1196        || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_E, &e, &e_len))
1197        || !TEST_true(sig_gen(pkey, params, tst->digest_alg,
1198                              tst->msg, tst->msg_len,
1199                              &sig, &sig_len)))
1200         goto err;
1201     test_output_memory("n", n, n_len);
1202     test_output_memory("e", e, e_len);
1203     test_output_memory("sig", sig, sig_len);
1204     ret = 1;
1205 err:
1206     OPENSSL_free(n);
1207     OPENSSL_free(e);
1208     OPENSSL_free(sig);
1209     EVP_PKEY_free(pkey);
1210     return ret;
1211 }
1212
1213 static int rsa_sigver_test(int id)
1214 {
1215     int ret = 0;
1216     EVP_PKEY_CTX *pkey_ctx = NULL;
1217     EVP_PKEY *pkey = NULL;
1218     EVP_MD_CTX *md_ctx = NULL;
1219     BN_CTX *bn_ctx = NULL;
1220     OSSL_PARAM params[4], *p;
1221     const struct rsa_sigver_st *tst  = &rsa_sigver_data[id];
1222
1223     TEST_note("RSA %s Signature Verify : expected to %s ", tst->sig_pad_mode,
1224                tst->pass == PASS ? "pass" : "fail");
1225
1226     p = params;
1227     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_PAD_MODE,
1228                                             (char *)tst->sig_pad_mode, 0);
1229     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
1230                                             (char *)tst->digest_alg, 0);
1231     if (tst->pss_salt_len >= 0) {
1232         int salt_len = tst->pss_salt_len;
1233
1234         *p++ = OSSL_PARAM_construct_int(OSSL_SIGNATURE_PARAM_PSS_SALTLEN,
1235                                         &salt_len);
1236     }
1237     *p++ = OSSL_PARAM_construct_end();
1238
1239     if (!TEST_ptr(bn_ctx = BN_CTX_new())
1240         || !TEST_true(rsa_create_pkey(&pkey, tst->n, tst->n_len,
1241                                       tst->e, tst->e_len, NULL, 0, bn_ctx))
1242         || !TEST_ptr(md_ctx = EVP_MD_CTX_new())
1243         || !TEST_true(EVP_DigestVerifyInit_ex(md_ctx, &pkey_ctx, tst->digest_alg,
1244                                               NULL, pkey, libctx)
1245         || !TEST_true(EVP_PKEY_CTX_set_params(pkey_ctx, params))
1246         || !TEST_int_eq(EVP_DigestVerify(md_ctx, tst->sig, tst->sig_len,
1247                                          tst->msg, tst->msg_len), tst->pass)))
1248         goto err;
1249     ret = 1;
1250 err:
1251     EVP_PKEY_free(pkey);
1252     BN_CTX_free(bn_ctx);
1253     EVP_MD_CTX_free(md_ctx);
1254     return ret;
1255 }
1256
1257 static int rsa_decryption_primitive_test(int id)
1258 {
1259     int ret = 0;
1260     EVP_PKEY_CTX *ctx = NULL;
1261     EVP_PKEY *pkey = NULL;
1262     unsigned char pt[2048];
1263     size_t pt_len = sizeof(pt);
1264     unsigned char *n = NULL, *e = NULL;
1265     size_t n_len = 0, e_len = 0;
1266     BN_CTX *bn_ctx = NULL;
1267     const struct rsa_decrypt_prim_st *tst  = &rsa_decrypt_prim_data[id];
1268
1269     if (!TEST_ptr(pkey = rsa_keygen(2048))
1270         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_N, &n, &n_len))
1271         || !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_E, &e, &e_len))
1272         || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, ""))
1273         || !TEST_int_gt(EVP_PKEY_decrypt_init(ctx), 0)
1274         || !TEST_int_gt(EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_NO_PADDING), 0))
1275         goto err;
1276
1277     test_output_memory("n", n, n_len);
1278     test_output_memory("e", e, e_len);
1279     if (!EVP_PKEY_decrypt(ctx, pt, &pt_len, tst->ct, tst->ct_len))
1280         TEST_note("Decryption Failed");
1281     else
1282         test_output_memory("pt", pt, pt_len);
1283     ret = 1;
1284 err:
1285     OPENSSL_free(n);
1286     OPENSSL_free(e);
1287     EVP_PKEY_CTX_free(ctx);
1288     EVP_PKEY_free(pkey);
1289     BN_CTX_free(bn_ctx);
1290     return ret;
1291 }
1292 #endif /* OPENSSL_NO_RSA */
1293
1294
1295 int setup_tests(void)
1296 {
1297     char *config_file = NULL;
1298
1299     OPTION_CHOICE o;
1300
1301     while ((o = opt_next()) != OPT_EOF) {
1302         switch (o) {
1303         case OPT_CONFIG_FILE:
1304             config_file = opt_arg();
1305             break;
1306         case OPT_TEST_CASES:
1307            break;
1308         default:
1309         case OPT_ERR:
1310             return 0;
1311         }
1312     }
1313
1314     prov_null = OSSL_PROVIDER_load(NULL, "null");
1315     if (prov_null == NULL) {
1316         opt_printf_stderr("Failed to load null provider into default libctx\n");
1317         return 0;
1318     }
1319
1320     libctx = OPENSSL_CTX_new();
1321     if (libctx == NULL
1322         || !OPENSSL_CTX_load_config(libctx, config_file)) {
1323         opt_printf_stderr("Failed to load config\n");
1324         return 0;
1325     }
1326
1327     ADD_ALL_TESTS(cipher_enc_dec_test, OSSL_NELEM(cipher_enc_data));
1328     ADD_ALL_TESTS(aes_ccm_enc_dec_test, OSSL_NELEM(aes_ccm_enc_data));
1329     ADD_ALL_TESTS(aes_gcm_enc_dec_test, OSSL_NELEM(aes_gcm_enc_data));
1330
1331 #ifndef OPENSSL_NO_RSA
1332     ADD_ALL_TESTS(rsa_keygen_test, OSSL_NELEM(rsa_keygen_data));
1333     ADD_ALL_TESTS(rsa_siggen_test, OSSL_NELEM(rsa_siggen_data));
1334     ADD_ALL_TESTS(rsa_sigver_test, OSSL_NELEM(rsa_sigver_data));
1335     ADD_ALL_TESTS(rsa_decryption_primitive_test,
1336                   OSSL_NELEM(rsa_decrypt_prim_data));
1337 #endif /* OPENSSL_NO_RSA */
1338
1339 #ifndef OPENSSL_NO_DH
1340     ADD_ALL_TESTS(dh_safe_prime_keygen_test,
1341                   OSSL_NELEM(dh_safe_prime_keygen_data));
1342     ADD_ALL_TESTS(dh_safe_prime_keyver_test,
1343                   OSSL_NELEM(dh_safe_prime_keyver_data));
1344 #endif /* OPENSSL_NO_DH */
1345
1346 #ifndef OPENSSL_NO_DSA
1347     ADD_ALL_TESTS(dsa_keygen_test, OSSL_NELEM(dsa_keygen_data));
1348     ADD_ALL_TESTS(dsa_paramgen_test, OSSL_NELEM(dsa_paramgen_data));
1349     ADD_ALL_TESTS(dsa_pqver_test, OSSL_NELEM(dsa_pqver_data));
1350     ADD_ALL_TESTS(dsa_siggen_test, OSSL_NELEM(dsa_siggen_data));
1351     ADD_ALL_TESTS(dsa_sigver_test, OSSL_NELEM(dsa_sigver_data));
1352 #endif /* OPENSSL_NO_DSA */
1353
1354 #ifndef OPENSSL_NO_EC
1355     ADD_ALL_TESTS(ecdsa_keygen_test, OSSL_NELEM(ecdsa_keygen_data));
1356     ADD_ALL_TESTS(ecdsa_pub_verify_test, OSSL_NELEM(ecdsa_pv_data));
1357     ADD_ALL_TESTS(ecdsa_siggen_test, OSSL_NELEM(ecdsa_siggen_data));
1358     ADD_ALL_TESTS(ecdsa_sigver_test, OSSL_NELEM(ecdsa_sigver_data));
1359 #endif /* OPENSSL_NO_EC */
1360     return 1;
1361 }
1362
1363 void cleanup_tests(void)
1364 {
1365     OSSL_PROVIDER_unload(prov_null);
1366     OPENSSL_CTX_free(libctx);
1367 }