evp_extra_test2.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: 54.4 KB

Line
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	static const unsigned char kExampleECXKey2DER[] = {
235	0x30, 0x2E, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x6e,
236	0x04, 0x22, 0x04, 0x20, 0xc8, 0xa9, 0xd5, 0xa9, 0x10, 0x91, 0xad, 0x85,
237	0x1c, 0x66, 0x8b, 0x07, 0x36, 0xc1, 0xc9, 0xa0, 0x29, 0x36, 0xc0, 0xd3,
238	0xad, 0x62, 0x67, 0x08, 0x58, 0x08, 0x80, 0x47, 0xba, 0x05, 0x74, 0x75
239	};
240	#endif
241
242	typedef struct APK_DATA_st {
243	const unsigned char *kder;
244	size_t size;
245	int evptype;
246	} APK_DATA;
247
248	static APK_DATA keydata[] = {
249	{kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER), EVP_PKEY_RSA},
250	{kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8), EVP_PKEY_RSA},
251	#ifndef OPENSSL_NO_EC
252	{kExampleECXKey2DER, sizeof(kExampleECXKey2DER), EVP_PKEY_X25519},
253	{kExampleECKeyDER, sizeof(kExampleECKeyDER), EVP_PKEY_EC},
254	{kExampleECKey2DER, sizeof(kExampleECKey2DER), EVP_PKEY_EC},
255	#endif
256	#ifndef OPENSSL_NO_DH
257	{kExampleDHPrivateKeyDER, sizeof(kExampleDHPrivateKeyDER), EVP_PKEY_DH},
258	#endif
259	};
260
261	static int pkey_has_private(EVP_PKEY key, const char privtag,
262	int use_octstring)
263	{
264	int ret = 0;
265
266	if (use_octstring) {
267	unsigned char buf[64];
268
269	ret = EVP_PKEY_get_octet_string_param(key, privtag, buf, sizeof(buf),
270	NULL);
271	} else {
272	BIGNUM *bn = NULL;
273
274	ret = EVP_PKEY_get_bn_param(key, privtag, &bn);
275	BN_free(bn);
276	}
277	return ret;
278	}
279
280	static int do_pkey_tofrom_data_select(EVP_PKEY key, const char keytype)
281	{
282	int ret = 0;
283	OSSL_PARAM pub_params = NULL, keypair_params = NULL;
284	EVP_PKEY fromkey = NULL, fromkeypair = NULL;
285	EVP_PKEY_CTX *fromctx = NULL;
286	const char *privtag = strcmp(keytype, "RSA") == 0 ? "d" : "priv";
287	const int use_octstring = strcmp(keytype, "X25519") == 0;
288
289	/*
290	* Select only the public key component when using EVP_PKEY_todata() and
291	* check that the resulting param array does not contain a private key.
292	*/
293	if (!TEST_int_eq(EVP_PKEY_todata(key, EVP_PKEY_PUBLIC_KEY, &pub_params), 1)
294	\|\| !TEST_ptr_null(OSSL_PARAM_locate(pub_params, privtag)))
295	goto end;
296	/*
297	* Select the keypair when using EVP_PKEY_todata() and check that
298	* the param array contains a private key.
299	*/
300	if (!TEST_int_eq(EVP_PKEY_todata(key, EVP_PKEY_KEYPAIR, &keypair_params), 1)
301	\|\| !TEST_ptr(OSSL_PARAM_locate(keypair_params, privtag)))
302	goto end;
303
304	/*
305	* Select only the public key when using EVP_PKEY_fromdata() and check that
306	* the resulting key does not contain a private key.
307	*/
308	if (!TEST_ptr(fromctx = EVP_PKEY_CTX_new_from_name(mainctx, keytype, NULL))
309	\|\| !TEST_int_eq(EVP_PKEY_fromdata_init(fromctx), 1)
310	\|\| !TEST_int_eq(EVP_PKEY_fromdata(fromctx, &fromkey, EVP_PKEY_PUBLIC_KEY,
311	keypair_params), 1)
312	\|\| !TEST_false(pkey_has_private(fromkey, privtag, use_octstring)))
313	goto end;
314	/*
315	* Select the keypair when using EVP_PKEY_fromdata() and check that
316	* the resulting key contains a private key.
317	*/
318	if (!TEST_int_eq(EVP_PKEY_fromdata(fromctx, &fromkeypair,
319	EVP_PKEY_KEYPAIR, keypair_params), 1)
320	\|\| !TEST_true(pkey_has_private(fromkeypair, privtag, use_octstring)))
321	goto end;
322	ret = 1;
323	end:
324	EVP_PKEY_free(fromkeypair);
325	EVP_PKEY_free(fromkey);
326	EVP_PKEY_CTX_free(fromctx);
327	OSSL_PARAM_free(keypair_params);
328	OSSL_PARAM_free(pub_params);
329	return ret;
330	}
331
332	#ifndef OPENSSL_NO_DH
333	static int test_dh_tofrom_data_select(void)
334	{
335	int ret;
336	OSSL_PARAM params[2];
337	EVP_PKEY *key = NULL;
338	EVP_PKEY_CTX *gctx = NULL;
339	# ifndef OPENSSL_NO_DEPRECATED_3_0
340	const DH *dhkey;
341	const BIGNUM *privkey;
342	# endif
343
344	params[0] = OSSL_PARAM_construct_utf8_string("group", "ffdhe2048", 0);
345	params[1] = OSSL_PARAM_construct_end();
346	ret = TEST_ptr(gctx = EVP_PKEY_CTX_new_from_name(mainctx, "DHX", NULL))
347	&& TEST_int_gt(EVP_PKEY_keygen_init(gctx), 0)
348	&& TEST_true(EVP_PKEY_CTX_set_params(gctx, params))
349	&& TEST_int_gt(EVP_PKEY_generate(gctx, &key), 0)
350	&& TEST_true(do_pkey_tofrom_data_select(key, "DHX"));
351	# ifndef OPENSSL_NO_DEPRECATED_3_0
352	ret = ret && TEST_ptr(dhkey = EVP_PKEY_get0_DH(key))
353	&& TEST_ptr(privkey = DH_get0_priv_key(dhkey))
354	&& TEST_int_le(BN_num_bits(privkey), 225);
355	# endif
356	EVP_PKEY_free(key);
357	EVP_PKEY_CTX_free(gctx);
358	return ret;
359	}
360
361	static int test_dh_paramgen(void)
362	{
363	int ret;
364	OSSL_PARAM params[3];
365	EVP_PKEY *pkey = NULL;
366	EVP_PKEY_CTX *gctx = NULL;
367	unsigned int pbits = 512; /* minimum allowed for speed */
368
369	params[0] = OSSL_PARAM_construct_uint(OSSL_PKEY_PARAM_FFC_PBITS, &pbits);
370	params[1] = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_FFC_TYPE,
371	"generator", 0);
372	params[2] = OSSL_PARAM_construct_end();
373
374	ret = TEST_ptr(gctx = EVP_PKEY_CTX_new_from_name(mainctx, "DH", NULL))
375	&& TEST_int_gt(EVP_PKEY_paramgen_init(gctx), 0)
376	&& TEST_true(EVP_PKEY_CTX_set_params(gctx, params))
377	&& TEST_true(EVP_PKEY_paramgen(gctx, &pkey))
378	&& TEST_ptr(pkey);
379
380	EVP_PKEY_CTX_free(gctx);
381	gctx = NULL;
382
383	ret = ret && TEST_ptr(gctx = EVP_PKEY_CTX_new_from_pkey(mainctx, pkey, NULL))
384	&& TEST_int_eq(EVP_PKEY_param_check(gctx), 1)
385	&& TEST_int_eq(EVP_PKEY_param_check_quick(gctx), 1);
386
387	EVP_PKEY_CTX_free(gctx);
388	EVP_PKEY_free(pkey);
389	return ret;
390	}
391
392	#endif
393
394	#ifndef OPENSSL_NO_EC
395	static int test_ec_tofrom_data_select(void)
396	{
397	int ret;
398	EVP_PKEY *key = NULL;
399
400	ret = TEST_ptr(key = EVP_PKEY_Q_keygen(mainctx, NULL, "EC", "P-256"))
401	&& TEST_true(do_pkey_tofrom_data_select(key, "EC"));
402	EVP_PKEY_free(key);
403	return ret;
404	}
405
406	static int test_ecx_tofrom_data_select(void)
407	{
408	int ret;
409	EVP_PKEY *key = NULL;
410
411	ret = TEST_ptr(key = EVP_PKEY_Q_keygen(mainctx, NULL, "X25519"))
412	&& TEST_true(do_pkey_tofrom_data_select(key, "X25519"));
413	EVP_PKEY_free(key);
414	return ret;
415	}
416	#endif
417
418	#ifndef OPENSSL_NO_SM2
419	static int test_sm2_tofrom_data_select(void)
420	{
421	int ret;
422	EVP_PKEY *key = NULL;
423
424	ret = TEST_ptr(key = EVP_PKEY_Q_keygen(mainctx, NULL, "SM2"))
425	&& TEST_true(do_pkey_tofrom_data_select(key, "SM2"));
426	EVP_PKEY_free(key);
427	return ret;
428	}
429	#endif
430
431	static int test_rsa_tofrom_data_select(void)
432	{
433	int ret;
434	EVP_PKEY *key = NULL;
435	const unsigned char *pdata = kExampleRSAKeyDER;
436	int pdata_len = sizeof(kExampleRSAKeyDER);
437
438	ret = TEST_ptr(key = d2i_AutoPrivateKey_ex(NULL, &pdata, pdata_len,
439	mainctx, NULL))
440	&& TEST_true(do_pkey_tofrom_data_select(key, "RSA"));
441	EVP_PKEY_free(key);
442	return ret;
443	}
444
445	/* This is the equivalent of test_d2i_AutoPrivateKey in evp_extra_test */
446	static int test_d2i_AutoPrivateKey_ex(int i)
447	{
448	int ret = 0;
449	const unsigned char *p;
450	EVP_PKEY *pkey = NULL;
451	const APK_DATA *ak = &keydata[i];
452	const unsigned char *input = ak->kder;
453	size_t input_len = ak->size;
454	int expected_id = ak->evptype;
455	BIGNUM *p_bn = NULL;
456	BIGNUM *g_bn = NULL;
457	BIGNUM *priv_bn = NULL;
458
459	p = input;
460	if (!TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &p, input_len, mainctx,
461	NULL))
462	\|\| !TEST_ptr_eq(p, input + input_len)
463	\|\| !TEST_int_eq(EVP_PKEY_get_id(pkey), expected_id))
464	goto done;
465
466	if (ak->evptype == EVP_PKEY_RSA) {
467	if (!TEST_true(EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_RSA_D,
468	&priv_bn)))
469	goto done;
470	} else if (ak->evptype == EVP_PKEY_X25519) {
471	unsigned char buffer[32];
472	size_t len;
473
474	if (!TEST_true(EVP_PKEY_get_octet_string_param(pkey,
475	OSSL_PKEY_PARAM_PRIV_KEY,
476	buffer, sizeof(buffer),
477	&len)))
478	goto done;
479	} else {
480	if (!TEST_true(EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_PRIV_KEY,
481	&priv_bn)))
482	goto done;
483	}
484
485	if (ak->evptype == EVP_PKEY_DH) {
486	if (!TEST_true(EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_FFC_P, &p_bn))
487	\|\| !TEST_true(EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_FFC_G,
488	&g_bn)))
489	goto done;
490	}
491
492	ret = 1;
493	done:
494	BN_free(p_bn);
495	BN_free(g_bn);
496	BN_free(priv_bn);
497	EVP_PKEY_free(pkey);
498	return ret;
499	}
500
501	#ifndef OPENSSL_NO_DES
502	static int test_pkcs8key_nid_bio(void)
503	{
504	int ret;
505	const int nid = NID_pbe_WithSHA1And3_Key_TripleDES_CBC;
506	static const char pwd[] = "PASSWORD";
507	EVP_PKEY pkey = NULL, pkey_dec = NULL;
508	BIO in = NULL, enc_bio = NULL;
509	char *enc_data = NULL;
510	long enc_datalen = 0;
511	OSSL_PROVIDER *provider = NULL;
512
513	ret = TEST_ptr(provider = OSSL_PROVIDER_load(NULL, "default"))
514	&& TEST_ptr(enc_bio = BIO_new(BIO_s_mem()))
515	&& TEST_ptr(in = BIO_new_mem_buf(kExampleRSAKeyPKCS8,
516	sizeof(kExampleRSAKeyPKCS8)))
517	&& TEST_ptr(pkey = d2i_PrivateKey_ex_bio(in, NULL, NULL, NULL))
518	&& TEST_int_eq(i2d_PKCS8PrivateKey_nid_bio(enc_bio, pkey, nid,
519	pwd, sizeof(pwd) - 1,
520	NULL, NULL), 1)
521	&& TEST_int_gt(enc_datalen = BIO_get_mem_data(enc_bio, &enc_data), 0)
522	&& TEST_ptr(pkey_dec = d2i_PKCS8PrivateKey_bio(enc_bio, NULL, NULL,
523	(void *)pwd))
524	&& TEST_true(EVP_PKEY_eq(pkey, pkey_dec));
525
526	EVP_PKEY_free(pkey_dec);
527	EVP_PKEY_free(pkey);
528	BIO_free(in);
529	BIO_free(enc_bio);
530	OSSL_PROVIDER_unload(provider);
531	return ret;
532	}
533	#endif /* OPENSSL_NO_DES */
534
535	static int test_alternative_default(void)
536	{
537	OSSL_LIB_CTX *oldctx;
538	EVP_MD *sha256;
539	int ok = 0;
540
541	/*
542	* setup_tests() loaded the "null" provider in the current default, so
543	* we know this fetch should fail.
544	*/
545	if (!TEST_ptr_null(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
546	goto err;
547
548	/*
549	* Now we switch to our main library context, and try again. Since no
550	* providers are loaded in this one, it should fall back to the default.
551	*/
552	if (!TEST_ptr(oldctx = OSSL_LIB_CTX_set0_default(mainctx))
553	\|\| !TEST_ptr(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
554	goto err;
555	EVP_MD_free(sha256);
556	sha256 = NULL;
557
558	/*
559	* Switching back should give us our main library context back, and
560	* fetching SHA2-256 should fail again.
561	*/
562	if (!TEST_ptr_eq(OSSL_LIB_CTX_set0_default(oldctx), mainctx)
563	\|\| !TEST_ptr_null(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
564	goto err;
565
566	ok = 1;
567	err:
568	EVP_MD_free(sha256);
569	return ok;
570	}
571
572	static int test_provider_unload_effective(int testid)
573	{
574	EVP_MD *sha256 = NULL;
575	OSSL_PROVIDER *provider = NULL;
576	int ok = 0;
577
578	if (!TEST_ptr(provider = OSSL_PROVIDER_load(NULL, "default"))
579	\|\| !TEST_ptr(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
580	goto err;
581
582	if (testid > 0) {
583	OSSL_PROVIDER_unload(provider);
584	provider = NULL;
585	EVP_MD_free(sha256);
586	sha256 = NULL;
587	} else {
588	EVP_MD_free(sha256);
589	sha256 = NULL;
590	OSSL_PROVIDER_unload(provider);
591	provider = NULL;
592	}
593
594	/*
595	* setup_tests() loaded the "null" provider in the current default, and
596	* we unloaded it above after the load so we know this fetch should fail.
597	*/
598	if (!TEST_ptr_null(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
599	goto err;
600
601	ok = 1;
602	err:
603	EVP_MD_free(sha256);
604	OSSL_PROVIDER_unload(provider);
605	return ok;
606	}
607
608	static int test_d2i_PrivateKey_ex(int testid)
609	{
610	int ok = 0;
611	OSSL_PROVIDER *provider = NULL;
612	BIO *key_bio = NULL;
613	EVP_PKEY *pkey = NULL;
614	int id = (testid == 0) ? 0 : 2;
615
616	if (!TEST_ptr(provider = OSSL_PROVIDER_load(NULL, "default")))
617	goto err;
618	if (!TEST_ptr(key_bio = BIO_new_mem_buf(keydata[id].kder, keydata[id].size)))
619	goto err;
620	if (!TEST_ptr_null(pkey = PEM_read_bio_PrivateKey(key_bio, NULL, NULL, NULL)))
621	goto err;
622
623	ERR_clear_error();
624	if (!TEST_int_ge(BIO_seek(key_bio, 0), 0))
625	goto err;
626	ok = TEST_ptr(pkey = d2i_PrivateKey_bio(key_bio, NULL));
627	TEST_int_eq(ERR_peek_error(), 0);
628	test_openssl_errors();
629
630	err:
631	EVP_PKEY_free(pkey);
632	BIO_free(key_bio);
633	OSSL_PROVIDER_unload(provider);
634
635	return ok;
636	}
637
638	static int test_PEM_read_bio_negative(int testid)
639	{
640	int ok = 0;
641	OSSL_PROVIDER *provider = NULL;
642	BIO *key_bio = NULL;
643	EVP_PKEY *pkey = NULL;
644
645	if (!TEST_ptr(key_bio = BIO_new_mem_buf(keydata[testid].kder, keydata[testid].size)))
646	goto err;
647	ERR_clear_error();
648	if (!TEST_ptr_null(pkey = PEM_read_bio_PrivateKey(key_bio, NULL, NULL, NULL)))
649	goto err;
650	if (!TEST_int_ne(ERR_peek_error(), 0))
651	goto err;
652	if (!TEST_ptr(provider = OSSL_PROVIDER_load(NULL, "default")))
653	goto err;
654	if (!TEST_int_ge(BIO_seek(key_bio, 0), 0))
655	goto err;
656	ERR_clear_error();
657	if (!TEST_ptr_null(pkey = PEM_read_bio_PrivateKey(key_bio, NULL, NULL, NULL)))
658	goto err;
659	if (!TEST_int_ne(ERR_peek_error(), 0))
660	goto err;
661
662	ok = 1;
663
664	err:
665	test_openssl_errors();
666	EVP_PKEY_free(pkey);
667	BIO_free(key_bio);
668	OSSL_PROVIDER_unload(provider);
669
670	return ok;
671	}
672
673	static int test_PEM_read_bio_negative_wrong_password(int testid)
674	{
675	int ok = 0;
676	OSSL_PROVIDER *provider = OSSL_PROVIDER_load(NULL, "default");
677	EVP_PKEY *read_pkey = NULL;
678	EVP_PKEY *write_pkey = EVP_RSA_gen(1024);
679	BIO *key_bio = BIO_new(BIO_s_mem());
680	const UI_METHOD *undo_ui_method = NULL;
681	const UI_METHOD *ui_method = NULL;
682	if (testid > 0)
683	ui_method = UI_null();
684
685	if (!TEST_ptr(provider))
686	goto err;
687	if (!TEST_ptr(key_bio))
688	goto err;
689	if (!TEST_ptr(write_pkey))
690	goto err;
691	undo_ui_method = UI_get_default_method();
692	UI_set_default_method(ui_method);
693
694	if (/* Output Encrypted private key in PEM form */
695	!TEST_true(PEM_write_bio_PrivateKey(key_bio, write_pkey, EVP_aes_256_cbc(),
696	NULL, 0, NULL, "pass")))
697	goto err;
698
699	ERR_clear_error();
700	read_pkey = PEM_read_bio_PrivateKey(key_bio, NULL, NULL, NULL);
701	if (!TEST_ptr_null(read_pkey))
702	goto err;
703
704	if (!TEST_int_eq(ERR_GET_REASON(ERR_get_error()), PEM_R_PROBLEMS_GETTING_PASSWORD))
705	goto err;
706	ok = 1;
707
708	err:
709	test_openssl_errors();
710	EVP_PKEY_free(read_pkey);
711	EVP_PKEY_free(write_pkey);
712	BIO_free(key_bio);
713	OSSL_PROVIDER_unload(provider);
714	UI_set_default_method(undo_ui_method);
715
716	return ok;
717	}
718
719	static int do_fromdata_key_is_equal(const OSSL_PARAM params[],
720	const EVP_PKEY expected, const char type)
721	{
722	EVP_PKEY_CTX *ctx = NULL;
723	EVP_PKEY *pkey = NULL;
724	int ret;
725
726	ret = TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(mainctx, type, NULL))
727	&& TEST_int_eq(EVP_PKEY_fromdata_init(ctx), 1)
728	&& TEST_int_eq(EVP_PKEY_fromdata(ctx, &pkey,
729	EVP_PKEY_KEYPAIR,
730	(OSSL_PARAM *)params), 1)
731	&& TEST_true(EVP_PKEY_eq(pkey, expected));
732	EVP_PKEY_CTX_free(ctx);
733	EVP_PKEY_free(pkey);
734	return ret;
735	}
736
737	#ifndef OPENSSL_NO_DSA
738	/*
739	* This data was generated using:
740	* > openssl genpkey \
741	* -genparam -algorithm DSA -pkeyopt type:fips186_4 -text \
742	* -pkeyopt gindex:5 -out dsa_param.pem
743	* > openssl genpkey \
744	* -paramfile dsa_param.pem -pkeyopt type:fips186_4 -out dsa_priv.pem
745	*/
746	static const unsigned char dsa_key[] = {
747	0x30, 0x82, 0x03, 0x4e, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x01, 0x00,
748	0xda, 0xb3, 0x46, 0x4d, 0x54, 0x57, 0xc7, 0xb4, 0x61, 0xa0, 0x6f, 0x66,
749	0x17, 0xda, 0xeb, 0x90, 0xf0, 0xa3, 0xd1, 0x29, 0xc9, 0x5f, 0xf2, 0x21,
750	0x3d, 0x85, 0xa3, 0x4a, 0xf0, 0xf8, 0x36, 0x39, 0x1b, 0xe3, 0xee, 0x37,
751	0x70, 0x06, 0x9b, 0xe8, 0xe3, 0x0a, 0xd2, 0xf1, 0xf6, 0xc4, 0x42, 0x23,
752	0x1f, 0x74, 0x78, 0xc2, 0x16, 0xf5, 0xce, 0xd6, 0xab, 0xa0, 0xc6, 0xe8,
753	0x99, 0x3d, 0xf8, 0x8b, 0xfb, 0x47, 0xf8, 0x5e, 0x05, 0x68, 0x6d, 0x8b,
754	0xa8, 0xad, 0xa1, 0xc2, 0x3a, 0x4e, 0xe0, 0xad, 0xec, 0x38, 0x75, 0x21,
755	0x55, 0x22, 0xce, 0xa2, 0xe9, 0xe5, 0x3b, 0xd7, 0x44, 0xeb, 0x5a, 0x03,
756	0x59, 0xa0, 0xc5, 0x7a, 0x92, 0x59, 0x7d, 0x7a, 0x07, 0x80, 0xfc, 0x4e,
757	0xf8, 0x56, 0x7e, 0xf1, 0x06, 0xe0, 0xba, 0xb2, 0xe7, 0x5b, 0x22, 0x55,
758	0xee, 0x4b, 0x42, 0x61, 0x67, 0x2c, 0x43, 0x9a, 0x38, 0x2b, 0x17, 0xc2,
759	0x62, 0x12, 0x8b, 0x0b, 0x22, 0x8c, 0x0c, 0x1c, 0x1c, 0x92, 0xb1, 0xec,
760	0x70, 0xce, 0x0f, 0x8c, 0xff, 0x8d, 0x21, 0xf9, 0x19, 0x68, 0x4d, 0x32,
761	0x59, 0x78, 0x42, 0x1d, 0x0c, 0xc5, 0x1a, 0xcb, 0x28, 0xe2, 0xc1, 0x1a,
762	0x35, 0xf1, 0x42, 0x0a, 0x19, 0x39, 0xfa, 0x83, 0xd1, 0xb4, 0xaa, 0x69,
763	0x0f, 0xc2, 0x8e, 0xf9, 0x59, 0x2c, 0xee, 0x11, 0xfc, 0x3e, 0x4b, 0x44,
764	0xfb, 0x9a, 0x32, 0xc8, 0x78, 0x23, 0x56, 0x85, 0x49, 0x21, 0x43, 0x12,
765	0x79, 0xbd, 0xa0, 0x70, 0x47, 0x2f, 0xae, 0xb6, 0xd7, 0x6c, 0xc6, 0x07,
766	0x76, 0xa9, 0x8a, 0xa2, 0x16, 0x02, 0x89, 0x1f, 0x1a, 0xd1, 0xa2, 0x96,
767	0x56, 0xd1, 0x1f, 0x10, 0xe1, 0xe5, 0x9f, 0x3f, 0xdd, 0x09, 0x0c, 0x40,
768	0x90, 0x71, 0xef, 0x14, 0x41, 0x02, 0x82, 0x3a, 0x6b, 0xe1, 0xf8, 0x2c,
769	0x5d, 0xbe, 0xfd, 0x1b, 0x02, 0x1d, 0x00, 0xe0, 0x20, 0xe0, 0x7c, 0x02,
770	0x16, 0xa7, 0x6c, 0x6a, 0x19, 0xba, 0xd5, 0x83, 0x73, 0xf3, 0x7d, 0x31,
771	0xef, 0xa7, 0xe1, 0x5d, 0x5b, 0x7f, 0xf3, 0xfc, 0xda, 0x84, 0x31, 0x02,
772	0x82, 0x01, 0x01, 0x00, 0x83, 0xdb, 0xa1, 0xbc, 0x3e, 0xc7, 0x29, 0xa5,
773	0x6a, 0x5c, 0x2c, 0xe8, 0x7a, 0x8c, 0x7e, 0xe8, 0xb8, 0x3e, 0x13, 0x47,
774	0xcd, 0x36, 0x7e, 0x79, 0x30, 0x7a, 0x28, 0x03, 0xd3, 0xd4, 0xd2, 0xe3,
775	0xee, 0x3b, 0x46, 0xda, 0xe0, 0x71, 0xe6, 0xcf, 0x46, 0x86, 0x0a, 0x37,
776	0x57, 0xb6, 0xe9, 0xcf, 0xa1, 0x78, 0x19, 0xb8, 0x72, 0x9f, 0x30, 0x8c,
777	0x2a, 0x04, 0x7c, 0x2f, 0x0c, 0x27, 0xa7, 0xb3, 0x23, 0xe0, 0x46, 0xf2,
778	0x75, 0x0c, 0x03, 0x4c, 0xad, 0xfb, 0xc1, 0xcb, 0x28, 0xcd, 0xa0, 0x63,
779	0xdb, 0x44, 0x88, 0xe0, 0xda, 0x6c, 0x5b, 0x89, 0xb2, 0x5b, 0x40, 0x6d,
780	0xeb, 0x78, 0x7a, 0xd5, 0xaf, 0x40, 0x52, 0x46, 0x63, 0x92, 0x13, 0x0d,
781	0xee, 0xee, 0xf9, 0x53, 0xca, 0x2d, 0x4e, 0x3b, 0x13, 0xd8, 0x0f, 0x50,
782	0xd0, 0x44, 0x57, 0x67, 0x0f, 0x45, 0x8f, 0x21, 0x30, 0x97, 0x9e, 0x80,
783	0xd9, 0xd0, 0x91, 0xb7, 0xc9, 0x5a, 0x69, 0xda, 0xeb, 0xd5, 0xea, 0x37,
784	0xf6, 0xb3, 0xbe, 0x1f, 0x24, 0xf1, 0x55, 0x14, 0x28, 0x05, 0xb5, 0xd8,
785	0x84, 0x0f, 0x62, 0x85, 0xaa, 0xec, 0x77, 0x64, 0xfd, 0x80, 0x7c, 0x41,
786	0x00, 0x88, 0xa3, 0x79, 0x7d, 0x4f, 0x6f, 0xe3, 0x76, 0xf4, 0xb5, 0x97,
787	0xb7, 0xeb, 0x67, 0x28, 0xba, 0x07, 0x1a, 0x59, 0x32, 0xc1, 0x53, 0xd9,
788	0x05, 0x6b, 0x63, 0x93, 0xce, 0xa1, 0xd9, 0x7a, 0xb2, 0xff, 0x1c, 0x12,
789	0x0a, 0x9a, 0xe5, 0x51, 0x1e, 0xba, 0xfc, 0x95, 0x2e, 0x28, 0xa9, 0xfc,
790	0x4c, 0xed, 0x7b, 0x05, 0xca, 0x67, 0xe0, 0x2d, 0xd7, 0x54, 0xb3, 0x05,
791	0x1c, 0x23, 0x2b, 0x35, 0x2e, 0x19, 0x48, 0x59, 0x0e, 0x58, 0xa8, 0x01,
792	0x56, 0xfb, 0x78, 0x90, 0xba, 0x08, 0x77, 0x94, 0x45, 0x05, 0x13, 0xc7,
793	0x6b, 0x96, 0xd2, 0xa3, 0xa6, 0x01, 0x9f, 0x34, 0x02, 0x82, 0x01, 0x00,
794	0x16, 0x1a, 0xb4, 0x6d, 0x9f, 0x16, 0x6c, 0xcc, 0x91, 0x66, 0xfe, 0x30,
795	0xeb, 0x8e, 0x44, 0xba, 0x2b, 0x7a, 0xc9, 0xa8, 0x95, 0xf2, 0xa6, 0x38,
796	0xd8, 0xaf, 0x3e, 0x91, 0x68, 0xe8, 0x52, 0xf3, 0x97, 0x37, 0x70, 0xf2,
797	0x47, 0xa3, 0xf4, 0x62, 0x26, 0xf5, 0x3b, 0x71, 0x52, 0x50, 0x15, 0x9c,
798	0x6d, 0xa6, 0x6d, 0x92, 0x4c, 0x48, 0x76, 0x31, 0x54, 0x48, 0xa5, 0x99,
799	0x7a, 0xd4, 0x61, 0xf7, 0x21, 0x44, 0xe7, 0xd8, 0x82, 0xc3, 0x50, 0xd3,
800	0xd9, 0xd4, 0x66, 0x20, 0xab, 0x70, 0x4c, 0x97, 0x9b, 0x8d, 0xac, 0x1f,
801	0x78, 0x27, 0x1e, 0x47, 0xf8, 0x3b, 0xd1, 0x55, 0x73, 0xf3, 0xb4, 0x8e,
802	0x6d, 0x45, 0x40, 0x54, 0xc6, 0xd8, 0x95, 0x15, 0x27, 0xb7, 0x5f, 0x65,
803	0xaa, 0xcb, 0x24, 0xc9, 0x49, 0x87, 0x32, 0xad, 0xcb, 0xf8, 0x35, 0x63,
804	0x56, 0x72, 0x7c, 0x4e, 0x6c, 0xad, 0x5f, 0x26, 0x8c, 0xd2, 0x80, 0x41,
805	0xaf, 0x88, 0x23, 0x20, 0x03, 0xa4, 0xd5, 0x3c, 0x53, 0x54, 0xb0, 0x3d,
806	0xed, 0x0e, 0x9e, 0x53, 0x0a, 0x63, 0x5f, 0xfd, 0x28, 0x57, 0x09, 0x07,
807	0x73, 0xf4, 0x0c, 0xd4, 0x71, 0x5d, 0x6b, 0xa0, 0xd7, 0x86, 0x99, 0x29,
808	0x9b, 0xca, 0xfb, 0xcc, 0xd6, 0x2f, 0xfe, 0xbe, 0x94, 0xef, 0x1a, 0x0e,
809	0x55, 0x84, 0xa7, 0xaf, 0x7b, 0xfa, 0xed, 0x77, 0x61, 0x28, 0x22, 0xee,
810	0x6b, 0x11, 0xdd, 0xb0, 0x17, 0x1e, 0x06, 0xe4, 0x29, 0x4c, 0xc2, 0x3f,
811	0xd6, 0x75, 0xb6, 0x08, 0x04, 0x55, 0x13, 0x48, 0x4f, 0x44, 0xea, 0x8d,
812	0xaf, 0xcb, 0xac, 0x22, 0xc4, 0x6a, 0xb3, 0x86, 0xe5, 0x47, 0xa9, 0xb5,
813	0x72, 0x17, 0x23, 0x11, 0x81, 0x7f, 0x00, 0x00, 0x67, 0x5c, 0xf4, 0x58,
814	0xcc, 0xe2, 0x46, 0xce, 0xf5, 0x6d, 0xd8, 0x18, 0x91, 0xc4, 0x20, 0xbf,
815	0x07, 0x48, 0x45, 0xfd, 0x02, 0x1c, 0x2f, 0x68, 0x44, 0xcb, 0xfb, 0x6b,
816	0xcb, 0x8d, 0x02, 0x49, 0x7c, 0xee, 0xd2, 0xa6, 0xd3, 0x43, 0xb8, 0xa4,
817	0x09, 0xb7, 0xc1, 0xd4, 0x4b, 0xc3, 0x66, 0xa7, 0xe0, 0x21,
818	};
819	static const unsigned char dsa_p[] = {
820	0x00, 0xda, 0xb3, 0x46, 0x4d, 0x54, 0x57, 0xc7, 0xb4, 0x61, 0xa0, 0x6f, 0x66, 0x17, 0xda,
821	0xeb, 0x90, 0xf0, 0xa3, 0xd1, 0x29, 0xc9, 0x5f, 0xf2, 0x21, 0x3d, 0x85, 0xa3, 0x4a, 0xf0,
822	0xf8, 0x36, 0x39, 0x1b, 0xe3, 0xee, 0x37, 0x70, 0x06, 0x9b, 0xe8, 0xe3, 0x0a, 0xd2, 0xf1,
823	0xf6, 0xc4, 0x42, 0x23, 0x1f, 0x74, 0x78, 0xc2, 0x16, 0xf5, 0xce, 0xd6, 0xab, 0xa0, 0xc6,
824	0xe8, 0x99, 0x3d, 0xf8, 0x8b, 0xfb, 0x47, 0xf8, 0x5e, 0x05, 0x68, 0x6d, 0x8b, 0xa8, 0xad,
825	0xa1, 0xc2, 0x3a, 0x4e, 0xe0, 0xad, 0xec, 0x38, 0x75, 0x21, 0x55, 0x22, 0xce, 0xa2, 0xe9,
826	0xe5, 0x3b, 0xd7, 0x44, 0xeb, 0x5a, 0x03, 0x59, 0xa0, 0xc5, 0x7a, 0x92, 0x59, 0x7d, 0x7a,
827	0x07, 0x80, 0xfc, 0x4e, 0xf8, 0x56, 0x7e, 0xf1, 0x06, 0xe0, 0xba, 0xb2, 0xe7, 0x5b, 0x22,
828	0x55, 0xee, 0x4b, 0x42, 0x61, 0x67, 0x2c, 0x43, 0x9a, 0x38, 0x2b, 0x17, 0xc2, 0x62, 0x12,
829	0x8b, 0x0b, 0x22, 0x8c, 0x0c, 0x1c, 0x1c, 0x92, 0xb1, 0xec, 0x70, 0xce, 0x0f, 0x8c, 0xff,
830	0x8d, 0x21, 0xf9, 0x19, 0x68, 0x4d, 0x32, 0x59, 0x78, 0x42, 0x1d, 0x0c, 0xc5, 0x1a, 0xcb,
831	0x28, 0xe2, 0xc1, 0x1a, 0x35, 0xf1, 0x42, 0x0a, 0x19, 0x39, 0xfa, 0x83, 0xd1, 0xb4, 0xaa,
832	0x69, 0x0f, 0xc2, 0x8e, 0xf9, 0x59, 0x2c, 0xee, 0x11, 0xfc, 0x3e, 0x4b, 0x44, 0xfb, 0x9a,
833	0x32, 0xc8, 0x78, 0x23, 0x56, 0x85, 0x49, 0x21, 0x43, 0x12, 0x79, 0xbd, 0xa0, 0x70, 0x47,
834	0x2f, 0xae, 0xb6, 0xd7, 0x6c, 0xc6, 0x07, 0x76, 0xa9, 0x8a, 0xa2, 0x16, 0x02, 0x89, 0x1f,
835	0x1a, 0xd1, 0xa2, 0x96, 0x56, 0xd1, 0x1f, 0x10, 0xe1, 0xe5, 0x9f, 0x3f, 0xdd, 0x09, 0x0c,
836	0x40, 0x90, 0x71, 0xef, 0x14, 0x41, 0x02, 0x82, 0x3a, 0x6b, 0xe1, 0xf8, 0x2c, 0x5d, 0xbe,
837	0xfd, 0x1b
838	};
839	static const unsigned char dsa_q[] = {
840	0x00, 0xe0, 0x20, 0xe0, 0x7c, 0x02, 0x16, 0xa7, 0x6c, 0x6a, 0x19, 0xba, 0xd5, 0x83, 0x73,
841	0xf3, 0x7d, 0x31, 0xef, 0xa7, 0xe1, 0x5d, 0x5b, 0x7f, 0xf3, 0xfc, 0xda, 0x84, 0x31
842	};
843	static const unsigned char dsa_g[] = {
844	0x00, 0x83, 0xdb, 0xa1, 0xbc, 0x3e, 0xc7, 0x29, 0xa5, 0x6a, 0x5c, 0x2c, 0xe8, 0x7a, 0x8c,
845	0x7e, 0xe8, 0xb8, 0x3e, 0x13, 0x47, 0xcd, 0x36, 0x7e, 0x79, 0x30, 0x7a, 0x28, 0x03, 0xd3,
846	0xd4, 0xd2, 0xe3, 0xee, 0x3b, 0x46, 0xda, 0xe0, 0x71, 0xe6, 0xcf, 0x46, 0x86, 0x0a, 0x37,
847	0x57, 0xb6, 0xe9, 0xcf, 0xa1, 0x78, 0x19, 0xb8, 0x72, 0x9f, 0x30, 0x8c, 0x2a, 0x04, 0x7c,
848	0x2f, 0x0c, 0x27, 0xa7, 0xb3, 0x23, 0xe0, 0x46, 0xf2, 0x75, 0x0c, 0x03, 0x4c, 0xad, 0xfb,
849	0xc1, 0xcb, 0x28, 0xcd, 0xa0, 0x63, 0xdb, 0x44, 0x88, 0xe0, 0xda, 0x6c, 0x5b, 0x89, 0xb2,
850	0x5b, 0x40, 0x6d, 0xeb, 0x78, 0x7a, 0xd5, 0xaf, 0x40, 0x52, 0x46, 0x63, 0x92, 0x13, 0x0d,
851	0xee, 0xee, 0xf9, 0x53, 0xca, 0x2d, 0x4e, 0x3b, 0x13, 0xd8, 0x0f, 0x50, 0xd0, 0x44, 0x57,
852	0x67, 0x0f, 0x45, 0x8f, 0x21, 0x30, 0x97, 0x9e, 0x80, 0xd9, 0xd0, 0x91, 0xb7, 0xc9, 0x5a,
853	0x69, 0xda, 0xeb, 0xd5, 0xea, 0x37, 0xf6, 0xb3, 0xbe, 0x1f, 0x24, 0xf1, 0x55, 0x14, 0x28,
854	0x05, 0xb5, 0xd8, 0x84, 0x0f, 0x62, 0x85, 0xaa, 0xec, 0x77, 0x64, 0xfd, 0x80, 0x7c, 0x41,
855	0x00, 0x88, 0xa3, 0x79, 0x7d, 0x4f, 0x6f, 0xe3, 0x76, 0xf4, 0xb5, 0x97, 0xb7, 0xeb, 0x67,
856	0x28, 0xba, 0x07, 0x1a, 0x59, 0x32, 0xc1, 0x53, 0xd9, 0x05, 0x6b, 0x63, 0x93, 0xce, 0xa1,
857	0xd9, 0x7a, 0xb2, 0xff, 0x1c, 0x12, 0x0a, 0x9a, 0xe5, 0x51, 0x1e, 0xba, 0xfc, 0x95, 0x2e,
858	0x28, 0xa9, 0xfc, 0x4c, 0xed, 0x7b, 0x05, 0xca, 0x67, 0xe0, 0x2d, 0xd7, 0x54, 0xb3, 0x05,
859	0x1c, 0x23, 0x2b, 0x35, 0x2e, 0x19, 0x48, 0x59, 0x0e, 0x58, 0xa8, 0x01, 0x56, 0xfb, 0x78,
860	0x90, 0xba, 0x08, 0x77, 0x94, 0x45, 0x05, 0x13, 0xc7, 0x6b, 0x96, 0xd2, 0xa3, 0xa6, 0x01,
861	0x9f, 0x34
862	};
863	static const unsigned char dsa_priv[] = {
864	0x2f, 0x68, 0x44, 0xcb, 0xfb, 0x6b, 0xcb, 0x8d, 0x02, 0x49, 0x7c, 0xee, 0xd2, 0xa6, 0xd3,
865	0x43, 0xb8, 0xa4, 0x09, 0xb7, 0xc1, 0xd4, 0x4b, 0xc3, 0x66, 0xa7, 0xe0, 0x21
866	};
867	static const unsigned char dsa_pub[] = {
868	0x16, 0x1a, 0xb4, 0x6d, 0x9f, 0x16, 0x6c, 0xcc, 0x91, 0x66, 0xfe, 0x30, 0xeb, 0x8e, 0x44,
869	0xba, 0x2b, 0x7a, 0xc9, 0xa8, 0x95, 0xf2, 0xa6, 0x38, 0xd8, 0xaf, 0x3e, 0x91, 0x68, 0xe8,
870	0x52, 0xf3, 0x97, 0x37, 0x70, 0xf2, 0x47, 0xa3, 0xf4, 0x62, 0x26, 0xf5, 0x3b, 0x71, 0x52,
871	0x50, 0x15, 0x9c, 0x6d, 0xa6, 0x6d, 0x92, 0x4c, 0x48, 0x76, 0x31, 0x54, 0x48, 0xa5, 0x99,
872	0x7a, 0xd4, 0x61, 0xf7, 0x21, 0x44, 0xe7, 0xd8, 0x82, 0xc3, 0x50, 0xd3, 0xd9, 0xd4, 0x66,
873	0x20, 0xab, 0x70, 0x4c, 0x97, 0x9b, 0x8d, 0xac, 0x1f, 0x78, 0x27, 0x1e, 0x47, 0xf8, 0x3b,
874	0xd1, 0x55, 0x73, 0xf3, 0xb4, 0x8e, 0x6d, 0x45, 0x40, 0x54, 0xc6, 0xd8, 0x95, 0x15, 0x27,
875	0xb7, 0x5f, 0x65, 0xaa, 0xcb, 0x24, 0xc9, 0x49, 0x87, 0x32, 0xad, 0xcb, 0xf8, 0x35, 0x63,
876	0x56, 0x72, 0x7c, 0x4e, 0x6c, 0xad, 0x5f, 0x26, 0x8c, 0xd2, 0x80, 0x41, 0xaf, 0x88, 0x23,
877	0x20, 0x03, 0xa4, 0xd5, 0x3c, 0x53, 0x54, 0xb0, 0x3d, 0xed, 0x0e, 0x9e, 0x53, 0x0a, 0x63,
878	0x5f, 0xfd, 0x28, 0x57, 0x09, 0x07, 0x73, 0xf4, 0x0c, 0xd4, 0x71, 0x5d, 0x6b, 0xa0, 0xd7,
879	0x86, 0x99, 0x29, 0x9b, 0xca, 0xfb, 0xcc, 0xd6, 0x2f, 0xfe, 0xbe, 0x94, 0xef, 0x1a, 0x0e,
880	0x55, 0x84, 0xa7, 0xaf, 0x7b, 0xfa, 0xed, 0x77, 0x61, 0x28, 0x22, 0xee, 0x6b, 0x11, 0xdd,
881	0xb0, 0x17, 0x1e, 0x06, 0xe4, 0x29, 0x4c, 0xc2, 0x3f, 0xd6, 0x75, 0xb6, 0x08, 0x04, 0x55,
882	0x13, 0x48, 0x4f, 0x44, 0xea, 0x8d, 0xaf, 0xcb, 0xac, 0x22, 0xc4, 0x6a, 0xb3, 0x86, 0xe5,
883	0x47, 0xa9, 0xb5, 0x72, 0x17, 0x23, 0x11, 0x81, 0x7f, 0x00, 0x00, 0x67, 0x5c, 0xf4, 0x58,
884	0xcc, 0xe2, 0x46, 0xce, 0xf5, 0x6d, 0xd8, 0x18, 0x91, 0xc4, 0x20, 0xbf, 0x07, 0x48, 0x45,
885	0xfd
886	};
887
888	static int do_check_params(OSSL_PARAM key_params[], int expected)
889	{
890	EVP_PKEY_CTX gen_ctx = NULL, check_ctx = NULL;
891	EVP_PKEY *pkey = NULL;
892	int ret;
893
894	ret = TEST_ptr(gen_ctx = EVP_PKEY_CTX_new_from_name(mainctx, "DSA", NULL))
895	&& TEST_int_eq(EVP_PKEY_fromdata_init(gen_ctx), 1)
896	&& TEST_int_eq(EVP_PKEY_fromdata(gen_ctx, &pkey,
897	EVP_PKEY_KEYPAIR, key_params), 1)
898	&& TEST_ptr(check_ctx = EVP_PKEY_CTX_new_from_pkey(mainctx, pkey,
899	NULL))
900	&& TEST_int_eq(EVP_PKEY_param_check(check_ctx), expected);
901	EVP_PKEY_CTX_free(check_ctx);
902	EVP_PKEY_CTX_free(gen_ctx);
903	EVP_PKEY_free(pkey);
904	return ret;
905	}
906
907	static int do_check_bn(OSSL_PARAM params[], const char *key,
908	const unsigned char *expected, size_t expected_len)
909	{
910	OSSL_PARAM *p;
911	BIGNUM *bn = NULL;
912	unsigned char buffer[256 + 1];
913	int ret, len;
914
915	ret = TEST_ptr(p = OSSL_PARAM_locate(params, key))
916	&& TEST_true(OSSL_PARAM_get_BN(p, &bn))
917	&& TEST_int_gt(len = BN_bn2binpad(bn, buffer, expected_len), 0)
918	&& TEST_mem_eq(expected, expected_len, buffer, len);
919	BN_free(bn);
920	return ret;
921	}
922
923	static int do_check_int(OSSL_PARAM params[], const char *key, int expected)
924	{
925	OSSL_PARAM *p;
926	int val = 0;
927
928	return TEST_ptr(p = OSSL_PARAM_locate(params, key))
929	&& TEST_true(OSSL_PARAM_get_int(p, &val))
930	&& TEST_int_eq(val, expected);
931	}
932
933	static int test_dsa_tofrom_data_select(void)
934	{
935	int ret;
936	EVP_PKEY *key = NULL;
937	const unsigned char *pkeydata = dsa_key;
938
939	ret = TEST_ptr(key = d2i_AutoPrivateKey_ex(NULL, &pkeydata, sizeof(dsa_key),
940	mainctx, NULL))
941	&& TEST_true(do_pkey_tofrom_data_select(key, "DSA"));
942
943	EVP_PKEY_free(key);
944	return ret;
945	}
946
947	static int test_dsa_todata(void)
948	{
949	EVP_PKEY *pkey = NULL;
950	OSSL_PARAM to_params = NULL, all_params = NULL;
951	OSSL_PARAM gen_params[4];
952	int ret = 0;
953	const unsigned char *pkeydata = dsa_key;
954
955	unsigned char dsa_seed[] = {
956	0xbc, 0x8a, 0x81, 0x64, 0x9e, 0x9d, 0x63, 0xa7, 0xa3, 0x5d, 0x87, 0xdd,
957	0x32, 0xf3, 0xc1, 0x9f, 0x18, 0x22, 0xeb, 0x73, 0x63, 0xad, 0x5e, 0x7b,
958	0x90, 0xc1, 0xe3, 0xe0
959	};
960	int dsa_pcounter = 319;
961	int dsa_gindex = 5;
962
963	gen_params[0] = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_FFC_SEED,
964	(void*)dsa_seed,
965	sizeof(dsa_seed));
966	gen_params[1] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_GINDEX,
967	&dsa_gindex);
968	gen_params[2] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_PCOUNTER,
969	&dsa_pcounter);
970	gen_params[3] = OSSL_PARAM_construct_end();
971
972	if (!TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pkeydata, sizeof(dsa_key),
973	mainctx, NULL))
974	\|\| !TEST_int_eq(EVP_PKEY_todata(pkey, EVP_PKEY_KEYPAIR, &to_params), 1)
975	\|\| !do_check_bn(to_params, OSSL_PKEY_PARAM_FFC_P, dsa_p, sizeof(dsa_p))
976	\|\| !do_check_bn(to_params, OSSL_PKEY_PARAM_FFC_Q, dsa_q, sizeof(dsa_q))
977	\|\| !do_check_bn(to_params, OSSL_PKEY_PARAM_FFC_G, dsa_g, sizeof(dsa_g))
978	\|\| !do_check_bn(to_params, OSSL_PKEY_PARAM_PUB_KEY, dsa_pub,
979	sizeof(dsa_pub))
980	\|\| !do_check_bn(to_params, OSSL_PKEY_PARAM_PRIV_KEY, dsa_priv,
981	sizeof(dsa_priv))
982	\|\| !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_GINDEX, -1)
983	\|\| !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_PCOUNTER, -1)
984	\|\| !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_H, 0)
985	\|\| !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_VALIDATE_PQ, 1)
986	\|\| !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_VALIDATE_G, 1)
987	\|\| !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_VALIDATE_LEGACY, 0)
988	\|\| !TEST_ptr_null(OSSL_PARAM_locate(to_params, OSSL_PKEY_PARAM_FFC_SEED)))
989	goto err;
990
991	if (!do_fromdata_key_is_equal(to_params, pkey, "DSA"))
992	goto err;
993
994	if (!TEST_ptr(all_params = OSSL_PARAM_merge(to_params, gen_params))
995	\|\| !do_check_params(all_params, 1))
996	goto err;
997	gen_params[1] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_GINDEX,
998	&dsa_gindex);
999	gen_params[2] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_PCOUNTER,
1000	&dsa_pcounter);
1001	/*
1002	* Check that modifying the shallow copy values used in OSSL_PARAM_merge()
1003	* results in an invalid key. This also verifies that the fips186-4
1004	* validation code is running.
1005	*/
1006	dsa_gindex++;
1007	if (!do_check_params(all_params, 0))
1008	goto err;
1009	dsa_gindex--;
1010	dsa_pcounter++;
1011	if (!do_check_params(all_params, 0))
1012	goto err;
1013	dsa_pcounter--;
1014	dsa_seed[0] = 0xb0;
1015	if (!do_check_params(all_params, 0))
1016	goto err;
1017
1018	ret = 1;
1019	err:
1020	EVP_PKEY_free(pkey);
1021	OSSL_PARAM_free(all_params);
1022	OSSL_PARAM_free(to_params);
1023	return ret;
1024	}
1025
1026	/*
1027	* Test that OSSL_PKEY_PARAM_FFC_DIGEST_PROPS is set properly when using fromdata
1028	* This test:
1029	* checks for failure when the property query is bad (tstid == 0)
1030	* checks for success when the property query is valid (tstid == 1)
1031	*/
1032	static int test_dsa_fromdata_digest_prop(int tstid)
1033	{
1034	EVP_PKEY_CTX ctx = NULL, gctx = NULL;
1035	EVP_PKEY pkey = NULL, pkey2 = NULL;
1036	OSSL_PARAM params[4], *p = params;
1037	int ret = 0;
1038	int expected = (tstid == 0 ? 0 : 1);
1039	unsigned int pbits = 512; /* minimum allowed for speed */
1040
1041	*p++ = OSSL_PARAM_construct_uint(OSSL_PKEY_PARAM_FFC_PBITS, &pbits);
1042	*p++ = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_FFC_DIGEST, "SHA512", 0);
1043	/* Setting a bad prop query here should fail during paramgen - when it tries to do a fetch */
1044	*p++ = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_FFC_DIGEST_PROPS,
1045	tstid == 0 ? "provider=unknown" : "provider=default", 0);
1046	*p++ = OSSL_PARAM_construct_end();
1047
1048	if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(mainctx, "DSA", NULL))
1049	\|\| !TEST_int_eq(EVP_PKEY_fromdata_init(ctx), 1)
1050	\|\| !TEST_int_eq(EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_KEY_PARAMETERS, params), 1))
1051	goto err;
1052
1053	if (!TEST_ptr(gctx = EVP_PKEY_CTX_new_from_pkey(mainctx, pkey, NULL))
1054	\|\| !TEST_int_eq(EVP_PKEY_paramgen_init(gctx), 1)
1055	\|\| !TEST_int_eq(EVP_PKEY_paramgen(gctx, &pkey2), expected))
1056	goto err;
1057
1058	ret = 1;
1059	err:
1060	EVP_PKEY_free(pkey2);
1061	EVP_PKEY_free(pkey);
1062	EVP_PKEY_CTX_free(ctx);
1063	EVP_PKEY_CTX_free(gctx);
1064	return ret;
1065	}
1066	#endif /* OPENSSL_NO_DSA */
1067
1068	static int test_pkey_todata_null(void)
1069	{
1070	OSSL_PARAM *params = NULL;
1071	EVP_PKEY *pkey = NULL;
1072	int ret = 0;
1073	const unsigned char *pdata = keydata[0].kder;
1074
1075	ret = TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, keydata[0].size,
1076	mainctx, NULL))
1077	&& TEST_int_eq(EVP_PKEY_todata(NULL, EVP_PKEY_KEYPAIR, &params), 0)
1078	&& TEST_int_eq(EVP_PKEY_todata(pkey, EVP_PKEY_KEYPAIR, NULL), 0);
1079	EVP_PKEY_free(pkey);
1080	return ret;
1081	}
1082
1083	static OSSL_CALLBACK test_pkey_export_cb;
1084
1085	static int test_pkey_export_cb(const OSSL_PARAM params[], void *arg)
1086	{
1087	if (arg == NULL)
1088	return 0;
1089	return do_fromdata_key_is_equal(params, (EVP_PKEY *)arg, "RSA");
1090	}
1091
1092	static int test_pkey_export_null(void)
1093	{
1094	EVP_PKEY *pkey = NULL;
1095	int ret = 0;
1096	const unsigned char *pdata = keydata[0].kder;
1097
1098	ret = TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, keydata[0].size,
1099	mainctx, NULL))
1100	&& TEST_int_eq(EVP_PKEY_export(NULL, EVP_PKEY_KEYPAIR,
1101	test_pkey_export_cb, NULL), 0)
1102	&& TEST_int_eq(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR, NULL, NULL), 0);
1103	EVP_PKEY_free(pkey);
1104	return ret;
1105	}
1106
1107	static int test_pkey_export(void)
1108	{
1109	EVP_PKEY *pkey = NULL;
1110	#ifndef OPENSSL_NO_DEPRECATED_3_0
1111	RSA *rsa = NULL;
1112	#endif
1113	int ret = 1;
1114	const unsigned char *pdata = keydata[0].kder;
1115	int pdata_len = keydata[0].size;
1116
1117	if (!TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, pdata_len,
1118	mainctx, NULL))
1119	\|\| !TEST_true(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR,
1120	test_pkey_export_cb, pkey))
1121	\|\| !TEST_false(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR,
1122	test_pkey_export_cb, NULL)))
1123	ret = 0;
1124	EVP_PKEY_free(pkey);
1125
1126	#ifndef OPENSSL_NO_DEPRECATED_3_0
1127	/* Now, try with a legacy key */
1128	pdata = keydata[0].kder;
1129	pdata_len = keydata[0].size;
1130	if (!TEST_ptr(rsa = d2i_RSAPrivateKey(NULL, &pdata, pdata_len))
1131	\|\| !TEST_ptr(pkey = EVP_PKEY_new())
1132	\|\| !TEST_true(EVP_PKEY_assign_RSA(pkey, rsa))
1133	\|\| !TEST_true(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR,
1134	test_pkey_export_cb, pkey))
1135	\|\| !TEST_false(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR,
1136	test_pkey_export_cb, NULL)))
1137	ret = 0;
1138	EVP_PKEY_free(pkey);
1139	#endif
1140	return ret;
1141	}
1142
1143	static int test_rsa_pss_sign(void)
1144	{
1145	EVP_PKEY *pkey = NULL;
1146	EVP_PKEY_CTX *pctx = NULL;
1147	int ret = 0;
1148	const unsigned char *pdata = keydata[0].kder;
1149	const char *mdname = "SHA2-256";
1150	OSSL_PARAM sig_params[3];
1151	unsigned char mdbuf[256 / 8] = { 0 };
1152	int padding = RSA_PKCS1_PSS_PADDING;
1153	unsigned char *sig = NULL;
1154	size_t sig_len = 0;
1155
1156	sig_params[0] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_PAD_MODE,
1157	&padding);
1158	sig_params[1] = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
1159	(char *)mdname, 0);
1160	sig_params[2] = OSSL_PARAM_construct_end();
1161
1162	ret = TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, keydata[0].size,
1163	mainctx, NULL))
1164	&& TEST_ptr(pctx = EVP_PKEY_CTX_new_from_pkey(mainctx, pkey, NULL))
1165	&& TEST_int_gt(EVP_PKEY_sign_init_ex(pctx, sig_params), 0)
1166	&& TEST_int_gt(EVP_PKEY_sign(pctx, NULL, &sig_len, mdbuf,
1167	sizeof(mdbuf)), 0)
1168	&& TEST_int_gt(sig_len, 0)
1169	&& TEST_ptr(sig = OPENSSL_malloc(sig_len))
1170	&& TEST_int_gt(EVP_PKEY_sign(pctx, sig, &sig_len, mdbuf,
1171	sizeof(mdbuf)), 0);
1172
1173	EVP_PKEY_CTX_free(pctx);
1174	OPENSSL_free(sig);
1175	EVP_PKEY_free(pkey);
1176
1177	return ret;
1178	}
1179
1180	static int test_evp_md_ctx_dup(void)
1181	{
1182	EVP_MD_CTX *mdctx;
1183	EVP_MD_CTX *copyctx = NULL;
1184	int ret;
1185
1186	/* test copying freshly initialized context */
1187	ret = TEST_ptr(mdctx = EVP_MD_CTX_new())
1188	&& TEST_ptr(copyctx = EVP_MD_CTX_dup(mdctx));
1189
1190	EVP_MD_CTX_free(mdctx);
1191	EVP_MD_CTX_free(copyctx);
1192	return ret;
1193	}
1194
1195	static int test_evp_md_ctx_copy(void)
1196	{
1197	EVP_MD_CTX *mdctx = NULL;
1198	EVP_MD_CTX *copyctx = NULL;
1199	int ret;
1200
1201	/* test copying freshly initialized context */
1202	ret = TEST_ptr(mdctx = EVP_MD_CTX_new())
1203	&& TEST_ptr(copyctx = EVP_MD_CTX_new())
1204	&& TEST_true(EVP_MD_CTX_copy_ex(copyctx, mdctx));
1205
1206	EVP_MD_CTX_free(mdctx);
1207	EVP_MD_CTX_free(copyctx);
1208	return ret;
1209	}
1210
1211	#if !defined OPENSSL_NO_DES && !defined OPENSSL_NO_MD5
1212	static int test_evp_pbe_alg_add(void)
1213	{
1214	int ret = 0;
1215	int cipher_nid = 0, md_nid = 0;
1216	EVP_PBE_KEYGEN_EX *keygen_ex = NULL;
1217	EVP_PBE_KEYGEN *keygen = NULL;
1218
1219	if (!TEST_true(EVP_PBE_alg_add(NID_pbeWithMD5AndDES_CBC, EVP_des_cbc(), EVP_md5(),
1220	PKCS5_PBE_keyivgen)))
1221	goto err;
1222
1223	if (!TEST_true(EVP_PBE_find_ex(EVP_PBE_TYPE_OUTER, NID_pbeWithMD5AndDES_CBC,
1224	&cipher_nid, &md_nid, &keygen, &keygen_ex)))
1225	goto err;
1226
1227	if (!TEST_true(keygen != NULL))
1228	goto err;
1229	if (!TEST_true(keygen_ex == NULL))
1230	goto err;
1231
1232	ret = 1;
1233
1234	err:
1235	return ret;
1236	}
1237	#endif
1238
1239	/*
1240	* Currently, EVP_<OBJ>_fetch doesn't support
1241	* colon separated alternative names for lookup
1242	* so add a test here to ensure that when one is provided
1243	* libcrypto returns an error
1244	*/
1245	static int evp_test_name_parsing(void)
1246	{
1247	EVP_MD *md;
1248
1249	if (!TEST_ptr_null(md = EVP_MD_fetch(mainctx, "SHA256:BogusName", NULL))) {
1250	EVP_MD_free(md);
1251	return 0;
1252	}
1253
1254	return 1;
1255	}
1256
1257	int setup_tests(void)
1258	{
1259	if (!test_get_libctx(&mainctx, &nullprov, NULL, NULL, NULL)) {
1260	OSSL_LIB_CTX_free(mainctx);
1261	mainctx = NULL;
1262	return 0;
1263	}
1264
1265	ADD_TEST(evp_test_name_parsing);
1266	ADD_TEST(test_alternative_default);
1267	ADD_ALL_TESTS(test_d2i_AutoPrivateKey_ex, OSSL_NELEM(keydata));
1268	#ifndef OPENSSL_NO_EC
1269	ADD_ALL_TESTS(test_d2i_PrivateKey_ex, 2);
1270	ADD_TEST(test_ec_tofrom_data_select);
1271	ADD_TEST(test_ecx_tofrom_data_select);
1272	#else
1273	ADD_ALL_TESTS(test_d2i_PrivateKey_ex, 1);
1274	#endif
1275	#ifndef OPENSSL_NO_SM2
1276	ADD_TEST(test_sm2_tofrom_data_select);
1277	#endif
1278	#ifndef OPENSSL_NO_DSA
1279	ADD_TEST(test_dsa_todata);
1280	ADD_TEST(test_dsa_tofrom_data_select);
1281	ADD_ALL_TESTS(test_dsa_fromdata_digest_prop, 2);
1282	#endif
1283	#ifndef OPENSSL_NO_DH
1284	ADD_TEST(test_dh_tofrom_data_select);
1285	ADD_TEST(test_dh_paramgen);
1286	#endif
1287	ADD_TEST(test_rsa_tofrom_data_select);
1288
1289	ADD_TEST(test_pkey_todata_null);
1290	ADD_TEST(test_pkey_export_null);
1291	ADD_TEST(test_pkey_export);
1292	#ifndef OPENSSL_NO_DES
1293	ADD_TEST(test_pkcs8key_nid_bio);
1294	#endif
1295	ADD_ALL_TESTS(test_PEM_read_bio_negative, OSSL_NELEM(keydata));
1296	ADD_ALL_TESTS(test_PEM_read_bio_negative_wrong_password, 2);
1297	ADD_TEST(test_rsa_pss_sign);
1298	ADD_TEST(test_evp_md_ctx_dup);
1299	ADD_TEST(test_evp_md_ctx_copy);
1300	ADD_ALL_TESTS(test_provider_unload_effective, 2);
1301	#if !defined OPENSSL_NO_DES && !defined OPENSSL_NO_MD5
1302	ADD_TEST(test_evp_pbe_alg_add);
1303	#endif
1304	return 1;
1305	}
1306
1307	void cleanup_tests(void)
1308	{
1309	OSSL_LIB_CTX_free(mainctx);
1310	OSSL_PROVIDER_unload(nullprov);
1311	}

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

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

Download in other formats: