dsatest.c@ 105770

Last change on this file since 105770 was 104078, checked in by vboxsync, 8 months ago
openssl-3.1.5: Applied and adjusted our OpenSSL changes to 3.1.4. bugref:10638
File size: 17.9 KB

Line
1	/*
2	* Copyright 1995-2023 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	* DSA low level APIs are deprecated for public use, but still ok for
12	* internal use.
13	*/
14	#include "internal/deprecated.h"
15
16	#include <stdio.h>
17	#include <stdlib.h>
18	#include <string.h>
19	#include <sys/types.h>
20	#include <sys/stat.h>
21
22	#include <openssl/crypto.h>
23	#include <openssl/rand.h>
24	#include <openssl/bn.h>
25	#include <openssl/dsa.h>
26	#include <openssl/evp.h>
27	#include <openssl/core_names.h>
28
29	#include "testutil.h"
30	#include "internal/nelem.h"
31
32	#ifndef OPENSSL_NO_DSA
33	static int dsa_cb(int p, int n, BN_GENCB *arg);
34
35	static unsigned char out_p[] = {
36	0x8d, 0xf2, 0xa4, 0x94, 0x49, 0x22, 0x76, 0xaa,
37	0x3d, 0x25, 0x75, 0x9b, 0xb0, 0x68, 0x69, 0xcb,
38	0xea, 0xc0, 0xd8, 0x3a, 0xfb, 0x8d, 0x0c, 0xf7,
39	0xcb, 0xb8, 0x32, 0x4f, 0x0d, 0x78, 0x82, 0xe5,
40	0xd0, 0x76, 0x2f, 0xc5, 0xb7, 0x21, 0x0e, 0xaf,
41	0xc2, 0xe9, 0xad, 0xac, 0x32, 0xab, 0x7a, 0xac,
42	0x49, 0x69, 0x3d, 0xfb, 0xf8, 0x37, 0x24, 0xc2,
43	0xec, 0x07, 0x36, 0xee, 0x31, 0xc8, 0x02, 0x91,
44	};
45	static unsigned char out_q[] = {
46	0xc7, 0x73, 0x21, 0x8c, 0x73, 0x7e, 0xc8, 0xee,
47	0x99, 0x3b, 0x4f, 0x2d, 0xed, 0x30, 0xf4, 0x8e,
48	0xda, 0xce, 0x91, 0x5f,
49	};
50	static unsigned char out_g[] = {
51	0x62, 0x6d, 0x02, 0x78, 0x39, 0xea, 0x0a, 0x13,
52	0x41, 0x31, 0x63, 0xa5, 0x5b, 0x4c, 0xb5, 0x00,
53	0x29, 0x9d, 0x55, 0x22, 0x95, 0x6c, 0xef, 0xcb,
54	0x3b, 0xff, 0x10, 0xf3, 0x99, 0xce, 0x2c, 0x2e,
55	0x71, 0xcb, 0x9d, 0xe5, 0xfa, 0x24, 0xba, 0xbf,
56	0x58, 0xe5, 0xb7, 0x95, 0x21, 0x92, 0x5c, 0x9c,
57	0xc4, 0x2e, 0x9f, 0x6f, 0x46, 0x4b, 0x08, 0x8c,
58	0xc5, 0x72, 0xaf, 0x53, 0xe6, 0xd7, 0x88, 0x02,
59	};
60
61	static int dsa_test(void)
62	{
63	BN_GENCB *cb;
64	DSA *dsa = NULL;
65	int counter, ret = 0, i, j;
66	unsigned char buf[256];
67	unsigned long h;
68	unsigned char sig[256];
69	unsigned int siglen;
70	const BIGNUM p = NULL, q = NULL, *g = NULL;
71	/*
72	* seed, out_p, out_q, out_g are taken from the updated Appendix 5 to FIPS
73	* PUB 186 and also appear in Appendix 5 to FIPS PIB 186-1
74	*/
75	static unsigned char seed[20] = {
76	0xd5, 0x01, 0x4e, 0x4b, 0x60, 0xef, 0x2b, 0xa8,
77	0xb6, 0x21, 0x1b, 0x40, 0x62, 0xba, 0x32, 0x24,
78	0xe0, 0x42, 0x7d, 0xd3,
79	};
80	static const unsigned char str1[] = "12345678901234567890";
81
82	if (!TEST_ptr(cb = BN_GENCB_new()))
83	goto end;
84
85	BN_GENCB_set(cb, dsa_cb, NULL);
86	if (!TEST_ptr(dsa = DSA_new())
87	\|\| !TEST_true(DSA_generate_parameters_ex(dsa, 512, seed, 20,
88	&counter, &h, cb)))
89	goto end;
90
91	if (!TEST_int_eq(counter, 105))
92	goto end;
93	if (!TEST_int_eq(h, 2))
94	goto end;
95
96	DSA_get0_pqg(dsa, &p, &q, &g);
97	i = BN_bn2bin(q, buf);
98	j = sizeof(out_q);
99	if (!TEST_int_eq(i, j) \|\| !TEST_mem_eq(buf, i, out_q, i))
100	goto end;
101
102	i = BN_bn2bin(p, buf);
103	j = sizeof(out_p);
104	if (!TEST_int_eq(i, j) \|\| !TEST_mem_eq(buf, i, out_p, i))
105	goto end;
106
107	i = BN_bn2bin(g, buf);
108	j = sizeof(out_g);
109	if (!TEST_int_eq(i, j) \|\| !TEST_mem_eq(buf, i, out_g, i))
110	goto end;
111
112	if (!TEST_true(DSA_generate_key(dsa)))
113	goto end;
114	if (!TEST_true(DSA_sign(0, str1, 20, sig, &siglen, dsa)))
115	goto end;
116	if (TEST_int_gt(DSA_verify(0, str1, 20, sig, siglen, dsa), 0))
117	ret = 1;
118	end:
119	DSA_free(dsa);
120	BN_GENCB_free(cb);
121	return ret;
122	}
123
124	static int dsa_cb(int p, int n, BN_GENCB *arg)
125	{
126	static int ok = 0, num = 0;
127
128	if (p == 0)
129	num++;
130	if (p == 2)
131	ok++;
132
133	if (!ok && (p == 0) && (num > 1)) {
134	TEST_error("dsa_cb error");
135	return 0;
136	}
137	return 1;
138	}
139
140	# define P 0
141	# define Q 1
142	# define G 2
143	# define SEED 3
144	# define PCOUNT 4
145	# define GINDEX 5
146	# define HCOUNT 6
147	# define GROUP 7
148
149	static int dsa_keygen_test(void)
150	{
151	int ret = 0;
152	EVP_PKEY param_key = NULL, key = NULL;
153	EVP_PKEY_CTX pg_ctx = NULL, kg_ctx = NULL;
154	BIGNUM p_in = NULL, q_in = NULL, *g_in = NULL;
155	BIGNUM p_out = NULL, q_out = NULL, *g_out = NULL;
156	int gindex_out = 0, pcount_out = 0, hcount_out = 0;
157	unsigned char seed_out[32];
158	char group_out[32];
159	size_t len = 0;
160	const OSSL_PARAM *settables = NULL;
161	static const unsigned char seed_data[] = {
162	0xa6, 0xf5, 0x28, 0x8c, 0x50, 0x77, 0xa5, 0x68,
163	0x6d, 0x3a, 0xf5, 0xf1, 0xc6, 0x4c, 0xdc, 0x35,
164	0x95, 0x26, 0x3f, 0x03, 0xdc, 0x00, 0x3f, 0x44,
165	0x7b, 0x2a, 0xc7, 0x29
166	};
167	static const unsigned char expected_p[]= {
168	0xdb, 0x47, 0x07, 0xaf, 0xf0, 0x06, 0x49, 0x55,
169	0xc9, 0xbb, 0x09, 0x41, 0xb8, 0xdb, 0x1f, 0xbc,
170	0xa8, 0xed, 0x12, 0x06, 0x7f, 0x88, 0x49, 0xb8,
171	0xc9, 0x12, 0x87, 0x21, 0xbb, 0x08, 0x6c, 0xbd,
172	0xf1, 0x89, 0xef, 0x84, 0xd9, 0x7a, 0x93, 0xe8,
173	0x45, 0x40, 0x81, 0xec, 0x37, 0x27, 0x1a, 0xa4,
174	0x22, 0x51, 0x99, 0xf0, 0xde, 0x04, 0xdb, 0xea,
175	0xa1, 0xf9, 0x37, 0x83, 0x80, 0x96, 0x36, 0x53,
176	0xf6, 0xae, 0x14, 0x73, 0x33, 0x0f, 0xdf, 0x0b,
177	0xf9, 0x2f, 0x08, 0x46, 0x31, 0xf9, 0x66, 0xcd,
178	0x5a, 0xeb, 0x6c, 0xf3, 0xbb, 0x74, 0xf3, 0x88,
179	0xf0, 0x31, 0x5c, 0xa4, 0xc8, 0x0f, 0x86, 0xf3,
180	0x0f, 0x9f, 0xc0, 0x8c, 0x57, 0xe4, 0x7f, 0x95,
181	0xb3, 0x62, 0xc8, 0x4e, 0xae, 0xf3, 0xd8, 0x14,
182	0xcc, 0x47, 0xc2, 0x4b, 0x4f, 0xef, 0xaf, 0xcd,
183	0xcf, 0xb2, 0xbb, 0xe8, 0xbe, 0x08, 0xca, 0x15,
184	0x90, 0x59, 0x35, 0xef, 0x35, 0x1c, 0xfe, 0xeb,
185	0x33, 0x2e, 0x25, 0x22, 0x57, 0x9c, 0x55, 0x23,
186	0x0c, 0x6f, 0xed, 0x7c, 0xb6, 0xc7, 0x36, 0x0b,
187	0xcb, 0x2b, 0x6a, 0x21, 0xa1, 0x1d, 0x55, 0x77,
188	0xd9, 0x91, 0xcd, 0xc1, 0xcd, 0x3d, 0x82, 0x16,
189	0x9c, 0xa0, 0x13, 0xa5, 0x83, 0x55, 0x3a, 0x73,
190	0x7e, 0x2c, 0x44, 0x3e, 0x70, 0x2e, 0x50, 0x91,
191	0x6e, 0xca, 0x3b, 0xef, 0xff, 0x85, 0x35, 0x70,
192	0xff, 0x61, 0x0c, 0xb1, 0xb2, 0xb7, 0x94, 0x6f,
193	0x65, 0xa4, 0x57, 0x62, 0xef, 0x21, 0x83, 0x0f,
194	0x3e, 0x71, 0xae, 0x7d, 0xe4, 0xad, 0xfb, 0xe3,
195	0xdd, 0xd6, 0x03, 0xda, 0x9a, 0xd8, 0x8f, 0x2d,
196	0xbb, 0x90, 0x87, 0xf8, 0xdb, 0xdc, 0xec, 0x71,
197	0xf2, 0xdb, 0x0b, 0x8e, 0xfc, 0x1a, 0x7e, 0x79,
198	0xb1, 0x1b, 0x0d, 0xfc, 0x70, 0xec, 0x85, 0xc2,
199	0xc5, 0xba, 0xb9, 0x69, 0x3f, 0x88, 0xbc, 0xcb
200	};
201	static const unsigned char expected_q[]= {
202	0x99, 0xb6, 0xa0, 0xee, 0xb3, 0xa6, 0x99, 0x1a,
203	0xb6, 0x67, 0x8d, 0xc1, 0x2b, 0x9b, 0xce, 0x2b,
204	0x01, 0x72, 0x5a, 0x65, 0x76, 0x3d, 0x93, 0x69,
205	0xe2, 0x56, 0xae, 0xd7
206	};
207	static const unsigned char expected_g[]= {
208	0x63, 0xf8, 0xb6, 0xee, 0x2a, 0x27, 0xaf, 0x4f,
209	0x4c, 0xf6, 0x08, 0x28, 0x87, 0x4a, 0xe7, 0x1f,
210	0x45, 0x46, 0x27, 0x52, 0x3b, 0x7f, 0x6f, 0xd2,
211	0x29, 0xcb, 0xe8, 0x11, 0x19, 0x25, 0x35, 0x76,
212	0x99, 0xcb, 0x4f, 0x1b, 0xe0, 0xed, 0x32, 0x9e,
213	0x05, 0xb5, 0xbe, 0xd7, 0xf6, 0x5a, 0xb2, 0xf6,
214	0x0e, 0x0c, 0x7e, 0xf5, 0xe1, 0x05, 0xfe, 0xda,
215	0xaf, 0x0f, 0x27, 0x1e, 0x40, 0x2a, 0xf7, 0xa7,
216	0x23, 0x49, 0x2c, 0xd9, 0x1b, 0x0a, 0xbe, 0xff,
217	0xc7, 0x7c, 0x7d, 0x60, 0xca, 0xa3, 0x19, 0xc3,
218	0xb7, 0xe4, 0x43, 0xb0, 0xf5, 0x75, 0x44, 0x90,
219	0x46, 0x47, 0xb1, 0xa6, 0x48, 0x0b, 0x21, 0x8e,
220	0xee, 0x75, 0xe6, 0x3d, 0xa7, 0xd3, 0x7b, 0x31,
221	0xd1, 0xd2, 0x9d, 0xe2, 0x8a, 0xfc, 0x57, 0xfd,
222	0x8a, 0x10, 0x31, 0xeb, 0x87, 0x36, 0x3f, 0x65,
223	0x72, 0x23, 0x2c, 0xd3, 0xd6, 0x17, 0xa5, 0x62,
224	0x58, 0x65, 0x57, 0x6a, 0xd4, 0xa8, 0xfe, 0xec,
225	0x57, 0x76, 0x0c, 0xb1, 0x4c, 0x93, 0xed, 0xb0,
226	0xb4, 0xf9, 0x45, 0xb3, 0x3e, 0xdd, 0x47, 0xf1,
227	0xfb, 0x7d, 0x25, 0x79, 0x3d, 0xfc, 0xa7, 0x39,
228	0x90, 0x68, 0x6a, 0x6b, 0xae, 0xf2, 0x6e, 0x64,
229	0x8c, 0xfb, 0xb8, 0xdd, 0x76, 0x4e, 0x4a, 0x69,
230	0x8c, 0x97, 0x15, 0x77, 0xb2, 0x67, 0xdc, 0xeb,
231	0x4a, 0x40, 0x6b, 0xb9, 0x47, 0x8f, 0xa6, 0xab,
232	0x6e, 0x98, 0xc0, 0x97, 0x9a, 0x0c, 0xea, 0x00,
233	0xfd, 0x56, 0x1a, 0x74, 0x9a, 0x32, 0x6b, 0xfe,
234	0xbd, 0xdf, 0x6c, 0x82, 0x54, 0x53, 0x4d, 0x70,
235	0x65, 0xe3, 0x8b, 0x37, 0xb8, 0xe4, 0x70, 0x08,
236	0xb7, 0x3b, 0x30, 0x27, 0xaf, 0x1c, 0x77, 0xf3,
237	0x62, 0xd4, 0x9a, 0x59, 0xba, 0xd1, 0x6e, 0x89,
238	0x5c, 0x34, 0x9a, 0xa1, 0xb7, 0x4f, 0x7d, 0x8c,
239	0xdc, 0xbc, 0x74, 0x25, 0x5e, 0xbf, 0x77, 0x46
240	};
241	int expected_c = 1316;
242	int expected_h = 2;
243
244	if (!TEST_ptr(p_in = BN_bin2bn(expected_p, sizeof(expected_p), NULL))
245	\|\| !TEST_ptr(q_in = BN_bin2bn(expected_q, sizeof(expected_q), NULL))
246	\|\| !TEST_ptr(g_in = BN_bin2bn(expected_g, sizeof(expected_g), NULL)))
247	goto end;
248	if (!TEST_ptr(pg_ctx = EVP_PKEY_CTX_new_from_name(NULL, "DSA", NULL))
249	\|\| !TEST_int_gt(EVP_PKEY_paramgen_init(pg_ctx), 0)
250	\|\| !TEST_ptr_null(EVP_PKEY_CTX_gettable_params(pg_ctx))
251	\|\| !TEST_ptr(settables = EVP_PKEY_CTX_settable_params(pg_ctx))
252	\|\| !TEST_ptr(OSSL_PARAM_locate_const(settables,
253	OSSL_PKEY_PARAM_FFC_PBITS))
254	\|\| !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_type(pg_ctx, "fips186_4"))
255	\|\| !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_bits(pg_ctx, 2048))
256	\|\| !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_q_bits(pg_ctx, 224))
257	\|\| !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_seed(pg_ctx, seed_data,
258	sizeof(seed_data)))
259	\|\| !TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_md_props(pg_ctx, "SHA256",
260	""))
261	\|\| !TEST_int_gt(EVP_PKEY_generate(pg_ctx, &param_key), 0)
262	\|\| !TEST_ptr(kg_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, param_key, NULL))
263	\|\| !TEST_int_gt(EVP_PKEY_keygen_init(kg_ctx), 0)
264	\|\| !TEST_int_gt(EVP_PKEY_generate(kg_ctx, &key), 0))
265	goto end;
266
267	if (!TEST_true(EVP_PKEY_get_bn_param(key, OSSL_PKEY_PARAM_FFC_P, &p_out))
268	\|\| !TEST_BN_eq(p_in, p_out)
269	\|\| !TEST_true(EVP_PKEY_get_bn_param(key, OSSL_PKEY_PARAM_FFC_Q, &q_out))
270	\|\| !TEST_BN_eq(q_in, q_out)
271	\|\| !TEST_true(EVP_PKEY_get_bn_param(key, OSSL_PKEY_PARAM_FFC_G, &g_out))
272	\|\| !TEST_BN_eq(g_in, g_out)
273	\|\| !TEST_true(EVP_PKEY_get_octet_string_param(
274	key, OSSL_PKEY_PARAM_FFC_SEED, seed_out,
275	sizeof(seed_out), &len))
276	\|\| !TEST_mem_eq(seed_out, len, seed_data, sizeof(seed_data))
277	\|\| !TEST_true(EVP_PKEY_get_int_param(key, OSSL_PKEY_PARAM_FFC_GINDEX,
278	&gindex_out))
279	\|\| !TEST_int_eq(gindex_out, -1)
280	\|\| !TEST_true(EVP_PKEY_get_int_param(key, OSSL_PKEY_PARAM_FFC_H,
281	&hcount_out))
282	\|\| !TEST_int_eq(hcount_out, expected_h)
283	\|\| !TEST_true(EVP_PKEY_get_int_param(key,
284	OSSL_PKEY_PARAM_FFC_PCOUNTER,
285	&pcount_out))
286	\|\| !TEST_int_eq(pcount_out, expected_c)
287	\|\| !TEST_false(EVP_PKEY_get_utf8_string_param(key,
288	OSSL_PKEY_PARAM_GROUP_NAME,
289	group_out,
290	sizeof(group_out), &len)))
291	goto end;
292	ret = 1;
293	end:
294	BN_free(p_in);
295	BN_free(q_in);
296	BN_free(g_in);
297	BN_free(p_out);
298	BN_free(q_out);
299	BN_free(g_out);
300	EVP_PKEY_free(param_key);
301	EVP_PKEY_free(key);
302	EVP_PKEY_CTX_free(kg_ctx);
303	EVP_PKEY_CTX_free(pg_ctx);
304	return ret;
305	}
306
307	static int test_dsa_default_paramgen_validate(int i)
308	{
309	int ret;
310	EVP_PKEY_CTX *gen_ctx = NULL;
311	EVP_PKEY_CTX *check_ctx = NULL;
312	EVP_PKEY *params = NULL;
313
314	ret = TEST_ptr(gen_ctx = EVP_PKEY_CTX_new_from_name(NULL, "DSA", NULL))
315	&& TEST_int_gt(EVP_PKEY_paramgen_init(gen_ctx), 0)
316	&& (i == 0
317	\|\| TEST_true(EVP_PKEY_CTX_set_dsa_paramgen_bits(gen_ctx, 512)))
318	&& TEST_int_gt(EVP_PKEY_generate(gen_ctx, &params), 0)
319	&& TEST_ptr(check_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, params, NULL))
320	&& TEST_int_gt(EVP_PKEY_param_check(check_ctx), 0);
321
322	EVP_PKEY_free(params);
323	EVP_PKEY_CTX_free(check_ctx);
324	EVP_PKEY_CTX_free(gen_ctx);
325	return ret;
326	}
327
328	static int test_dsa_sig_infinite_loop(void)
329	{
330	int ret = 0;
331	DSA *dsa = NULL;
332	BIGNUM p = NULL, q = NULL, g = NULL, priv = NULL, pub = NULL, priv2 = NULL;
333	BIGNUM badq = NULL, badpriv = NULL;
334	const unsigned char msg[] = { 0x00 };
335	unsigned int signature_len;
336	unsigned char signature[64];
337
338	static unsigned char out_priv[] = {
339	0x17, 0x00, 0xb2, 0x8d, 0xcb, 0x24, 0xc9, 0x98,
340	0xd0, 0x7f, 0x1f, 0x83, 0x1a, 0xa1, 0xc4, 0xa4,
341	0xf8, 0x0f, 0x7f, 0x12
342	};
343	static unsigned char out_pub[] = {
344	0x04, 0x72, 0xee, 0x8d, 0xaa, 0x4d, 0x89, 0x60,
345	0x0e, 0xb2, 0xd4, 0x38, 0x84, 0xa2, 0x2a, 0x60,
346	0x5f, 0x67, 0xd7, 0x9e, 0x24, 0xdd, 0xe8, 0x50,
347	0xf2, 0x23, 0x71, 0x55, 0x53, 0x94, 0x0d, 0x6b,
348	0x2e, 0xcd, 0x30, 0xda, 0x6f, 0x1e, 0x2c, 0xcf,
349	0x59, 0xbe, 0x05, 0x6c, 0x07, 0x0e, 0xc6, 0x38,
350	0x05, 0xcb, 0x0c, 0x44, 0x0a, 0x08, 0x13, 0xb6,
351	0x0f, 0x14, 0xde, 0x4a, 0xf6, 0xed, 0x4e, 0xc3
352	};
353	if (!TEST_ptr(p = BN_bin2bn(out_p, sizeof(out_p), NULL))
354	\|\| !TEST_ptr(q = BN_bin2bn(out_q, sizeof(out_q), NULL))
355	\|\| !TEST_ptr(g = BN_bin2bn(out_g, sizeof(out_g), NULL))
356	\|\| !TEST_ptr(pub = BN_bin2bn(out_pub, sizeof(out_pub), NULL))
357	\|\| !TEST_ptr(priv = BN_bin2bn(out_priv, sizeof(out_priv), NULL))
358	\|\| !TEST_ptr(priv2 = BN_dup(priv))
359	\|\| !TEST_ptr(badq = BN_new())
360	\|\| !TEST_true(BN_set_word(badq, 1))
361	\|\| !TEST_ptr(badpriv = BN_new())
362	\|\| !TEST_true(BN_set_word(badpriv, 0))
363	\|\| !TEST_ptr(dsa = DSA_new()))
364	goto err;
365
366	if (!TEST_true(DSA_set0_pqg(dsa, p, q, g)))
367	goto err;
368	p = q = g = NULL;
369
370	if (!TEST_true(DSA_set0_key(dsa, pub, priv)))
371	goto err;
372	pub = priv = NULL;
373
374	if (!TEST_int_le(DSA_size(dsa), sizeof(signature)))
375	goto err;
376
377	/* Test passing signature as NULL */
378	if (!TEST_true(DSA_sign(0, msg, sizeof(msg), NULL, &signature_len, dsa)))
379	goto err;
380
381	if (!TEST_true(DSA_sign(0, msg, sizeof(msg), signature, &signature_len, dsa)))
382	goto err;
383
384	/* Test using a private key of zero fails - this causes an infinite loop without the retry test */
385	if (!TEST_true(DSA_set0_key(dsa, NULL, badpriv)))
386	goto err;
387	badpriv = NULL;
388	if (!TEST_false(DSA_sign(0, msg, sizeof(msg), signature, &signature_len, dsa)))
389	goto err;
390
391	/* Restore private and set a bad q - this caused an infinite loop in the setup */
392	if (!TEST_true(DSA_set0_key(dsa, NULL, priv2)))
393	goto err;
394	priv2 = NULL;
395	if (!TEST_true(DSA_set0_pqg(dsa, NULL, badq, NULL)))
396	goto err;
397	badq = NULL;
398	if (!TEST_false(DSA_sign(0, msg, sizeof(msg), signature, &signature_len, dsa)))
399	goto err;
400
401	ret = 1;
402	err:
403	BN_free(badq);
404	BN_free(badpriv);
405	BN_free(pub);
406	BN_free(priv);
407	BN_free(priv2);
408	BN_free(g);
409	BN_free(q);
410	BN_free(p);
411	DSA_free(dsa);
412	return ret;
413	}
414
415	static int test_dsa_sig_neg_param(void)
416	{
417	int ret = 0, setpqg = 0;
418	DSA *dsa = NULL;
419	BIGNUM p = NULL, q = NULL, g = NULL, priv = NULL, *pub = NULL;
420	const unsigned char msg[] = { 0x00 };
421	unsigned int signature_len;
422	unsigned char signature[64];
423
424	static unsigned char out_priv[] = {
425	0x17, 0x00, 0xb2, 0x8d, 0xcb, 0x24, 0xc9, 0x98,
426	0xd0, 0x7f, 0x1f, 0x83, 0x1a, 0xa1, 0xc4, 0xa4,
427	0xf8, 0x0f, 0x7f, 0x12
428	};
429	static unsigned char out_pub[] = {
430	0x04, 0x72, 0xee, 0x8d, 0xaa, 0x4d, 0x89, 0x60,
431	0x0e, 0xb2, 0xd4, 0x38, 0x84, 0xa2, 0x2a, 0x60,
432	0x5f, 0x67, 0xd7, 0x9e, 0x24, 0xdd, 0xe8, 0x50,
433	0xf2, 0x23, 0x71, 0x55, 0x53, 0x94, 0x0d, 0x6b,
434	0x2e, 0xcd, 0x30, 0xda, 0x6f, 0x1e, 0x2c, 0xcf,
435	0x59, 0xbe, 0x05, 0x6c, 0x07, 0x0e, 0xc6, 0x38,
436	0x05, 0xcb, 0x0c, 0x44, 0x0a, 0x08, 0x13, 0xb6,
437	0x0f, 0x14, 0xde, 0x4a, 0xf6, 0xed, 0x4e, 0xc3
438	};
439	if (!TEST_ptr(p = BN_bin2bn(out_p, sizeof(out_p), NULL))
440	\|\| !TEST_ptr(q = BN_bin2bn(out_q, sizeof(out_q), NULL))
441	\|\| !TEST_ptr(g = BN_bin2bn(out_g, sizeof(out_g), NULL))
442	\|\| !TEST_ptr(pub = BN_bin2bn(out_pub, sizeof(out_pub), NULL))
443	\|\| !TEST_ptr(priv = BN_bin2bn(out_priv, sizeof(out_priv), NULL))
444	\|\| !TEST_ptr(dsa = DSA_new()))
445	goto err;
446
447	if (!TEST_true(DSA_set0_pqg(dsa, p, q, g)))
448	goto err;
449	setpqg = 1;
450
451	if (!TEST_true(DSA_set0_key(dsa, pub, priv)))
452	goto err;
453	pub = priv = NULL;
454
455	BN_set_negative(p, 1);
456	if (!TEST_false(DSA_sign(0, msg, sizeof(msg), signature, &signature_len, dsa)))
457	goto err;
458
459	BN_set_negative(p, 0);
460	BN_set_negative(q, 1);
461	if (!TEST_false(DSA_sign(0, msg, sizeof(msg), signature, &signature_len, dsa)))
462	goto err;
463
464	BN_set_negative(q, 0);
465	BN_set_negative(g, 1);
466	if (!TEST_false(DSA_sign(0, msg, sizeof(msg), signature, &signature_len, dsa)))
467	goto err;
468
469	BN_set_negative(p, 1);
470	BN_set_negative(q, 1);
471	BN_set_negative(g, 1);
472	if (!TEST_false(DSA_sign(0, msg, sizeof(msg), signature, &signature_len, dsa)))
473	goto err;
474
475	ret = 1;
476	err:
477	BN_free(pub);
478	BN_free(priv);
479
480	if (setpqg == 0) {
481	BN_free(g);
482	BN_free(q);
483	BN_free(p);
484	}
485	DSA_free(dsa);
486	return ret;
487	}
488
489	#endif /* OPENSSL_NO_DSA */
490
491	int setup_tests(void)
492	{
493	#ifndef OPENSSL_NO_DSA
494	ADD_TEST(dsa_test);
495	ADD_TEST(dsa_keygen_test);
496	ADD_TEST(test_dsa_sig_infinite_loop);
497	ADD_TEST(test_dsa_sig_neg_param);
498	ADD_ALL_TESTS(test_dsa_default_paramgen_validate, 2);
499	#endif
500	return 1;
501	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/openssl-3.1.5/test/dsatest.c@ 105770

Download in other formats: