evp_extra_test.c@ 96408

最後變更在這個檔案從96408是 95219,由 vboxsync 提交於 3 年前
libs/openssl: Switched to v3.0.3, bugref:10128
檔案大小: 153.5 KB

行
1	/*
2	* Copyright 2015-2022 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	#include <stdio.h>
14	#include <stdlib.h>
15	#include <string.h>
16	#include <openssl/bio.h>
17	#include <openssl/conf.h>
18	#include <openssl/crypto.h>
19	#include <openssl/err.h>
20	#include <openssl/evp.h>
21	#include <openssl/x509.h>
22	#include <openssl/pem.h>
23	#include <openssl/kdf.h>
24	#include <openssl/provider.h>
25	#include <openssl/core_names.h>
26	#include <openssl/params.h>
27	#include <openssl/param_build.h>
28	#include <openssl/dsa.h>
29	#include <openssl/dh.h>
30	#include <openssl/aes.h>
31	#include <openssl/decoder.h>
32	#include <openssl/rsa.h>
33	#include <openssl/engine.h>
34	#include "testutil.h"
35	#include "internal/nelem.h"
36	#include "internal/sizes.h"
37	#include "crypto/evp.h"
38
39	static OSSL_LIB_CTX *testctx = NULL;
40	static char *testpropq = NULL;
41
42	static OSSL_PROVIDER *nullprov = NULL;
43	static OSSL_PROVIDER *deflprov = NULL;
44	static OSSL_PROVIDER *lgcyprov = NULL;
45
46	/*
47	* kExampleRSAKeyDER is an RSA private key in ASN.1, DER format. Of course, you
48	* should never use this key anywhere but in an example.
49	*/
50	static const unsigned char kExampleRSAKeyDER[] = {
51	0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xf8,
52	0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5, 0xb4, 0x59,
53	0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e, 0xd3, 0x37,
54	0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34, 0x75, 0x71,
55	0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde, 0x97, 0x8a,
56	0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8, 0x50, 0xe4,
57	0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b, 0xdc, 0xec,
58	0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83, 0x58, 0x76,
59	0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48, 0x1a, 0xd8,
60	0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a, 0x5c, 0xd7,
61	0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2, 0xa7, 0x2c,
62	0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01, 0x00, 0x01,
63	0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a, 0x6d, 0xc7,
64	0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5, 0x32, 0x85,
65	0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6, 0x5f, 0xee,
66	0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8, 0x66, 0x85,
67	0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6, 0xa4, 0x0a,
68	0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f, 0xc2, 0x15,
69	0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c, 0x5b, 0x83,
70	0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78, 0x80, 0x1b,
71	0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71, 0x99, 0x73,
72	0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60, 0x1f, 0x99,
73	0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d, 0xb1, 0x02,
74	0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3, 0x40, 0x41,
75	0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d, 0x3d, 0x59,
76	0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18, 0xc6, 0xd9,
77	0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d, 0x9f, 0xef,
78	0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32, 0x46, 0x87,
79	0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc, 0x2c, 0xdf,
80	0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63, 0x55, 0xf5,
81	0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05, 0xcd, 0xb5,
82	0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16, 0xb3, 0x62,
83	0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3, 0x9b, 0x64,
84	0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85, 0xfa, 0xb8,
85	0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97, 0xe8, 0xba,
86	0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7, 0xe7, 0xfe,
87	0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99, 0x75, 0xe7,
88	0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4, 0x9d, 0xfe,
89	0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d, 0xf1, 0xdb,
90	0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40, 0x5a, 0x34,
91	0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26, 0x84, 0x27,
92	0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1, 0xe9, 0xc0,
93	0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c, 0xb9, 0xba,
94	0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30, 0x10, 0x06,
95	0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea, 0x52, 0x2c,
96	0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b, 0xc4, 0x1e,
97	0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e, 0x49, 0xaf,
98	0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9, 0xd1, 0x8a,
99	0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae, 0x17, 0x17,
100	0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d, 0x08, 0xf1,
101	0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
102	};
103
104	/*
105	* kExampleDSAKeyDER is a DSA private key in ASN.1, DER format. Of course, you
106	* should never use this key anywhere but in an example.
107	*/
108	#ifndef OPENSSL_NO_DSA
109	static const unsigned char kExampleDSAKeyDER[] = {
110	0x30, 0x82, 0x01, 0xba, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0x9a,
111	0x05, 0x6d, 0x33, 0xcd, 0x5d, 0x78, 0xa1, 0xbb, 0xcb, 0x7d, 0x5b, 0x8d,
112	0xb4, 0xcc, 0xbf, 0x03, 0x99, 0x64, 0xde, 0x38, 0x78, 0x06, 0x15, 0x2f,
113	0x86, 0x26, 0x77, 0xf3, 0xb1, 0x85, 0x00, 0xed, 0xfc, 0x28, 0x3a, 0x42,
114	0x4d, 0xab, 0xab, 0xdf, 0xbc, 0x9c, 0x16, 0xd0, 0x22, 0x50, 0xd1, 0x38,
115	0xdd, 0x3f, 0x64, 0x05, 0x9e, 0x68, 0x7a, 0x1e, 0xf1, 0x56, 0xbf, 0x1e,
116	0x2c, 0xc5, 0x97, 0x2a, 0xfe, 0x7a, 0x22, 0xdc, 0x6c, 0x68, 0xb8, 0x2e,
117	0x06, 0xdb, 0x41, 0xca, 0x98, 0xd8, 0x54, 0xc7, 0x64, 0x48, 0x24, 0x04,
118	0x20, 0xbc, 0x59, 0xe3, 0x6b, 0xea, 0x7e, 0xfc, 0x7e, 0xc5, 0x4e, 0xd4,
119	0xd8, 0x3a, 0xed, 0xcd, 0x5d, 0x99, 0xb8, 0x5c, 0xa2, 0x8b, 0xbb, 0x0b,
120	0xac, 0xe6, 0x8e, 0x25, 0x56, 0x22, 0x3a, 0x2d, 0x3a, 0x56, 0x41, 0x14,
121	0x1f, 0x1c, 0x8f, 0x53, 0x46, 0x13, 0x85, 0x02, 0x15, 0x00, 0x98, 0x7e,
122	0x92, 0x81, 0x88, 0xc7, 0x3f, 0x70, 0x49, 0x54, 0xf6, 0x76, 0xb4, 0xa3,
123	0x9e, 0x1d, 0x45, 0x98, 0x32, 0x7f, 0x02, 0x81, 0x80, 0x69, 0x4d, 0xef,
124	0x55, 0xff, 0x4d, 0x59, 0x2c, 0x01, 0xfa, 0x6a, 0x38, 0xe0, 0x70, 0x9f,
125	0x9e, 0x66, 0x8e, 0x3e, 0x8c, 0x52, 0x22, 0x9d, 0x15, 0x7e, 0x3c, 0xef,
126	0x4c, 0x7a, 0x61, 0x26, 0xe0, 0x2b, 0x81, 0x3f, 0xeb, 0xaf, 0x35, 0x38,
127	0x8d, 0xfe, 0xed, 0x46, 0xff, 0x5f, 0x03, 0x9b, 0x81, 0x92, 0xe7, 0x6f,
128	0x76, 0x4f, 0x1d, 0xd9, 0xbb, 0x89, 0xc9, 0x3e, 0xd9, 0x0b, 0xf9, 0xf4,
129	0x78, 0x11, 0x59, 0xc0, 0x1d, 0xcd, 0x0e, 0xa1, 0x6f, 0x15, 0xf1, 0x4d,
130	0xc1, 0xc9, 0x22, 0xed, 0x8d, 0xad, 0x67, 0xc5, 0x4b, 0x95, 0x93, 0x86,
131	0xa6, 0xaf, 0x8a, 0xee, 0x06, 0x89, 0x2f, 0x37, 0x7e, 0x64, 0xaa, 0xf6,
132	0xe7, 0xb1, 0x5a, 0x0a, 0x93, 0x95, 0x5d, 0x3e, 0x53, 0x9a, 0xde, 0x8a,
133	0xc2, 0x95, 0x45, 0x81, 0xbe, 0x5c, 0x2f, 0xc2, 0xb2, 0x92, 0x58, 0x19,
134	0x72, 0x80, 0xe9, 0x79, 0xa1, 0x02, 0x81, 0x80, 0x07, 0xd7, 0x62, 0xff,
135	0xdf, 0x1a, 0x3f, 0xed, 0x32, 0xd4, 0xd4, 0x88, 0x7b, 0x2c, 0x63, 0x7f,
136	0x97, 0xdc, 0x44, 0xd4, 0x84, 0xa2, 0xdd, 0x17, 0x16, 0x85, 0x13, 0xe0,
137	0xac, 0x51, 0x8d, 0x29, 0x1b, 0x75, 0x9a, 0xe4, 0xe3, 0x8a, 0x92, 0x69,
138	0x09, 0x03, 0xc5, 0x68, 0xae, 0x5e, 0x94, 0xfe, 0xc9, 0x92, 0x6c, 0x07,
139	0xb4, 0x1e, 0x64, 0x62, 0x87, 0xc6, 0xa4, 0xfd, 0x0d, 0x5f, 0xe5, 0xf9,
140	0x1b, 0x4f, 0x85, 0x5f, 0xae, 0xf3, 0x11, 0xe5, 0x18, 0xd4, 0x4d, 0x79,
141	0x9f, 0xc4, 0x79, 0x26, 0x04, 0x27, 0xf0, 0x0b, 0xee, 0x2b, 0x86, 0x9f,
142	0x86, 0x61, 0xe6, 0x51, 0xce, 0x04, 0x9b, 0x5d, 0x6b, 0x34, 0x43, 0x8c,
143	0x85, 0x3c, 0xf1, 0x51, 0x9b, 0x08, 0x23, 0x1b, 0xf5, 0x7e, 0x33, 0x12,
144	0xea, 0xab, 0x1f, 0xb7, 0x2d, 0xe2, 0x5f, 0xe6, 0x97, 0x99, 0xb5, 0x45,
145	0x16, 0x5b, 0xc3, 0x41, 0x02, 0x14, 0x61, 0xbf, 0x51, 0x60, 0xcf, 0xc8,
146	0xf1, 0x8c, 0x82, 0x97, 0xf2, 0xf4, 0x19, 0xba, 0x2b, 0xf3, 0x16, 0xbe,
147	0x40, 0x48
148	};
149	#endif
150
151	/*
152	* kExampleBadRSAKeyDER is an RSA private key in ASN.1, DER format. The private
153	* components are not correct.
154	*/
155	static const unsigned char kExampleBadRSAKeyDER[] = {
156	0x30, 0x82, 0x04, 0x27, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x01, 0x00,
157	0xa6, 0x1a, 0x1e, 0x6e, 0x7b, 0xee, 0xc6, 0x89, 0x66, 0xe7, 0x93, 0xef,
158	0x54, 0x12, 0x68, 0xea, 0xbf, 0x86, 0x2f, 0xdd, 0xd2, 0x79, 0xb8, 0xa9,
159	0x6e, 0x03, 0xc2, 0xa3, 0xb9, 0xa3, 0xe1, 0x4b, 0x2a, 0xb3, 0xf8, 0xb4,
160	0xcd, 0xea, 0xbe, 0x24, 0xa6, 0x57, 0x5b, 0x83, 0x1f, 0x0f, 0xf2, 0xd3,
161	0xb7, 0xac, 0x7e, 0xd6, 0x8e, 0x6e, 0x1e, 0xbf, 0xb8, 0x73, 0x8c, 0x05,
162	0x56, 0xe6, 0x35, 0x1f, 0xe9, 0x04, 0x0b, 0x09, 0x86, 0x7d, 0xf1, 0x26,
163	0x08, 0x99, 0xad, 0x7b, 0xc8, 0x4d, 0x94, 0xb0, 0x0b, 0x8b, 0x38, 0xa0,
164	0x5c, 0x62, 0xa0, 0xab, 0xd3, 0x8f, 0xd4, 0x09, 0x60, 0x72, 0x1e, 0x33,
165	0x50, 0x80, 0x6e, 0x22, 0xa6, 0x77, 0x57, 0x6b, 0x9a, 0x33, 0x21, 0x66,
166	0x87, 0x6e, 0x21, 0x7b, 0xc7, 0x24, 0x0e, 0xd8, 0x13, 0xdf, 0x83, 0xde,
167	0xcd, 0x40, 0x58, 0x1d, 0x84, 0x86, 0xeb, 0xb8, 0x12, 0x4e, 0xd2, 0xfa,
168	0x80, 0x1f, 0xe4, 0xe7, 0x96, 0x29, 0xb8, 0xcc, 0xce, 0x66, 0x6d, 0x53,
169	0xca, 0xb9, 0x5a, 0xd7, 0xf6, 0x84, 0x6c, 0x2d, 0x9a, 0x1a, 0x14, 0x1c,
170	0x4e, 0x93, 0x39, 0xba, 0x74, 0xed, 0xed, 0x87, 0x87, 0x5e, 0x48, 0x75,
171	0x36, 0xf0, 0xbc, 0x34, 0xfb, 0x29, 0xf9, 0x9f, 0x96, 0x5b, 0x0b, 0xa7,
172	0x54, 0x30, 0x51, 0x29, 0x18, 0x5b, 0x7d, 0xac, 0x0f, 0xd6, 0x5f, 0x7c,
173	0xf8, 0x98, 0x8c, 0xd8, 0x86, 0x62, 0xb3, 0xdc, 0xff, 0x0f, 0xff, 0x7a,
174	0xaf, 0x5c, 0x4c, 0x61, 0x49, 0x2e, 0xc8, 0x95, 0x86, 0xc4, 0x0e, 0x87,
175	0xfc, 0x1d, 0xcf, 0x8b, 0x7c, 0x61, 0xf6, 0xd8, 0xd0, 0x69, 0xf6, 0xcd,
176	0x8a, 0x8c, 0xf6, 0x62, 0xa2, 0x56, 0xa9, 0xe3, 0xd1, 0xcf, 0x4d, 0xa0,
177	0xf6, 0x2d, 0x20, 0x0a, 0x04, 0xb7, 0xa2, 0xf7, 0xb5, 0x99, 0x47, 0x18,
178	0x56, 0x85, 0x87, 0xc7, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x82, 0x01,
179	0x01, 0x00, 0x99, 0x41, 0x38, 0x1a, 0xd0, 0x96, 0x7a, 0xf0, 0x83, 0xd5,
180	0xdf, 0x94, 0xce, 0x89, 0x3d, 0xec, 0x7a, 0x52, 0x21, 0x10, 0x16, 0x06,
181	0xe0, 0xee, 0xd2, 0xe6, 0xfd, 0x4b, 0x7b, 0x19, 0x4d, 0xe1, 0xc0, 0xc0,
182	0xd5, 0x14, 0x5d, 0x79, 0xdd, 0x7e, 0x8b, 0x4b, 0xc6, 0xcf, 0xb0, 0x75,
183	0x52, 0xa3, 0x2d, 0xb1, 0x26, 0x46, 0x68, 0x9c, 0x0a, 0x1a, 0xf2, 0xe1,
184	0x09, 0xac, 0x53, 0x85, 0x8c, 0x36, 0xa9, 0x14, 0x65, 0xea, 0xa0, 0x00,
185	0xcb, 0xe3, 0x3f, 0xc4, 0x2b, 0x61, 0x2e, 0x6b, 0x06, 0x69, 0x77, 0xfd,
186	0x38, 0x7e, 0x1d, 0x3f, 0x92, 0xe7, 0x77, 0x08, 0x19, 0xa7, 0x9d, 0x29,
187	0x2d, 0xdc, 0x42, 0xc6, 0x7c, 0xd7, 0xd3, 0xa8, 0x01, 0x2c, 0xf2, 0xd5,
188	0x82, 0x57, 0xcb, 0x55, 0x3d, 0xe7, 0xaa, 0xd2, 0x06, 0x30, 0x30, 0x05,
189	0xe6, 0xf2, 0x47, 0x86, 0xba, 0xc6, 0x61, 0x64, 0xeb, 0x4f, 0x2a, 0x5e,
190	0x07, 0x29, 0xe0, 0x96, 0xb2, 0x43, 0xff, 0x5f, 0x1a, 0x54, 0x16, 0xcf,
191	0xb5, 0x56, 0x5c, 0xa0, 0x9b, 0x0c, 0xfd, 0xb3, 0xd2, 0xe3, 0x79, 0x1d,
192	0x21, 0xe2, 0xd6, 0x13, 0xc4, 0x74, 0xa6, 0xf5, 0x8e, 0x8e, 0x81, 0xbb,
193	0xb4, 0xad, 0x8a, 0xf0, 0x93, 0x0a, 0xd8, 0x0a, 0x42, 0x36, 0xbc, 0xe5,
194	0x26, 0x2a, 0x0d, 0x5d, 0x57, 0x13, 0xc5, 0x4e, 0x2f, 0x12, 0x0e, 0xef,
195	0xa7, 0x81, 0x1e, 0xc3, 0xa5, 0xdb, 0xc9, 0x24, 0xeb, 0x1a, 0xa1, 0xf9,
196	0xf6, 0xa1, 0x78, 0x98, 0x93, 0x77, 0x42, 0x45, 0x03, 0xe2, 0xc9, 0xa2,
197	0xfe, 0x2d, 0x77, 0xc8, 0xc6, 0xac, 0x9b, 0x98, 0x89, 0x6d, 0x9a, 0xe7,
198	0x61, 0x63, 0xb7, 0xf2, 0xec, 0xd6, 0xb1, 0xa1, 0x6e, 0x0a, 0x1a, 0xff,
199	0xfd, 0x43, 0x28, 0xc3, 0x0c, 0xdc, 0xf2, 0x47, 0x4f, 0x27, 0xaa, 0x99,
200	0x04, 0x8e, 0xac, 0xe8, 0x7c, 0x01, 0x02, 0x04, 0x12, 0x34, 0x56, 0x78,
201	0x02, 0x81, 0x81, 0x00, 0xca, 0x69, 0xe5, 0xbb, 0x3a, 0x90, 0x82, 0xcb,
202	0x82, 0x50, 0x2f, 0x29, 0xe2, 0x76, 0x6a, 0x57, 0x55, 0x45, 0x4e, 0x35,
203	0x18, 0x61, 0xe0, 0x12, 0x70, 0xc0, 0xab, 0xc7, 0x80, 0xa2, 0xd4, 0x46,
204	0x34, 0x03, 0xa0, 0x19, 0x26, 0x23, 0x9e, 0xef, 0x1a, 0xcb, 0x75, 0xd6,
205	0xba, 0x81, 0xf4, 0x7e, 0x52, 0xe5, 0x2a, 0xe8, 0xf1, 0x49, 0x6c, 0x0f,
206	0x1a, 0xa0, 0xf9, 0xc6, 0xe7, 0xec, 0x60, 0xe4, 0xcb, 0x2a, 0xb5, 0x56,
207	0xe9, 0x9c, 0xcd, 0x19, 0x75, 0x92, 0xb1, 0x66, 0xce, 0xc3, 0xd9, 0x3d,
208	0x11, 0xcb, 0xc4, 0x09, 0xce, 0x1e, 0x30, 0xba, 0x2f, 0x60, 0x60, 0x55,
209	0x8d, 0x02, 0xdc, 0x5d, 0xaf, 0xf7, 0x52, 0x31, 0x17, 0x07, 0x53, 0x20,
210	0x33, 0xad, 0x8c, 0xd5, 0x2f, 0x5a, 0xd0, 0x57, 0xd7, 0xd1, 0x80, 0xd6,
211	0x3a, 0x9b, 0x04, 0x4f, 0x35, 0xbf, 0xe7, 0xd5, 0xbc, 0x8f, 0xd4, 0x81,
212	0x02, 0x81, 0x81, 0x00, 0xc0, 0x9f, 0xf8, 0xcd, 0xf7, 0x3f, 0x26, 0x8a,
213	0x3d, 0x4d, 0x2b, 0x0c, 0x01, 0xd0, 0xa2, 0xb4, 0x18, 0xfe, 0xf7, 0x5e,
214	0x2f, 0x06, 0x13, 0xcd, 0x63, 0xaa, 0x12, 0xa9, 0x24, 0x86, 0xe3, 0xf3,
215	0x7b, 0xda, 0x1a, 0x3c, 0xb1, 0x38, 0x80, 0x80, 0xef, 0x64, 0x64, 0xa1,
216	0x9b, 0xfe, 0x76, 0x63, 0x8e, 0x83, 0xd2, 0xd9, 0xb9, 0x86, 0xb0, 0xe6,
217	0xa6, 0x0c, 0x7e, 0xa8, 0x84, 0x90, 0x98, 0x0c, 0x1e, 0xf3, 0x14, 0x77,
218	0xe0, 0x5f, 0x81, 0x08, 0x11, 0x8f, 0xa6, 0x23, 0xc4, 0xba, 0xc0, 0x8a,
219	0xe4, 0xc6, 0xe3, 0x5c, 0xbe, 0xc5, 0xec, 0x2c, 0xb9, 0xd8, 0x8c, 0x4d,
220	0x1a, 0x9d, 0xe7, 0x7c, 0x85, 0x4c, 0x0d, 0x71, 0x4e, 0x72, 0x33, 0x1b,
221	0xfe, 0xa9, 0x17, 0x72, 0x76, 0x56, 0x9d, 0x74, 0x7e, 0x52, 0x67, 0x9a,
222	0x87, 0x9a, 0xdb, 0x30, 0xde, 0xe4, 0x49, 0x28, 0x3b, 0xd2, 0x67, 0xaf,
223	0x02, 0x81, 0x81, 0x00, 0x89, 0x74, 0x9a, 0x8e, 0xa7, 0xb9, 0xa5, 0x28,
224	0xc0, 0x68, 0xe5, 0x6e, 0x63, 0x1c, 0x99, 0x20, 0x8f, 0x86, 0x8e, 0x12,
225	0x9e, 0x69, 0x30, 0xfa, 0x34, 0xd9, 0x92, 0x8d, 0xdb, 0x7c, 0x37, 0xfd,
226	0x28, 0xab, 0x61, 0x98, 0x52, 0x7f, 0x14, 0x1a, 0x39, 0xae, 0xfb, 0x6a,
227	0x03, 0xa3, 0xe6, 0xbd, 0xb6, 0x5b, 0x6b, 0xe5, 0x5e, 0x9d, 0xc6, 0xa5,
228	0x07, 0x27, 0x54, 0x17, 0xd0, 0x3d, 0x84, 0x9b, 0x3a, 0xa0, 0xd9, 0x1e,
229	0x99, 0x6c, 0x63, 0x17, 0xab, 0xf1, 0x1f, 0x49, 0xba, 0x95, 0xe3, 0x3b,
230	0x86, 0x8f, 0x42, 0xa4, 0x89, 0xf5, 0x94, 0x8f, 0x8b, 0x46, 0xbe, 0x84,
231	0xba, 0x4a, 0xbc, 0x0d, 0x5f, 0x46, 0xeb, 0xe8, 0xec, 0x43, 0x8c, 0x1e,
232	0xad, 0x19, 0x69, 0x2f, 0x08, 0x86, 0x7a, 0x3f, 0x7d, 0x0f, 0x07, 0x97,
233	0xf3, 0x9a, 0x7b, 0xb5, 0xb2, 0xc1, 0x8c, 0x95, 0x68, 0x04, 0xa0, 0x81,
234	0x02, 0x81, 0x80, 0x4e, 0xbf, 0x7e, 0x1b, 0xcb, 0x13, 0x61, 0x75, 0x3b,
235	0xdb, 0x59, 0x5f, 0xb1, 0xd4, 0xb8, 0xeb, 0x9e, 0x73, 0xb5, 0xe7, 0xf6,
236	0x89, 0x3d, 0x1c, 0xda, 0xf0, 0x36, 0xff, 0x35, 0xbd, 0x1e, 0x0b, 0x74,
237	0xe3, 0x9e, 0xf0, 0xf2, 0xf7, 0xd7, 0x82, 0xb7, 0x7b, 0x6a, 0x1b, 0x0e,
238	0x30, 0x4a, 0x98, 0x0e, 0xb4, 0xf9, 0x81, 0x07, 0xe4, 0x75, 0x39, 0xe9,
239	0x53, 0xca, 0xbb, 0x5c, 0xaa, 0x93, 0x07, 0x0e, 0xa8, 0x2f, 0xba, 0x98,
240	0x49, 0x30, 0xa7, 0xcc, 0x1a, 0x3c, 0x68, 0x0c, 0xe1, 0xa4, 0xb1, 0x05,
241	0xe6, 0xe0, 0x25, 0x78, 0x58, 0x14, 0x37, 0xf5, 0x1f, 0xe3, 0x22, 0xef,
242	0xa8, 0x0e, 0x22, 0xa0, 0x94, 0x3a, 0xf6, 0xc9, 0x13, 0xe6, 0x06, 0xbf,
243	0x7f, 0x99, 0xc6, 0xcc, 0xd8, 0xc6, 0xbe, 0xd9, 0x2e, 0x24, 0xc7, 0x69,
244	0x8c, 0x95, 0xba, 0xf6, 0x04, 0xb3, 0x0a, 0xf4, 0xcb, 0xf0, 0xce,
245	};
246
247	static const unsigned char kMsg[] = { 1, 2, 3, 4 };
248
249	static const unsigned char kSignature[] = {
250	0xa5, 0xf0, 0x8a, 0x47, 0x5d, 0x3c, 0xb3, 0xcc, 0xa9, 0x79, 0xaf, 0x4d,
251	0x8c, 0xae, 0x4c, 0x14, 0xef, 0xc2, 0x0b, 0x34, 0x36, 0xde, 0xf4, 0x3e,
252	0x3d, 0xbb, 0x4a, 0x60, 0x5c, 0xc8, 0x91, 0x28, 0xda, 0xfb, 0x7e, 0x04,
253	0x96, 0x7e, 0x63, 0x13, 0x90, 0xce, 0xb9, 0xb4, 0x62, 0x7a, 0xfd, 0x09,
254	0x3d, 0xc7, 0x67, 0x78, 0x54, 0x04, 0xeb, 0x52, 0x62, 0x6e, 0x24, 0x67,
255	0xb4, 0x40, 0xfc, 0x57, 0x62, 0xc6, 0xf1, 0x67, 0xc1, 0x97, 0x8f, 0x6a,
256	0xa8, 0xae, 0x44, 0x46, 0x5e, 0xab, 0x67, 0x17, 0x53, 0x19, 0x3a, 0xda,
257	0x5a, 0xc8, 0x16, 0x3e, 0x86, 0xd5, 0xc5, 0x71, 0x2f, 0xfc, 0x23, 0x48,
258	0xd9, 0x0b, 0x13, 0xdd, 0x7b, 0x5a, 0x25, 0x79, 0xef, 0xa5, 0x7b, 0x04,
259	0xed, 0x44, 0xf6, 0x18, 0x55, 0xe4, 0x0a, 0xe9, 0x57, 0x79, 0x5d, 0xd7,
260	0x55, 0xa7, 0xab, 0x45, 0x02, 0x97, 0x60, 0x42,
261	};
262
263	/*
264	* kExampleRSAKeyPKCS8 is kExampleRSAKeyDER encoded in a PKCS #8
265	* PrivateKeyInfo.
266	*/
267	static const unsigned char kExampleRSAKeyPKCS8[] = {
268	0x30, 0x82, 0x02, 0x76, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a,
269	0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82,
270	0x02, 0x60, 0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81,
271	0x00, 0xf8, 0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5,
272	0xb4, 0x59, 0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e,
273	0xd3, 0x37, 0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34,
274	0x75, 0x71, 0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde,
275	0x97, 0x8a, 0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8,
276	0x50, 0xe4, 0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b,
277	0xdc, 0xec, 0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83,
278	0x58, 0x76, 0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48,
279	0x1a, 0xd8, 0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a,
280	0x5c, 0xd7, 0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2,
281	0xa7, 0x2c, 0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01,
282	0x00, 0x01, 0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a,
283	0x6d, 0xc7, 0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5,
284	0x32, 0x85, 0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6,
285	0x5f, 0xee, 0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8,
286	0x66, 0x85, 0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6,
287	0xa4, 0x0a, 0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f,
288	0xc2, 0x15, 0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c,
289	0x5b, 0x83, 0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78,
290	0x80, 0x1b, 0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71,
291	0x99, 0x73, 0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60,
292	0x1f, 0x99, 0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d,
293	0xb1, 0x02, 0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3,
294	0x40, 0x41, 0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d,
295	0x3d, 0x59, 0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18,
296	0xc6, 0xd9, 0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d,
297	0x9f, 0xef, 0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32,
298	0x46, 0x87, 0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc,
299	0x2c, 0xdf, 0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63,
300	0x55, 0xf5, 0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05,
301	0xcd, 0xb5, 0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16,
302	0xb3, 0x62, 0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3,
303	0x9b, 0x64, 0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85,
304	0xfa, 0xb8, 0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97,
305	0xe8, 0xba, 0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7,
306	0xe7, 0xfe, 0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99,
307	0x75, 0xe7, 0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4,
308	0x9d, 0xfe, 0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d,
309	0xf1, 0xdb, 0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40,
310	0x5a, 0x34, 0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26,
311	0x84, 0x27, 0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1,
312	0xe9, 0xc0, 0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c,
313	0xb9, 0xba, 0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30,
314	0x10, 0x06, 0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea,
315	0x52, 0x2c, 0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b,
316	0xc4, 0x1e, 0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e,
317	0x49, 0xaf, 0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9,
318	0xd1, 0x8a, 0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae,
319	0x17, 0x17, 0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d,
320	0x08, 0xf1, 0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
321	};
322
323	#ifndef OPENSSL_NO_EC
324	/*
325	* kExampleECKeyDER is a sample EC private key encoded as an ECPrivateKey
326	* structure.
327	*/
328	static const unsigned char kExampleECKeyDER[] = {
329	0x30, 0x77, 0x02, 0x01, 0x01, 0x04, 0x20, 0x07, 0x0f, 0x08, 0x72, 0x7a,
330	0xd4, 0xa0, 0x4a, 0x9c, 0xdd, 0x59, 0xc9, 0x4d, 0x89, 0x68, 0x77, 0x08,
331	0xb5, 0x6f, 0xc9, 0x5d, 0x30, 0x77, 0x0e, 0xe8, 0xd1, 0xc9, 0xce, 0x0a,
332	0x8b, 0xb4, 0x6a, 0xa0, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
333	0x03, 0x01, 0x07, 0xa1, 0x44, 0x03, 0x42, 0x00, 0x04, 0xe6, 0x2b, 0x69,
334	0xe2, 0xbf, 0x65, 0x9f, 0x97, 0xbe, 0x2f, 0x1e, 0x0d, 0x94, 0x8a, 0x4c,
335	0xd5, 0x97, 0x6b, 0xb7, 0xa9, 0x1e, 0x0d, 0x46, 0xfb, 0xdd, 0xa9, 0xa9,
336	0x1e, 0x9d, 0xdc, 0xba, 0x5a, 0x01, 0xe7, 0xd6, 0x97, 0xa8, 0x0a, 0x18,
337	0xf9, 0xc3, 0xc4, 0xa3, 0x1e, 0x56, 0xe2, 0x7c, 0x83, 0x48, 0xdb, 0x16,
338	0x1a, 0x1c, 0xf5, 0x1d, 0x7e, 0xf1, 0x94, 0x2d, 0x4b, 0xcf, 0x72, 0x22,
339	0xc1,
340	};
341
342	/*
343	* kExampleBadECKeyDER is a sample EC private key encoded as an ECPrivateKey
344	* structure. The private key is equal to the order and will fail to import
345	*/
346	static const unsigned char kExampleBadECKeyDER[] = {
347	0x30, 0x66, 0x02, 0x01, 0x00, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86, 0x48,
348	0xCE, 0x3D, 0x02, 0x01, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03,
349	0x01, 0x07, 0x04, 0x4C, 0x30, 0x4A, 0x02, 0x01, 0x01, 0x04, 0x20, 0xFF,
350	0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
351	0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84, 0xF3,
352	0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51, 0xA1, 0x23, 0x03, 0x21, 0x00,
353	0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
354	0xFF, 0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84,
355	0xF3, 0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51
356	};
357
358	/* prime256v1 */
359	static const unsigned char kExampleECPubKeyDER[] = {
360	0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
361	0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
362	0x42, 0x00, 0x04, 0xba, 0xeb, 0x83, 0xfb, 0x3b, 0xb2, 0xff, 0x30, 0x53,
363	0xdb, 0xce, 0x32, 0xf2, 0xac, 0xae, 0x44, 0x0d, 0x3d, 0x13, 0x53, 0xb8,
364	0xd1, 0x68, 0x55, 0xde, 0x44, 0x46, 0x05, 0xa6, 0xc9, 0xd2, 0x04, 0xb7,
365	0xe3, 0xa2, 0x96, 0xc8, 0xb2, 0x5e, 0x22, 0x03, 0xd7, 0x03, 0x7a, 0x8b,
366	0x13, 0x5c, 0x42, 0x49, 0xc2, 0xab, 0x86, 0xd6, 0xac, 0x6b, 0x93, 0x20,
367	0x56, 0x6a, 0xc6, 0xc8, 0xa5, 0x0b, 0xe5
368	};
369
370	/*
371	* kExampleBadECPubKeyDER is a sample EC public key with a wrong OID
372	* 1.2.840.10045.2.2 instead of 1.2.840.10045.2.1 - EC Public Key
373	*/
374	static const unsigned char kExampleBadECPubKeyDER[] = {
375	0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
376	0x02, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
377	0x42, 0x00, 0x04, 0xba, 0xeb, 0x83, 0xfb, 0x3b, 0xb2, 0xff, 0x30, 0x53,
378	0xdb, 0xce, 0x32, 0xf2, 0xac, 0xae, 0x44, 0x0d, 0x3d, 0x13, 0x53, 0xb8,
379	0xd1, 0x68, 0x55, 0xde, 0x44, 0x46, 0x05, 0xa6, 0xc9, 0xd2, 0x04, 0xb7,
380	0xe3, 0xa2, 0x96, 0xc8, 0xb2, 0x5e, 0x22, 0x03, 0xd7, 0x03, 0x7a, 0x8b,
381	0x13, 0x5c, 0x42, 0x49, 0xc2, 0xab, 0x86, 0xd6, 0xac, 0x6b, 0x93, 0x20,
382	0x56, 0x6a, 0xc6, 0xc8, 0xa5, 0x0b, 0xe5
383	};
384
385	static const unsigned char pExampleECParamDER[] = {
386	0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07
387	};
388
389	static const unsigned char kExampleED25519KeyDER[] = {
390	0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70,
391	0x04, 0x22, 0x04, 0x20, 0xba, 0x7b, 0xba, 0x20, 0x1b, 0x02, 0x75, 0x3a,
392	0xe8, 0x88, 0xfe, 0x00, 0xcd, 0x8b, 0xc6, 0xf4, 0x5c, 0x47, 0x09, 0x46,
393	0x66, 0xe4, 0x72, 0x85, 0x25, 0x26, 0x5e, 0x12, 0x33, 0x48, 0xf6, 0x50
394	};
395
396	static const unsigned char kExampleED25519PubKeyDER[] = {
397	0x30, 0x2a, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x03, 0x21, 0x00,
398	0xf5, 0xc5, 0xeb, 0x52, 0x3e, 0x7d, 0x07, 0x86, 0xb2, 0x55, 0x07, 0x45,
399	0xef, 0x5b, 0x7c, 0x20, 0xe8, 0x66, 0x28, 0x30, 0x3c, 0x8a, 0x82, 0x40,
400	0x97, 0xa3, 0x08, 0xdc, 0x65, 0x80, 0x39, 0x29
401	};
402
403	# ifndef OPENSSL_NO_DEPRECATED_3_0
404	static const unsigned char kExampleX25519KeyDER[] = {
405	0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x6e,
406	0x04, 0x22, 0x04, 0x20, 0xa0, 0x24, 0x3a, 0x31, 0x24, 0xc3, 0x3f, 0xf6,
407	0x7b, 0x96, 0x0b, 0xd4, 0x8f, 0xd1, 0xee, 0x67, 0xf2, 0x9b, 0x88, 0xac,
408	0x50, 0xce, 0x97, 0x36, 0xdd, 0xaf, 0x25, 0xf6, 0x10, 0x34, 0x96, 0x6e
409	};
410	# endif
411	#endif
412
413	/* kExampleDHKeyDER is a DH private key in ASN.1, DER format. */
414	#ifndef OPENSSL_NO_DEPRECATED_3_0
415	# ifndef OPENSSL_NO_DH
416	static const unsigned char kExampleDHKeyDER[] = {
417	0x30, 0x82, 0x01, 0x21, 0x02, 0x01, 0x00, 0x30, 0x81, 0x95, 0x06, 0x09,
418	0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x03, 0x01, 0x30, 0x81, 0x87,
419	0x02, 0x81, 0x81, 0x00, 0xf7, 0x52, 0xc2, 0x68, 0xcc, 0x66, 0xc4, 0x8d,
420	0x03, 0x3f, 0xfa, 0x9c, 0x52, 0xd0, 0xd8, 0x33, 0xf2, 0xe1, 0xc9, 0x9e,
421	0xb7, 0xe7, 0x6e, 0x90, 0x97, 0xeb, 0x92, 0x91, 0x6a, 0x9a, 0x85, 0x63,
422	0x92, 0x79, 0xab, 0xb6, 0x3d, 0x23, 0x58, 0x5a, 0xe8, 0x45, 0x06, 0x81,
423	0x97, 0x77, 0xe1, 0xcc, 0x34, 0x4e, 0xae, 0x36, 0x80, 0xf2, 0xc4, 0x7f,
424	0x8a, 0x52, 0xb8, 0xdb, 0x58, 0xc8, 0x4b, 0x12, 0x4c, 0xf1, 0x4c, 0x53,
425	0xc1, 0x89, 0x39, 0x8d, 0xb6, 0x06, 0xd8, 0xea, 0x7f, 0x2d, 0x36, 0x53,
426	0x96, 0x29, 0xbe, 0xb6, 0x75, 0xfc, 0xe7, 0xf3, 0x36, 0xd6, 0xf4, 0x8f,
427	0x16, 0xa6, 0xc7, 0xec, 0x7b, 0xce, 0x42, 0x8d, 0x48, 0x2e, 0xb7, 0x74,
428	0x00, 0x11, 0x52, 0x61, 0xb4, 0x19, 0x35, 0xec, 0x5c, 0xe4, 0xbe, 0x34,
429	0xc6, 0x59, 0x64, 0x5e, 0x42, 0x61, 0x70, 0x54, 0xf4, 0xe9, 0x6b, 0x53,
430	0x02, 0x01, 0x02, 0x04, 0x81, 0x83, 0x02, 0x81, 0x80, 0x64, 0xc2, 0xe3,
431	0x09, 0x69, 0x37, 0x3c, 0xd2, 0x4a, 0xba, 0xc3, 0x78, 0x6a, 0x9b, 0x8a,
432	0x2a, 0xdb, 0xe7, 0xe6, 0xc0, 0xfa, 0x3a, 0xbe, 0x39, 0x67, 0xc0, 0xa9,
433	0x2a, 0xf0, 0x0a, 0xc1, 0x53, 0x1c, 0xdb, 0xfa, 0x1a, 0x26, 0x98, 0xb0,
434	0x8c, 0xc6, 0x06, 0x4a, 0xa2, 0x48, 0xd3, 0xa4, 0x3b, 0xbd, 0x05, 0x48,
435	0xea, 0x59, 0xdb, 0x18, 0xa4, 0xca, 0x66, 0xd9, 0x5d, 0xb8, 0x95, 0xd1,
436	0xeb, 0x97, 0x3d, 0x66, 0x97, 0x5c, 0x86, 0x8f, 0x7e, 0x90, 0xd3, 0x43,
437	0xd1, 0xa2, 0x0d, 0xcb, 0xe7, 0xeb, 0x90, 0xea, 0x09, 0x40, 0xb1, 0x6f,
438	0xf7, 0x4c, 0xf2, 0x41, 0x83, 0x1d, 0xd0, 0x76, 0xef, 0xaf, 0x55, 0x6f,
439	0x5d, 0xa9, 0xa3, 0x55, 0x81, 0x2a, 0xd1, 0x5d, 0x9d, 0x22, 0x77, 0x97,
440	0x83, 0xde, 0xad, 0xb6, 0x5d, 0x19, 0xc1, 0x53, 0xec, 0xfb, 0xaf, 0x06,
441	0x2e, 0x87, 0x2a, 0x0b, 0x7a
442	};
443	# endif
444	#endif
445
446	static const unsigned char kCFBDefaultKey[] = {
447	0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88,
448	0x09, 0xCF, 0x4F, 0x3C
449	};
450
451	static const unsigned char kGCMDefaultKey[32] = { 0 };
452
453	static const unsigned char kGCMResetKey[] = {
454	0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c, 0x6d, 0x6a, 0x8f, 0x94,
455	0x67, 0x30, 0x83, 0x08, 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
456	0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08
457	};
458
459	static const unsigned char iCFBIV[] = {
460	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
461	0x0C, 0x0D, 0x0E, 0x0F
462	};
463
464	static const unsigned char iGCMDefaultIV[12] = { 0 };
465
466	static const unsigned char iGCMResetIV1[] = {
467	0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad
468	};
469
470	static const unsigned char iGCMResetIV2[] = {
471	0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad, 0xde, 0xca, 0xf8, 0x88
472	};
473
474	static const unsigned char cfbPlaintext[] = {
475	0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96, 0xE9, 0x3D, 0x7E, 0x11,
476	0x73, 0x93, 0x17, 0x2A
477	};
478
479	static const unsigned char gcmDefaultPlaintext[16] = { 0 };
480
481	static const unsigned char gcmResetPlaintext[] = {
482	0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5, 0xa5, 0x59, 0x09, 0xc5,
483	0xaf, 0xf5, 0x26, 0x9a, 0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
484	0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72, 0x1c, 0x3c, 0x0c, 0x95,
485	0x95, 0x68, 0x09, 0x53, 0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
486	0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57, 0xba, 0x63, 0x7b, 0x39
487	};
488
489	static const unsigned char cfbCiphertext[] = {
490	0x3B, 0x3F, 0xD9, 0x2E, 0xB7, 0x2D, 0xAD, 0x20, 0x33, 0x34, 0x49, 0xF8,
491	0xE8, 0x3C, 0xFB, 0x4A
492	};
493
494	static const unsigned char gcmDefaultCiphertext[] = {
495	0xce, 0xa7, 0x40, 0x3d, 0x4d, 0x60, 0x6b, 0x6e, 0x07, 0x4e, 0xc5, 0xd3,
496	0xba, 0xf3, 0x9d, 0x18
497	};
498
499	static const unsigned char gcmResetCiphertext1[] = {
500	0xc3, 0x76, 0x2d, 0xf1, 0xca, 0x78, 0x7d, 0x32, 0xae, 0x47, 0xc1, 0x3b,
501	0xf1, 0x98, 0x44, 0xcb, 0xaf, 0x1a, 0xe1, 0x4d, 0x0b, 0x97, 0x6a, 0xfa,
502	0xc5, 0x2f, 0xf7, 0xd7, 0x9b, 0xba, 0x9d, 0xe0, 0xfe, 0xb5, 0x82, 0xd3,
503	0x39, 0x34, 0xa4, 0xf0, 0x95, 0x4c, 0xc2, 0x36, 0x3b, 0xc7, 0x3f, 0x78,
504	0x62, 0xac, 0x43, 0x0e, 0x64, 0xab, 0xe4, 0x99, 0xf4, 0x7c, 0x9b, 0x1f
505	};
506
507	static const unsigned char gcmResetCiphertext2[] = {
508	0x52, 0x2d, 0xc1, 0xf0, 0x99, 0x56, 0x7d, 0x07, 0xf4, 0x7f, 0x37, 0xa3,
509	0x2a, 0x84, 0x42, 0x7d, 0x64, 0x3a, 0x8c, 0xdc, 0xbf, 0xe5, 0xc0, 0xc9,
510	0x75, 0x98, 0xa2, 0xbd, 0x25, 0x55, 0xd1, 0xaa, 0x8c, 0xb0, 0x8e, 0x48,
511	0x59, 0x0d, 0xbb, 0x3d, 0xa7, 0xb0, 0x8b, 0x10, 0x56, 0x82, 0x88, 0x38,
512	0xc5, 0xf6, 0x1e, 0x63, 0x93, 0xba, 0x7a, 0x0a, 0xbc, 0xc9, 0xf6, 0x62
513	};
514
515	static const unsigned char gcmAAD[] = {
516	0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef, 0xfe, 0xed, 0xfa, 0xce,
517	0xde, 0xad, 0xbe, 0xef, 0xab, 0xad, 0xda, 0xd2
518	};
519
520	static const unsigned char gcmDefaultTag[] = {
521	0xd0, 0xd1, 0xc8, 0xa7, 0x99, 0x99, 0x6b, 0xf0, 0x26, 0x5b, 0x98, 0xb5,
522	0xd4, 0x8a, 0xb9, 0x19
523	};
524
525	static const unsigned char gcmResetTag1[] = {
526	0x3a, 0x33, 0x7d, 0xbf, 0x46, 0xa7, 0x92, 0xc4, 0x5e, 0x45, 0x49, 0x13,
527	0xfe, 0x2e, 0xa8, 0xf2
528	};
529
530	static const unsigned char gcmResetTag2[] = {
531	0x76, 0xfc, 0x6e, 0xce, 0x0f, 0x4e, 0x17, 0x68, 0xcd, 0xdf, 0x88, 0x53,
532	0xbb, 0x2d, 0x55, 0x1b
533	};
534
535	typedef struct APK_DATA_st {
536	const unsigned char *kder;
537	size_t size;
538	const char *keytype;
539	int evptype;
540	int check;
541	int pub_check;
542	int param_check;
543	int type; /* 0 for private, 1 for public, 2 for params */
544	} APK_DATA;
545
546	static APK_DATA keydata[] = {
547	{kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER), "RSA", EVP_PKEY_RSA},
548	{kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8), "RSA", EVP_PKEY_RSA},
549	#ifndef OPENSSL_NO_EC
550	{kExampleECKeyDER, sizeof(kExampleECKeyDER), "EC", EVP_PKEY_EC}
551	#endif
552	};
553
554	static APK_DATA keycheckdata[] = {
555	{kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER), "RSA", EVP_PKEY_RSA, 1, 1, 1,
556	0},
557	{kExampleBadRSAKeyDER, sizeof(kExampleBadRSAKeyDER), "RSA", EVP_PKEY_RSA,
558	0, 1, 1, 0},
559	#ifndef OPENSSL_NO_EC
560	{kExampleECKeyDER, sizeof(kExampleECKeyDER), "EC", EVP_PKEY_EC, 1, 1, 1, 0},
561	/* group is also associated in our pub key */
562	{kExampleECPubKeyDER, sizeof(kExampleECPubKeyDER), "EC", EVP_PKEY_EC, 0, 1,
563	1, 1},
564	{pExampleECParamDER, sizeof(pExampleECParamDER), "EC", EVP_PKEY_EC, 0, 0, 1,
565	2},
566	{kExampleED25519KeyDER, sizeof(kExampleED25519KeyDER), "ED25519",
567	EVP_PKEY_ED25519, 1, 1, 1, 0},
568	{kExampleED25519PubKeyDER, sizeof(kExampleED25519PubKeyDER), "ED25519",
569	EVP_PKEY_ED25519, 0, 1, 1, 1},
570	#endif
571	};
572
573	static EVP_PKEY load_example_key(const char keytype,
574	const unsigned char *data, size_t data_len)
575	{
576	const unsigned char **pdata = &data;
577	EVP_PKEY *pkey = NULL;
578	OSSL_DECODER_CTX *dctx =
579	OSSL_DECODER_CTX_new_for_pkey(&pkey, "DER", NULL, keytype, 0,
580	testctx, testpropq);
581
582	/* \|pkey\| will be NULL on error */
583	(void)OSSL_DECODER_from_data(dctx, pdata, &data_len);
584	OSSL_DECODER_CTX_free(dctx);
585	return pkey;
586	}
587
588	static EVP_PKEY *load_example_rsa_key(void)
589	{
590	return load_example_key("RSA", kExampleRSAKeyDER,
591	sizeof(kExampleRSAKeyDER));
592	}
593
594	#ifndef OPENSSL_NO_DSA
595	static EVP_PKEY *load_example_dsa_key(void)
596	{
597	return load_example_key("DSA", kExampleDSAKeyDER,
598	sizeof(kExampleDSAKeyDER));
599	}
600	#endif
601
602	#ifndef OPENSSL_NO_EC
603	static EVP_PKEY *load_example_ec_key(void)
604	{
605	return load_example_key("EC", kExampleECKeyDER,
606	sizeof(kExampleECKeyDER));
607	}
608	#endif
609
610	#ifndef OPENSSL_NO_DEPRECATED_3_0
611	# ifndef OPENSSL_NO_DH
612	static EVP_PKEY *load_example_dh_key(void)
613	{
614	return load_example_key("DH", kExampleDHKeyDER,
615	sizeof(kExampleDHKeyDER));
616	}
617	# endif
618
619	# ifndef OPENSSL_NO_EC
620	static EVP_PKEY *load_example_ed25519_key(void)
621	{
622	return load_example_key("ED25519", kExampleED25519KeyDER,
623	sizeof(kExampleED25519KeyDER));
624	}
625
626	static EVP_PKEY *load_example_x25519_key(void)
627	{
628	return load_example_key("X25519", kExampleX25519KeyDER,
629	sizeof(kExampleX25519KeyDER));
630	}
631	# endif
632	#endif /* OPENSSL_NO_DEPRECATED_3_0 */
633
634	static EVP_PKEY *load_example_hmac_key(void)
635	{
636	EVP_PKEY *pkey = NULL;
637	unsigned char key[] = {
638	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
639	0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
640	0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
641	};
642
643	pkey = EVP_PKEY_new_raw_private_key_ex(testctx, "HMAC",
644	NULL, key, sizeof(key));
645	if (!TEST_ptr(pkey))
646	return NULL;
647
648	return pkey;
649	}
650
651	static int test_EVP_set_default_properties(void)
652	{
653	OSSL_LIB_CTX *ctx;
654	EVP_MD *md = NULL;
655	int res = 0;
656
657	if (!TEST_ptr(ctx = OSSL_LIB_CTX_new())
658	\|\| !TEST_ptr(md = EVP_MD_fetch(ctx, "sha256", NULL)))
659	goto err;
660	EVP_MD_free(md);
661	md = NULL;
662
663	if (!TEST_true(EVP_set_default_properties(ctx, "provider=fizzbang"))
664	\|\| !TEST_ptr_null(md = EVP_MD_fetch(ctx, "sha256", NULL))
665	\|\| !TEST_ptr(md = EVP_MD_fetch(ctx, "sha256", "-provider")))
666	goto err;
667	EVP_MD_free(md);
668	md = NULL;
669
670	if (!TEST_true(EVP_set_default_properties(ctx, NULL))
671	\|\| !TEST_ptr(md = EVP_MD_fetch(ctx, "sha256", NULL)))
672	goto err;
673	res = 1;
674	err:
675	EVP_MD_free(md);
676	OSSL_LIB_CTX_free(ctx);
677	return res;
678	}
679
680	#if !defined(OPENSSL_NO_DH) \|\| !defined(OPENSSL_NO_DSA) \|\| !defined(OPENSSL_NO_EC)
681	static EVP_PKEY make_key_fromdata(char keytype, OSSL_PARAM *params)
682	{
683	EVP_PKEY_CTX *pctx = NULL;
684	EVP_PKEY tmp_pkey = NULL, pkey = NULL;
685
686	if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_from_name(testctx, keytype, testpropq)))
687	goto err;
688	if (!TEST_int_gt(EVP_PKEY_fromdata_init(pctx), 0)
689	\|\| !TEST_int_gt(EVP_PKEY_fromdata(pctx, &tmp_pkey, EVP_PKEY_KEYPAIR,
690	params), 0))
691	goto err;
692
693	if (!TEST_ptr(tmp_pkey))
694	goto err;
695
696	pkey = tmp_pkey;
697	tmp_pkey = NULL;
698	err:
699	EVP_PKEY_free(tmp_pkey);
700	EVP_PKEY_CTX_free(pctx);
701	return pkey;
702	}
703
704	static int test_selection(EVP_PKEY *pkey, int selection)
705	{
706	int testresult = 0;
707	int ret;
708	BIO *bio = BIO_new(BIO_s_mem());
709
710	ret = PEM_write_bio_PUBKEY(bio, pkey);
711	if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0) {
712	if (!TEST_true(ret))
713	goto err;
714	} else {
715	if (!TEST_false(ret))
716	goto err;
717	}
718	ret = PEM_write_bio_PrivateKey_ex(bio, pkey, NULL, NULL, 0, NULL, NULL,
719	testctx, NULL);
720	if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0) {
721	if (!TEST_true(ret))
722	goto err;
723	} else {
724	if (!TEST_false(ret))
725	goto err;
726	}
727
728	testresult = 1;
729	err:
730	BIO_free(bio);
731
732	return testresult;
733	}
734	#endif /* !OPENSSL_NO_DH \|\| !OPENSSL_NO_DSA \|\| !OPENSSL_NO_EC */
735
736	/*
737	* Test combinations of private, public, missing and private + public key
738	* params to ensure they are all accepted
739	*/
740	#if !defined(OPENSSL_NO_DH) \|\| !defined(OPENSSL_NO_DSA)
741	static int test_EVP_PKEY_ffc_priv_pub(char *keytype)
742	{
743	OSSL_PARAM_BLD *bld = NULL;
744	OSSL_PARAM *params = NULL;
745	EVP_PKEY *just_params = NULL;
746	EVP_PKEY *params_and_priv = NULL;
747	EVP_PKEY *params_and_pub = NULL;
748	EVP_PKEY *params_and_keypair = NULL;
749	BIGNUM p = NULL, q = NULL, g = NULL, pub = NULL, *priv = NULL;
750	int ret = 0;
751
752	/*
753	* Setup the parameters for our pkey object. For our purposes they don't
754	* have to actually be valid parameters. We just need to set something.
755	*/
756	if (!TEST_ptr(p = BN_new())
757	\|\| !TEST_ptr(q = BN_new())
758	\|\| !TEST_ptr(g = BN_new())
759	\|\| !TEST_ptr(pub = BN_new())
760	\|\| !TEST_ptr(priv = BN_new()))
761	goto err;
762
763	/* Test !priv and !pub */
764	if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
765	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_P, p))
766	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_Q, q))
767	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_G, g)))
768	goto err;
769	if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
770	\|\| !TEST_ptr(just_params = make_key_fromdata(keytype, params)))
771	goto err;
772
773	OSSL_PARAM_free(params);
774	OSSL_PARAM_BLD_free(bld);
775	params = NULL;
776	bld = NULL;
777
778	if (!test_selection(just_params, OSSL_KEYMGMT_SELECT_ALL_PARAMETERS)
779	\|\| test_selection(just_params, OSSL_KEYMGMT_SELECT_KEYPAIR))
780	goto err;
781
782	/* Test priv and !pub */
783	if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
784	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_P, p))
785	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_Q, q))
786	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_G, g))
787	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY,
788	priv)))
789	goto err;
790	if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
791	\|\| !TEST_ptr(params_and_priv = make_key_fromdata(keytype, params)))
792	goto err;
793
794	OSSL_PARAM_free(params);
795	OSSL_PARAM_BLD_free(bld);
796	params = NULL;
797	bld = NULL;
798
799	if (!test_selection(params_and_priv, OSSL_KEYMGMT_SELECT_PRIVATE_KEY)
800	\|\| test_selection(params_and_priv, OSSL_KEYMGMT_SELECT_PUBLIC_KEY))
801	goto err;
802
803	/* Test !priv and pub */
804	if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
805	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_P, p))
806	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_Q, q))
807	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_G, g))
808	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PUB_KEY,
809	pub)))
810	goto err;
811	if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
812	\|\| !TEST_ptr(params_and_pub = make_key_fromdata(keytype, params)))
813	goto err;
814
815	OSSL_PARAM_free(params);
816	OSSL_PARAM_BLD_free(bld);
817	params = NULL;
818	bld = NULL;
819
820	if (!test_selection(params_and_pub, OSSL_KEYMGMT_SELECT_PUBLIC_KEY)
821	\|\| test_selection(params_and_pub, OSSL_KEYMGMT_SELECT_PRIVATE_KEY))
822	goto err;
823
824	/* Test priv and pub */
825	if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
826	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_P, p))
827	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_Q, q))
828	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_G, g))
829	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PUB_KEY,
830	pub))
831	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY,
832	priv)))
833	goto err;
834	if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
835	\|\| !TEST_ptr(params_and_keypair = make_key_fromdata(keytype, params)))
836	goto err;
837
838	if (!test_selection(params_and_keypair, EVP_PKEY_KEYPAIR))
839	goto err;
840
841	ret = 1;
842	err:
843	OSSL_PARAM_free(params);
844	OSSL_PARAM_BLD_free(bld);
845	EVP_PKEY_free(just_params);
846	EVP_PKEY_free(params_and_priv);
847	EVP_PKEY_free(params_and_pub);
848	EVP_PKEY_free(params_and_keypair);
849	BN_free(p);
850	BN_free(q);
851	BN_free(g);
852	BN_free(pub);
853	BN_free(priv);
854
855	return ret;
856	}
857	#endif /* !OPENSSL_NO_DH \|\| !OPENSSL_NO_DSA */
858
859	/*
860	* Test combinations of private, public, missing and private + public key
861	* params to ensure they are all accepted for EC keys
862	*/
863	#ifndef OPENSSL_NO_EC
864	static unsigned char ec_priv[] = {
865	0xe9, 0x25, 0xf7, 0x66, 0x58, 0xa4, 0xdd, 0x99, 0x61, 0xe7, 0xe8, 0x23,
866	0x85, 0xc2, 0xe8, 0x33, 0x27, 0xc5, 0x5c, 0xeb, 0xdb, 0x43, 0x9f, 0xd5,
867	0xf2, 0x5a, 0x75, 0x55, 0xd0, 0x2e, 0x6d, 0x16
868	};
869	static unsigned char ec_pub[] = {
870	0x04, 0xad, 0x11, 0x90, 0x77, 0x4b, 0x46, 0xee, 0x72, 0x51, 0x15, 0x97,
871	0x4a, 0x6a, 0xa7, 0xaf, 0x59, 0xfa, 0x4b, 0xf2, 0x41, 0xc8, 0x3a, 0x81,
872	0x23, 0xb6, 0x90, 0x04, 0x6c, 0x67, 0x66, 0xd0, 0xdc, 0xf2, 0x15, 0x1d,
873	0x41, 0x61, 0xb7, 0x95, 0x85, 0x38, 0x5a, 0x84, 0x56, 0xe8, 0xb3, 0x0e,
874	0xf5, 0xc6, 0x5d, 0xa4, 0x54, 0x26, 0xb0, 0xf7, 0xa5, 0x4a, 0x33, 0xf1,
875	0x08, 0x09, 0xb8, 0xdb, 0x03
876	};
877
878	static int test_EC_priv_pub(void)
879	{
880	OSSL_PARAM_BLD *bld = NULL;
881	OSSL_PARAM *params = NULL;
882	EVP_PKEY *just_params = NULL;
883	EVP_PKEY *params_and_priv = NULL;
884	EVP_PKEY *params_and_pub = NULL;
885	EVP_PKEY *params_and_keypair = NULL;
886	BIGNUM *priv = NULL;
887	int ret = 0;
888
889	/*
890	* Setup the parameters for our pkey object. For our purposes they don't
891	* have to actually be valid parameters. We just need to set something.
892	*/
893	if (!TEST_ptr(priv = BN_bin2bn(ec_priv, sizeof(ec_priv), NULL)))
894	goto err;
895
896	/* Test !priv and !pub */
897	if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
898	\|\| !TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld,
899	OSSL_PKEY_PARAM_GROUP_NAME,
900	"P-256", 0)))
901	goto err;
902	if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
903	\|\| !TEST_ptr(just_params = make_key_fromdata("EC", params)))
904	goto err;
905
906	OSSL_PARAM_free(params);
907	OSSL_PARAM_BLD_free(bld);
908	params = NULL;
909	bld = NULL;
910
911	if (!test_selection(just_params, OSSL_KEYMGMT_SELECT_ALL_PARAMETERS)
912	\|\| test_selection(just_params, OSSL_KEYMGMT_SELECT_KEYPAIR))
913	goto err;
914
915	/* Test priv and !pub */
916	if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
917	\|\| !TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld,
918	OSSL_PKEY_PARAM_GROUP_NAME,
919	"P-256", 0))
920	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY,
921	priv)))
922	goto err;
923	if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
924	\|\| !TEST_ptr(params_and_priv = make_key_fromdata("EC", params)))
925	goto err;
926
927	OSSL_PARAM_free(params);
928	OSSL_PARAM_BLD_free(bld);
929	params = NULL;
930	bld = NULL;
931
932	/*
933	* We indicate only parameters here, in spite of having built a key that
934	* has a private part, because the PEM_write_bio_PrivateKey_ex call is
935	* expected to fail because it does not support exporting a private EC
936	* key without a corresponding public key
937	*/
938	if (!test_selection(params_and_priv, OSSL_KEYMGMT_SELECT_ALL_PARAMETERS)
939	\|\| test_selection(params_and_priv, OSSL_KEYMGMT_SELECT_PUBLIC_KEY))
940	goto err;
941
942	/* Test !priv and pub */
943	if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
944	\|\| !TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld,
945	OSSL_PKEY_PARAM_GROUP_NAME,
946	"P-256", 0))
947	\|\| !TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
948	OSSL_PKEY_PARAM_PUB_KEY,
949	ec_pub, sizeof(ec_pub))))
950	goto err;
951	if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
952	\|\| !TEST_ptr(params_and_pub = make_key_fromdata("EC", params)))
953	goto err;
954
955	OSSL_PARAM_free(params);
956	OSSL_PARAM_BLD_free(bld);
957	params = NULL;
958	bld = NULL;
959
960	if (!test_selection(params_and_pub, OSSL_KEYMGMT_SELECT_PUBLIC_KEY)
961	\|\| test_selection(params_and_pub, OSSL_KEYMGMT_SELECT_PRIVATE_KEY))
962	goto err;
963
964	/* Test priv and pub */
965	if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
966	\|\| !TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld,
967	OSSL_PKEY_PARAM_GROUP_NAME,
968	"P-256", 0))
969	\|\| !TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
970	OSSL_PKEY_PARAM_PUB_KEY,
971	ec_pub, sizeof(ec_pub)))
972	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY,
973	priv)))
974	goto err;
975	if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
976	\|\| !TEST_ptr(params_and_keypair = make_key_fromdata("EC", params)))
977	goto err;
978
979	if (!test_selection(params_and_keypair, EVP_PKEY_KEYPAIR))
980	goto err;
981
982	/* Try key equality */
983	if (!TEST_int_gt(EVP_PKEY_parameters_eq(just_params, just_params), 0)
984	\|\| !TEST_int_gt(EVP_PKEY_parameters_eq(just_params, params_and_pub),
985	0)
986	\|\| !TEST_int_gt(EVP_PKEY_parameters_eq(just_params, params_and_priv),
987	0)
988	\|\| !TEST_int_gt(EVP_PKEY_parameters_eq(just_params, params_and_keypair),
989	0)
990	\|\| !TEST_int_gt(EVP_PKEY_eq(params_and_pub, params_and_pub), 0)
991	\|\| !TEST_int_gt(EVP_PKEY_eq(params_and_priv, params_and_priv), 0)
992	\|\| !TEST_int_gt(EVP_PKEY_eq(params_and_keypair, params_and_pub), 0)
993	\|\| !TEST_int_gt(EVP_PKEY_eq(params_and_keypair, params_and_priv), 0))
994	goto err;
995
996	ret = 1;
997	err:
998	OSSL_PARAM_free(params);
999	OSSL_PARAM_BLD_free(bld);
1000	EVP_PKEY_free(just_params);
1001	EVP_PKEY_free(params_and_priv);
1002	EVP_PKEY_free(params_and_pub);
1003	EVP_PKEY_free(params_and_keypair);
1004	BN_free(priv);
1005
1006	return ret;
1007	}
1008
1009	/* Test that using a legacy EC key with only a private key in it works */
1010	# ifndef OPENSSL_NO_DEPRECATED_3_0
1011	static int test_EC_priv_only_legacy(void)
1012	{
1013	BIGNUM *priv = NULL;
1014	int ret = 0;
1015	EC_KEY *eckey = NULL;
1016	EVP_PKEY pkey = NULL, dup_pk = NULL;
1017	EVP_MD_CTX *ctx = NULL;
1018
1019	/* Create the low level EC_KEY */
1020	if (!TEST_ptr(priv = BN_bin2bn(ec_priv, sizeof(ec_priv), NULL)))
1021	goto err;
1022
1023	eckey = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
1024	if (!TEST_ptr(eckey))
1025	goto err;
1026
1027	if (!TEST_true(EC_KEY_set_private_key(eckey, priv)))
1028	goto err;
1029
1030	pkey = EVP_PKEY_new();
1031	if (!TEST_ptr(pkey))
1032	goto err;
1033
1034	if (!TEST_true(EVP_PKEY_assign_EC_KEY(pkey, eckey)))
1035	goto err;
1036	eckey = NULL;
1037
1038	while (dup_pk == NULL) {
1039	ret = 0;
1040	ctx = EVP_MD_CTX_new();
1041	if (!TEST_ptr(ctx))
1042	goto err;
1043
1044	/*
1045	* The EVP_DigestSignInit function should create the key on the
1046	* provider side which is sufficient for this test.
1047	*/
1048	if (!TEST_true(EVP_DigestSignInit_ex(ctx, NULL, NULL, testctx,
1049	testpropq, pkey, NULL)))
1050	goto err;
1051	EVP_MD_CTX_free(ctx);
1052	ctx = NULL;
1053
1054	if (!TEST_ptr(dup_pk = EVP_PKEY_dup(pkey)))
1055	goto err;
1056	/* EVP_PKEY_eq() returns -2 with missing public keys */
1057	ret = TEST_int_eq(EVP_PKEY_eq(pkey, dup_pk), -2);
1058	EVP_PKEY_free(pkey);
1059	pkey = dup_pk;
1060	if (!ret)
1061	goto err;
1062	}
1063
1064	err:
1065	EVP_MD_CTX_free(ctx);
1066	EVP_PKEY_free(pkey);
1067	EC_KEY_free(eckey);
1068	BN_free(priv);
1069
1070	return ret;
1071	}
1072	# endif /* OPENSSL_NO_DEPRECATED_3_0 */
1073	#endif /* OPENSSL_NO_EC */
1074
1075	static int test_EVP_PKEY_sign(int tst)
1076	{
1077	int ret = 0;
1078	EVP_PKEY *pkey = NULL;
1079	unsigned char *sig = NULL;
1080	size_t sig_len = 0, shortsig_len = 1;
1081	EVP_PKEY_CTX *ctx = NULL;
1082	unsigned char tbs[] = {
1083	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
1084	0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13
1085	};
1086
1087	if (tst == 0 ) {
1088	if (!TEST_ptr(pkey = load_example_rsa_key()))
1089	goto out;
1090	} else if (tst == 1) {
1091	#ifndef OPENSSL_NO_DSA
1092	if (!TEST_ptr(pkey = load_example_dsa_key()))
1093	goto out;
1094	#else
1095	ret = 1;
1096	goto out;
1097	#endif
1098	} else {
1099	#ifndef OPENSSL_NO_EC
1100	if (!TEST_ptr(pkey = load_example_ec_key()))
1101	goto out;
1102	#else
1103	ret = 1;
1104	goto out;
1105	#endif
1106	}
1107
1108	ctx = EVP_PKEY_CTX_new_from_pkey(testctx, pkey, NULL);
1109	if (!TEST_ptr(ctx)
1110	\|\| !TEST_int_gt(EVP_PKEY_sign_init(ctx), 0)
1111	\|\| !TEST_int_gt(EVP_PKEY_sign(ctx, NULL, &sig_len, tbs,
1112	sizeof(tbs)), 0))
1113	goto out;
1114	sig = OPENSSL_malloc(sig_len);
1115	if (!TEST_ptr(sig)
1116	/* Test sending a signature buffer that is too short is rejected */
1117	\|\| !TEST_int_le(EVP_PKEY_sign(ctx, sig, &shortsig_len, tbs,
1118	sizeof(tbs)), 0)
1119	\|\| !TEST_int_gt(EVP_PKEY_sign(ctx, sig, &sig_len, tbs, sizeof(tbs)),
1120	0)
1121	/* Test the signature round-trips */
1122	\|\| !TEST_int_gt(EVP_PKEY_verify_init(ctx), 0)
1123	\|\| !TEST_int_gt(EVP_PKEY_verify(ctx, sig, sig_len, tbs, sizeof(tbs)),
1124	0))
1125	goto out;
1126
1127	ret = 1;
1128	out:
1129	EVP_PKEY_CTX_free(ctx);
1130	OPENSSL_free(sig);
1131	EVP_PKEY_free(pkey);
1132	return ret;
1133	}
1134
1135	/*
1136	* n = 0 => test using legacy cipher
1137	* n = 1 => test using fetched cipher
1138	*/
1139	static int test_EVP_Enveloped(int n)
1140	{
1141	int ret = 0;
1142	EVP_CIPHER_CTX *ctx = NULL;
1143	EVP_PKEY *keypair = NULL;
1144	unsigned char *kek = NULL;
1145	unsigned char iv[EVP_MAX_IV_LENGTH];
1146	static const unsigned char msg[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
1147	int len, kek_len, ciphertext_len, plaintext_len;
1148	unsigned char ciphertext[32], plaintext[16];
1149	EVP_CIPHER *type = NULL;
1150
1151	if (nullprov != NULL)
1152	return TEST_skip("Test does not support a non-default library context");
1153
1154	if (n == 0)
1155	type = (EVP_CIPHER *)EVP_aes_256_cbc();
1156	else if (!TEST_ptr(type = EVP_CIPHER_fetch(testctx, "AES-256-CBC",
1157	testpropq)))
1158	goto err;
1159
1160	if (!TEST_ptr(keypair = load_example_rsa_key())
1161	\|\| !TEST_ptr(kek = OPENSSL_zalloc(EVP_PKEY_get_size(keypair)))
1162	\|\| !TEST_ptr(ctx = EVP_CIPHER_CTX_new())
1163	\|\| !TEST_true(EVP_SealInit(ctx, type, &kek, &kek_len, iv,
1164	&keypair, 1))
1165	\|\| !TEST_true(EVP_SealUpdate(ctx, ciphertext, &ciphertext_len,
1166	msg, sizeof(msg)))
1167	\|\| !TEST_true(EVP_SealFinal(ctx, ciphertext + ciphertext_len,
1168	&len)))
1169	goto err;
1170
1171	ciphertext_len += len;
1172
1173	if (!TEST_true(EVP_OpenInit(ctx, type, kek, kek_len, iv, keypair))
1174	\|\| !TEST_true(EVP_OpenUpdate(ctx, plaintext, &plaintext_len,
1175	ciphertext, ciphertext_len))
1176	\|\| !TEST_true(EVP_OpenFinal(ctx, plaintext + plaintext_len, &len)))
1177	goto err;
1178
1179	plaintext_len += len;
1180	if (!TEST_mem_eq(msg, sizeof(msg), plaintext, plaintext_len))
1181	goto err;
1182
1183	ret = 1;
1184	err:
1185	if (n != 0)
1186	EVP_CIPHER_free(type);
1187	OPENSSL_free(kek);
1188	EVP_PKEY_free(keypair);
1189	EVP_CIPHER_CTX_free(ctx);
1190	return ret;
1191	}
1192
1193	/*
1194	* Test 0: Standard calls to EVP_DigestSignInit/Update/Final (Implicit fetch digest, RSA)
1195	* Test 1: Standard calls to EVP_DigestSignInit/Update/Final (Implicit fetch digest, DSA)
1196	* Test 2: Standard calls to EVP_DigestSignInit/Update/Final (Implicit fetch digest, HMAC)
1197	* Test 3: Standard calls to EVP_DigestSignInit/Update/Final (Explicit fetch digest, RSA)
1198	* Test 4: Standard calls to EVP_DigestSignInit/Update/Final (Explicit fetch digest, DSA)
1199	* Test 5: Standard calls to EVP_DigestSignInit/Update/Final (Explicit fetch diegst, HMAC)
1200	* Test 6: Use an MD BIO to do the Update calls instead (RSA)
1201	* Test 7: Use an MD BIO to do the Update calls instead (DSA)
1202	* Test 8: Use an MD BIO to do the Update calls instead (HMAC)
1203	* Test 9: Use EVP_DigestSign (Implicit fetch digest, RSA, short sig)
1204	* Test 10: Use EVP_DigestSign (Implicit fetch digest, DSA, short sig)
1205	* Test 11: Use EVP_DigestSign (Implicit fetch digest, HMAC, short sig)
1206	* Test 12: Use EVP_DigestSign (Implicit fetch digest, RSA)
1207	* Test 13: Use EVP_DigestSign (Implicit fetch digest, DSA)
1208	* Test 14: Use EVP_DigestSign (Implicit fetch digest, HMAC)
1209	* Test 15-29: Same as above with reinitialization
1210	*/
1211	static int test_EVP_DigestSignInit(int tst)
1212	{
1213	int ret = 0;
1214	EVP_PKEY *pkey = NULL;
1215	unsigned char sig = NULL, sig2 = NULL;
1216	size_t sig_len = 0, sig2_len = 0, shortsig_len = 1;
1217	EVP_MD_CTX md_ctx = NULL, md_ctx_verify = NULL;
1218	EVP_MD_CTX a_md_ctx = NULL, a_md_ctx_verify = NULL;
1219	BIO mdbio = NULL, membio = NULL;
1220	size_t written;
1221	const EVP_MD *md;
1222	EVP_MD *mdexp = NULL;
1223	int reinit = 0;
1224
1225	if (nullprov != NULL)
1226	return TEST_skip("Test does not support a non-default library context");
1227
1228	if (tst >= 15) {
1229	reinit = 1;
1230	tst -= 15;
1231	}
1232
1233	if (tst >= 6 && tst <= 8) {
1234	membio = BIO_new(BIO_s_mem());
1235	mdbio = BIO_new(BIO_f_md());
1236	if (!TEST_ptr(membio) \|\| !TEST_ptr(mdbio))
1237	goto out;
1238	BIO_push(mdbio, membio);
1239	if (!TEST_int_gt(BIO_get_md_ctx(mdbio, &md_ctx), 0))
1240	goto out;
1241	} else {
1242	if (!TEST_ptr(a_md_ctx = md_ctx = EVP_MD_CTX_new())
1243	\|\| !TEST_ptr(a_md_ctx_verify = md_ctx_verify = EVP_MD_CTX_new()))
1244	goto out;
1245	}
1246
1247	if (tst % 3 == 0) {
1248	if (!TEST_ptr(pkey = load_example_rsa_key()))
1249	goto out;
1250	} else if (tst % 3 == 1) {
1251	#ifndef OPENSSL_NO_DSA
1252	if (!TEST_ptr(pkey = load_example_dsa_key()))
1253	goto out;
1254	#else
1255	ret = 1;
1256	goto out;
1257	#endif
1258	} else {
1259	if (!TEST_ptr(pkey = load_example_hmac_key()))
1260	goto out;
1261	}
1262
1263	if (tst >= 3 && tst <= 5)
1264	md = mdexp = EVP_MD_fetch(NULL, "SHA256", NULL);
1265	else
1266	md = EVP_sha256();
1267
1268	if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, md, NULL, pkey)))
1269	goto out;
1270
1271	if (reinit && !TEST_true(EVP_DigestSignInit(md_ctx, NULL, NULL, NULL, NULL)))
1272	goto out;
1273
1274	if (tst >= 6 && tst <= 8) {
1275	if (!BIO_write_ex(mdbio, kMsg, sizeof(kMsg), &written))
1276	goto out;
1277	} else if (tst < 6) {
1278	if (!TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
1279	goto out;
1280	}
1281
1282	if (tst >= 9) {
1283	/* Determine the size of the signature. */
1284	if (!TEST_true(EVP_DigestSign(md_ctx, NULL, &sig_len, kMsg,
1285	sizeof(kMsg)))
1286	\|\| !TEST_ptr(sig = OPENSSL_malloc(sig_len)))
1287	goto out;
1288	if (tst <= 11) {
1289	/* Test that supply a short sig buffer fails */
1290	if (!TEST_false(EVP_DigestSign(md_ctx, sig, &shortsig_len, kMsg,
1291	sizeof(kMsg))))
1292	goto out;
1293	/*
1294	* We end here because once EVP_DigestSign() has failed you should
1295	* not call it again without re-initing the ctx
1296	*/
1297	ret = 1;
1298	goto out;
1299	}
1300	if (!TEST_true(EVP_DigestSign(md_ctx, sig, &sig_len, kMsg,
1301	sizeof(kMsg))))
1302	goto out;
1303	} else {
1304	/* Determine the size of the signature. */
1305	if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len))
1306	\|\| !TEST_ptr(sig = OPENSSL_malloc(sig_len))
1307	/*
1308	* Trying to create a signature with a deliberately short
1309	* buffer should fail.
1310	*/
1311	\|\| !TEST_false(EVP_DigestSignFinal(md_ctx, sig, &shortsig_len))
1312	\|\| !TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
1313	goto out;
1314	}
1315
1316	/*
1317	* Ensure that the signature round-trips (Verification isn't supported for
1318	* HMAC via EVP_DigestVerify*)
1319	*/
1320	if (tst % 3 != 2) {
1321	if (tst >= 6 && tst <= 8) {
1322	if (!TEST_int_gt(BIO_reset(mdbio), 0)
1323	\|\| !TEST_int_gt(BIO_get_md_ctx(mdbio, &md_ctx_verify), 0))
1324	goto out;
1325	}
1326
1327	if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, md,
1328	NULL, pkey)))
1329	goto out;
1330
1331	if (tst >= 6 && tst <= 8) {
1332	if (!TEST_true(BIO_write_ex(mdbio, kMsg, sizeof(kMsg), &written)))
1333	goto out;
1334	} else {
1335	if (!TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify, kMsg,
1336	sizeof(kMsg))))
1337	goto out;
1338	}
1339	if (!TEST_int_gt(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len), 0))
1340	goto out;
1341
1342	/* Multiple calls to EVP_DigestVerifyFinal should work */
1343	if (!TEST_int_gt(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len), 0))
1344	goto out;
1345	} else {
1346	/*
1347	* For HMAC a doubled call to DigestSignFinal should produce the same
1348	* value as finalization should not happen.
1349	*/
1350	if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig2_len))
1351	\|\| !TEST_ptr(sig2 = OPENSSL_malloc(sig2_len))
1352	\|\| !TEST_true(EVP_DigestSignFinal(md_ctx, sig2, &sig2_len)))
1353	goto out;
1354
1355	if (!TEST_mem_eq(sig, sig_len, sig2, sig2_len))
1356	goto out;
1357	}
1358
1359	ret = 1;
1360
1361	out:
1362	BIO_free(membio);
1363	BIO_free(mdbio);
1364	EVP_MD_CTX_free(a_md_ctx);
1365	EVP_MD_CTX_free(a_md_ctx_verify);
1366	EVP_PKEY_free(pkey);
1367	OPENSSL_free(sig);
1368	OPENSSL_free(sig2);
1369	EVP_MD_free(mdexp);
1370
1371	return ret;
1372	}
1373
1374	static int test_EVP_DigestVerifyInit(void)
1375	{
1376	int ret = 0;
1377	EVP_PKEY *pkey = NULL;
1378	EVP_MD_CTX *md_ctx = NULL;
1379
1380	if (nullprov != NULL)
1381	return TEST_skip("Test does not support a non-default library context");
1382
1383	if (!TEST_ptr(md_ctx = EVP_MD_CTX_new())
1384	\|\| !TEST_ptr(pkey = load_example_rsa_key()))
1385	goto out;
1386
1387	if (!TEST_true(EVP_DigestVerifyInit(md_ctx, NULL, EVP_sha256(), NULL, pkey))
1388	\|\| !TEST_true(EVP_DigestVerifyUpdate(md_ctx, kMsg, sizeof(kMsg)))
1389	\|\| !TEST_int_gt(EVP_DigestVerifyFinal(md_ctx, kSignature,
1390	sizeof(kSignature)), 0))
1391	goto out;
1392
1393	/* test with reinitialization */
1394	if (!TEST_true(EVP_DigestVerifyInit(md_ctx, NULL, NULL, NULL, NULL))
1395	\|\| !TEST_true(EVP_DigestVerifyUpdate(md_ctx, kMsg, sizeof(kMsg)))
1396	\|\| !TEST_int_gt(EVP_DigestVerifyFinal(md_ctx, kSignature,
1397	sizeof(kSignature)), 0))
1398	goto out;
1399	ret = 1;
1400
1401	out:
1402	EVP_MD_CTX_free(md_ctx);
1403	EVP_PKEY_free(pkey);
1404	return ret;
1405	}
1406
1407	#ifndef OPENSSL_NO_SIPHASH
1408	/* test SIPHASH MAC via EVP_PKEY with non-default parameters and reinit */
1409	static int test_siphash_digestsign(void)
1410	{
1411	unsigned char key[16];
1412	unsigned char buf[8], digest[8];
1413	unsigned char expected[8] = {
1414	0x6d, 0x3e, 0x54, 0xc2, 0x2f, 0xf1, 0xfe, 0xe2
1415	};
1416	EVP_PKEY *pkey = NULL;
1417	EVP_MD_CTX *mdctx = NULL;
1418	EVP_PKEY_CTX *ctx = NULL;
1419	int ret = 0;
1420	size_t len = 8;
1421
1422	if (nullprov != NULL)
1423	return TEST_skip("Test does not support a non-default library context");
1424
1425	memset(buf, 0, 8);
1426	memset(key, 1, 16);
1427	if (!TEST_ptr(pkey = EVP_PKEY_new_raw_private_key(EVP_PKEY_SIPHASH, NULL,
1428	key, 16)))
1429	goto out;
1430
1431	if (!TEST_ptr(mdctx = EVP_MD_CTX_create()))
1432	goto out;
1433
1434	if (!TEST_true(EVP_DigestSignInit(mdctx, &ctx, NULL, NULL, pkey)))
1435	goto out;
1436	if (!TEST_int_eq(EVP_PKEY_CTX_ctrl(ctx, -1, EVP_PKEY_OP_SIGNCTX,
1437	EVP_PKEY_CTRL_SET_DIGEST_SIZE,
1438	8, NULL), 1))
1439	goto out;
1440	/* reinitialize */
1441	if (!TEST_true(EVP_DigestSignInit(mdctx, NULL, NULL, NULL, NULL)))
1442	goto out;
1443	if (!TEST_true(EVP_DigestSignUpdate(mdctx, buf, 8)))
1444	goto out;
1445	if (!TEST_true(EVP_DigestSignFinal(mdctx, digest, &len)))
1446	goto out;
1447	if (!TEST_mem_eq(digest, len, expected, sizeof(expected)))
1448	goto out;
1449
1450	ret = 1;
1451	out:
1452	EVP_PKEY_free(pkey);
1453	EVP_MD_CTX_free(mdctx);
1454	return ret;
1455	}
1456	#endif
1457
1458	/*
1459	* Test corner cases of EVP_DigestInit/Update/Final API call behavior.
1460	*/
1461	static int test_EVP_Digest(void)
1462	{
1463	int ret = 0;
1464	EVP_MD_CTX *md_ctx = NULL;
1465	unsigned char md[EVP_MAX_MD_SIZE];
1466	EVP_MD *sha256 = NULL;
1467	EVP_MD *shake256 = NULL;
1468
1469	if (!TEST_ptr(md_ctx = EVP_MD_CTX_new()))
1470	goto out;
1471
1472	if (!TEST_ptr(sha256 = EVP_MD_fetch(testctx, "sha256", testpropq))
1473	\|\| !TEST_ptr(shake256 = EVP_MD_fetch(testctx, "shake256", testpropq)))
1474	goto out;
1475
1476	if (!TEST_true(EVP_DigestInit_ex(md_ctx, sha256, NULL))
1477	\|\| !TEST_true(EVP_DigestUpdate(md_ctx, kMsg, sizeof(kMsg)))
1478	\|\| !TEST_true(EVP_DigestFinal(md_ctx, md, NULL))
1479	/* EVP_DigestFinal resets the EVP_MD_CTX. */
1480	\|\| !TEST_ptr_eq(EVP_MD_CTX_get0_md(md_ctx), NULL))
1481	goto out;
1482
1483	if (!TEST_true(EVP_DigestInit_ex(md_ctx, sha256, NULL))
1484	\|\| !TEST_true(EVP_DigestUpdate(md_ctx, kMsg, sizeof(kMsg)))
1485	\|\| !TEST_true(EVP_DigestFinal_ex(md_ctx, md, NULL))
1486	/* EVP_DigestFinal_ex does not reset the EVP_MD_CTX. */
1487	\|\| !TEST_ptr(EVP_MD_CTX_get0_md(md_ctx))
1488	/*
1489	* EVP_DigestInit_ex with NULL type should work on
1490	* pre-initialized context.
1491	*/
1492	\|\| !TEST_true(EVP_DigestInit_ex(md_ctx, NULL, NULL)))
1493	goto out;
1494
1495	if (!TEST_true(EVP_DigestInit_ex(md_ctx, shake256, NULL))
1496	\|\| !TEST_true(EVP_DigestUpdate(md_ctx, kMsg, sizeof(kMsg)))
1497	\|\| !TEST_true(EVP_DigestFinalXOF(md_ctx, md, sizeof(md)))
1498	/* EVP_DigestFinalXOF does not reset the EVP_MD_CTX. */
1499	\|\| !TEST_ptr(EVP_MD_CTX_get0_md(md_ctx))
1500	\|\| !TEST_true(EVP_DigestInit_ex(md_ctx, NULL, NULL)))
1501	goto out;
1502	ret = 1;
1503
1504	out:
1505	EVP_MD_CTX_free(md_ctx);
1506	EVP_MD_free(sha256);
1507	EVP_MD_free(shake256);
1508	return ret;
1509	}
1510
1511	static int test_EVP_md_null(void)
1512	{
1513	int ret = 0;
1514	EVP_MD_CTX *md_ctx = NULL;
1515	const EVP_MD *md_null = EVP_md_null();
1516	unsigned char md_value[EVP_MAX_MD_SIZE];
1517	unsigned int md_len = sizeof(md_value);
1518
1519	if (nullprov != NULL)
1520	return TEST_skip("Test does not support a non-default library context");
1521
1522	if (!TEST_ptr(md_null)
1523	\|\| !TEST_ptr(md_ctx = EVP_MD_CTX_new()))
1524	goto out;
1525
1526	if (!TEST_true(EVP_DigestInit_ex(md_ctx, md_null, NULL))
1527	\|\| !TEST_true(EVP_DigestUpdate(md_ctx, "test", 4))
1528	\|\| !TEST_true(EVP_DigestFinal_ex(md_ctx, md_value, &md_len)))
1529	goto out;
1530
1531	if (!TEST_uint_eq(md_len, 0))
1532	goto out;
1533
1534	ret = 1;
1535	out:
1536	EVP_MD_CTX_free(md_ctx);
1537	return ret;
1538	}
1539
1540	static int test_d2i_AutoPrivateKey(int i)
1541	{
1542	int ret = 0;
1543	const unsigned char *p;
1544	EVP_PKEY *pkey = NULL;
1545	const APK_DATA *ak = &keydata[i];
1546	const unsigned char *input = ak->kder;
1547	size_t input_len = ak->size;
1548	int expected_id = ak->evptype;
1549
1550	p = input;
1551	if (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
1552	\|\| !TEST_ptr_eq(p, input + input_len)
1553	\|\| !TEST_int_eq(EVP_PKEY_get_id(pkey), expected_id))
1554	goto done;
1555
1556	ret = 1;
1557
1558	done:
1559	EVP_PKEY_free(pkey);
1560	return ret;
1561	}
1562
1563	#ifndef OPENSSL_NO_EC
1564
1565	static const unsigned char ec_public_sect163k1_validxy[] = {
1566	0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
1567	0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04,
1568	0x02, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69,
1569	0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0x79, 0x02, 0xd1, 0x7b,
1570	0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3,
1571	0x6a, 0xd8, 0x17, 0x65, 0x41, 0x2f
1572	};
1573
1574	static const unsigned char ec_public_sect163k1_badx[] = {
1575	0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
1576	0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04,
1577	0x0a, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69,
1578	0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0xb0, 0x02, 0xd1, 0x7b,
1579	0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3,
1580	0x6a, 0xd8, 0x17, 0x65, 0x41, 0x2f
1581	};
1582
1583	static const unsigned char ec_public_sect163k1_bady[] = {
1584	0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
1585	0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04,
1586	0x02, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69,
1587	0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0x79, 0x0a, 0xd1, 0x7b,
1588	0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3,
1589	0x6a, 0xd8, 0x17, 0x65, 0x41, 0xe6
1590	};
1591
1592	static struct ec_der_pub_keys_st {
1593	const unsigned char *der;
1594	size_t len;
1595	int valid;
1596	} ec_der_pub_keys[] = {
1597	{ ec_public_sect163k1_validxy, sizeof(ec_public_sect163k1_validxy), 1 },
1598	{ ec_public_sect163k1_badx, sizeof(ec_public_sect163k1_badx), 0 },
1599	{ ec_public_sect163k1_bady, sizeof(ec_public_sect163k1_bady), 0 },
1600	};
1601
1602	/*
1603	* Tests the range of the decoded EC char2 public point.
1604	* See ec_GF2m_simple_oct2point().
1605	*/
1606	static int test_invalide_ec_char2_pub_range_decode(int id)
1607	{
1608	int ret = 0;
1609	EVP_PKEY *pkey;
1610
1611	pkey = load_example_key("EC", ec_der_pub_keys[id].der,
1612	ec_der_pub_keys[id].len);
1613
1614	ret = (ec_der_pub_keys[id].valid && TEST_ptr(pkey))
1615	\|\| TEST_ptr_null(pkey);
1616	EVP_PKEY_free(pkey);
1617	return ret;
1618	}
1619
1620	/* Tests loading a bad key in PKCS8 format */
1621	static int test_EVP_PKCS82PKEY(void)
1622	{
1623	int ret = 0;
1624	const unsigned char *derp = kExampleBadECKeyDER;
1625	PKCS8_PRIV_KEY_INFO *p8inf = NULL;
1626	EVP_PKEY *pkey = NULL;
1627
1628	if (!TEST_ptr(p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp,
1629	sizeof(kExampleBadECKeyDER))))
1630	goto done;
1631
1632	if (!TEST_ptr_eq(derp,
1633	kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)))
1634	goto done;
1635
1636	if (!TEST_ptr_null(pkey = EVP_PKCS82PKEY(p8inf)))
1637	goto done;
1638
1639	ret = 1;
1640
1641	done:
1642	PKCS8_PRIV_KEY_INFO_free(p8inf);
1643	EVP_PKEY_free(pkey);
1644
1645	return ret;
1646	}
1647
1648	#endif
1649	static int test_EVP_PKCS82PKEY_wrong_tag(void)
1650	{
1651	EVP_PKEY *pkey = NULL;
1652	EVP_PKEY *pkey2 = NULL;
1653	BIO *membio = NULL;
1654	char *membuf = NULL;
1655	PKCS8_PRIV_KEY_INFO *p8inf = NULL;
1656	int ok = 0;
1657
1658	if (testctx != NULL)
1659	/* test not supported with non-default context */
1660	return 1;
1661
1662	if (!TEST_ptr(membio = BIO_new(BIO_s_mem()))
1663	\|\| !TEST_ptr(pkey = load_example_rsa_key())
1664	\|\| !TEST_int_gt(i2d_PKCS8PrivateKey_bio(membio, pkey, NULL,
1665	NULL, 0, NULL, NULL),
1666	0)
1667	\|\| !TEST_int_gt(BIO_get_mem_data(membio, &membuf), 0)
1668	\|\| !TEST_ptr(p8inf = d2i_PKCS8_PRIV_KEY_INFO_bio(membio, NULL))
1669	\|\| !TEST_ptr(pkey2 = EVP_PKCS82PKEY(p8inf))
1670	\|\| !TEST_int_eq(ERR_peek_last_error(), 0)) {
1671	goto done;
1672	}
1673
1674	ok = 1;
1675	done:
1676	EVP_PKEY_free(pkey);
1677	EVP_PKEY_free(pkey2);
1678	PKCS8_PRIV_KEY_INFO_free(p8inf);
1679	BIO_free_all(membio);
1680	return ok;
1681	}
1682
1683	/* This uses kExampleRSAKeyDER and kExampleRSAKeyPKCS8 to verify encoding */
1684	static int test_privatekey_to_pkcs8(void)
1685	{
1686	EVP_PKEY *pkey = NULL;
1687	BIO *membio = NULL;
1688	char *membuf = NULL;
1689	long membuf_len = 0;
1690	int ok = 0;
1691
1692	if (!TEST_ptr(membio = BIO_new(BIO_s_mem()))
1693	\|\| !TEST_ptr(pkey = load_example_rsa_key())
1694	\|\| !TEST_int_gt(i2d_PKCS8PrivateKey_bio(membio, pkey, NULL,
1695	NULL, 0, NULL, NULL),
1696	0)
1697	\|\| !TEST_int_gt(membuf_len = BIO_get_mem_data(membio, &membuf), 0)
1698	\|\| !TEST_ptr(membuf)
1699	\|\| !TEST_mem_eq(membuf, (size_t)membuf_len,
1700	kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8))
1701	/*
1702	* We try to write PEM as well, just to see that it doesn't err, but
1703	* assume that the result is correct.
1704	*/
1705	\|\| !TEST_int_gt(PEM_write_bio_PKCS8PrivateKey(membio, pkey, NULL,
1706	NULL, 0, NULL, NULL),
1707	0))
1708	goto done;
1709
1710	ok = 1;
1711	done:
1712	EVP_PKEY_free(pkey);
1713	BIO_free_all(membio);
1714	return ok;
1715	}
1716
1717	#ifndef OPENSSL_NO_EC
1718	static const struct {
1719	int encoding;
1720	const char *encoding_name;
1721	} ec_encodings[] = {
1722	{ OPENSSL_EC_EXPLICIT_CURVE, OSSL_PKEY_EC_ENCODING_EXPLICIT },
1723	{ OPENSSL_EC_NAMED_CURVE, OSSL_PKEY_EC_ENCODING_GROUP }
1724	};
1725
1726	static int ec_export_get_encoding_cb(const OSSL_PARAM params[], void *arg)
1727	{
1728	const OSSL_PARAM *p;
1729	const char *enc_name = NULL;
1730	int *enc = arg;
1731	size_t i;
1732
1733	*enc = -1;
1734
1735	if (!TEST_ptr(p = OSSL_PARAM_locate_const(params,
1736	OSSL_PKEY_PARAM_EC_ENCODING))
1737	\|\| !TEST_true(OSSL_PARAM_get_utf8_string_ptr(p, &enc_name)))
1738	return 0;
1739
1740	for (i = 0; i < OSSL_NELEM(ec_encodings); i++) {
1741	if (OPENSSL_strcasecmp(enc_name, ec_encodings[i].encoding_name) == 0) {
1742	*enc = ec_encodings[i].encoding;
1743	break;
1744	}
1745	}
1746
1747	return (*enc != -1);
1748	}
1749
1750	static int test_EC_keygen_with_enc(int idx)
1751	{
1752	EVP_PKEY params = NULL, key = NULL;
1753	EVP_PKEY_CTX pctx = NULL, kctx = NULL;
1754	int enc;
1755	int ret = 0;
1756
1757	enc = ec_encodings[idx].encoding;
1758
1759	/* Create key parameters */
1760	if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_from_name(testctx, "EC", NULL))
1761	\|\| !TEST_int_gt(EVP_PKEY_paramgen_init(pctx), 0)
1762	\|\| !TEST_true(EVP_PKEY_CTX_set_group_name(pctx, "P-256"))
1763	\|\| !TEST_true(EVP_PKEY_CTX_set_ec_param_enc(pctx, enc))
1764	\|\| !TEST_true(EVP_PKEY_paramgen(pctx, &params))
1765	\|\| !TEST_ptr(params))
1766	goto done;
1767
1768	/* Create key */
1769	if (!TEST_ptr(kctx = EVP_PKEY_CTX_new_from_pkey(testctx, params, NULL))
1770	\|\| !TEST_int_gt(EVP_PKEY_keygen_init(kctx), 0)
1771	\|\| !TEST_true(EVP_PKEY_keygen(kctx, &key))
1772	\|\| !TEST_ptr(key))
1773	goto done;
1774
1775	/* Check that the encoding got all the way into the key */
1776	if (!TEST_true(evp_keymgmt_util_export(key, OSSL_KEYMGMT_SELECT_ALL,
1777	ec_export_get_encoding_cb, &enc))
1778	\|\| !TEST_int_eq(enc, ec_encodings[idx].encoding))
1779	goto done;
1780
1781	ret = 1;
1782	done:
1783	EVP_PKEY_free(key);
1784	EVP_PKEY_free(params);
1785	EVP_PKEY_CTX_free(kctx);
1786	EVP_PKEY_CTX_free(pctx);
1787	return ret;
1788	}
1789	#endif
1790
1791	#if !defined(OPENSSL_NO_SM2) && !defined(FIPS_MODULE)
1792
1793	static int test_EVP_SM2_verify(void)
1794	{
1795	const char *pubkey =
1796	"-----BEGIN PUBLIC KEY-----\n"
1797	"MFkwEwYHKoZIzj0CAQYIKoEcz1UBgi0DQgAEp1KLWq1ZE2jmoAnnBJE1LBGxVr18\n"
1798	"YvvqECWCpXfAQ9qUJ+UmthnUPf0iM3SaXKHe6PlLIDyNlWMWb9RUh/yU3g==\n"
1799	"-----END PUBLIC KEY-----\n";
1800
1801	const char *msg = "message digest";
1802	const char *id = "ALICE123@YAHOO.COM";
1803
1804	const uint8_t signature[] = {
1805	0x30, 0x44, 0x02, 0x20, 0x5b, 0xdb, 0xab, 0x81, 0x4f, 0xbb,
1806	0x8b, 0x69, 0xb1, 0x05, 0x9c, 0x99, 0x3b, 0xb2, 0x45, 0x06,
1807	0x4a, 0x30, 0x15, 0x59, 0x84, 0xcd, 0xee, 0x30, 0x60, 0x36,
1808	0x57, 0x87, 0xef, 0x5c, 0xd0, 0xbe, 0x02, 0x20, 0x43, 0x8d,
1809	0x1f, 0xc7, 0x77, 0x72, 0x39, 0xbb, 0x72, 0xe1, 0xfd, 0x07,
1810	0x58, 0xd5, 0x82, 0xc8, 0x2d, 0xba, 0x3b, 0x2c, 0x46, 0x24,
1811	0xe3, 0x50, 0xff, 0x04, 0xc7, 0xa0, 0x71, 0x9f, 0xa4, 0x70
1812	};
1813
1814	int rc = 0;
1815	BIO *bio = NULL;
1816	EVP_PKEY *pkey = NULL;
1817	EVP_MD_CTX *mctx = NULL;
1818	EVP_PKEY_CTX *pctx = NULL;
1819	EVP_MD *sm3 = NULL;
1820
1821	bio = BIO_new_mem_buf(pubkey, strlen(pubkey));
1822	if (!TEST_true(bio != NULL))
1823	goto done;
1824
1825	pkey = PEM_read_bio_PUBKEY_ex(bio, NULL, NULL, NULL, testctx, testpropq);
1826	if (!TEST_true(pkey != NULL))
1827	goto done;
1828
1829	if (!TEST_true(EVP_PKEY_is_a(pkey, "SM2")))
1830	goto done;
1831
1832	if (!TEST_ptr(mctx = EVP_MD_CTX_new()))
1833	goto done;
1834
1835	if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_from_pkey(testctx, pkey, testpropq)))
1836	goto done;
1837
1838	EVP_MD_CTX_set_pkey_ctx(mctx, pctx);
1839
1840	if (!TEST_ptr(sm3 = EVP_MD_fetch(testctx, "sm3", testpropq)))
1841	goto done;
1842
1843	if (!TEST_true(EVP_DigestVerifyInit(mctx, NULL, sm3, NULL, pkey)))
1844	goto done;
1845
1846	if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(pctx, id, strlen(id)), 0))
1847	goto done;
1848
1849	if (!TEST_true(EVP_DigestVerifyUpdate(mctx, msg, strlen(msg))))
1850	goto done;
1851
1852	if (!TEST_int_gt(EVP_DigestVerifyFinal(mctx, signature, sizeof(signature)), 0))
1853	goto done;
1854	rc = 1;
1855
1856	done:
1857	BIO_free(bio);
1858	EVP_PKEY_free(pkey);
1859	EVP_PKEY_CTX_free(pctx);
1860	EVP_MD_CTX_free(mctx);
1861	EVP_MD_free(sm3);
1862	return rc;
1863	}
1864
1865	static int test_EVP_SM2(void)
1866	{
1867	int ret = 0;
1868	EVP_PKEY *pkey = NULL;
1869	EVP_PKEY *pkeyparams = NULL;
1870	EVP_PKEY_CTX *pctx = NULL;
1871	EVP_PKEY_CTX *kctx = NULL;
1872	EVP_PKEY_CTX *sctx = NULL;
1873	size_t sig_len = 0;
1874	unsigned char *sig = NULL;
1875	EVP_MD_CTX *md_ctx = NULL;
1876	EVP_MD_CTX *md_ctx_verify = NULL;
1877	EVP_PKEY_CTX *cctx = NULL;
1878	EVP_MD *check_md = NULL;
1879
1880	uint8_t ciphertext[128];
1881	size_t ctext_len = sizeof(ciphertext);
1882
1883	uint8_t plaintext[8];
1884	size_t ptext_len = sizeof(plaintext);
1885
1886	uint8_t sm2_id[] = {1, 2, 3, 4, 'l', 'e', 't', 't', 'e', 'r'};
1887
1888	OSSL_PARAM sparams[2] = {OSSL_PARAM_END, OSSL_PARAM_END};
1889	OSSL_PARAM gparams[2] = {OSSL_PARAM_END, OSSL_PARAM_END};
1890	int i;
1891	char mdname[OSSL_MAX_NAME_SIZE];
1892
1893	if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_from_name(testctx,
1894	"SM2", testpropq)))
1895	goto done;
1896
1897	if (!TEST_true(EVP_PKEY_paramgen_init(pctx) == 1))
1898	goto done;
1899
1900	if (!TEST_true(EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx, NID_sm2)))
1901	goto done;
1902
1903	if (!TEST_true(EVP_PKEY_paramgen(pctx, &pkeyparams)))
1904	goto done;
1905
1906	if (!TEST_ptr(kctx = EVP_PKEY_CTX_new_from_pkey(testctx,
1907	pkeyparams, testpropq)))
1908	goto done;
1909
1910	if (!TEST_int_gt(EVP_PKEY_keygen_init(kctx), 0))
1911	goto done;
1912
1913	if (!TEST_true(EVP_PKEY_keygen(kctx, &pkey)))
1914	goto done;
1915
1916	if (!TEST_ptr(md_ctx = EVP_MD_CTX_new()))
1917	goto done;
1918
1919	if (!TEST_ptr(md_ctx_verify = EVP_MD_CTX_new()))
1920	goto done;
1921
1922	if (!TEST_ptr(sctx = EVP_PKEY_CTX_new_from_pkey(testctx, pkey, testpropq)))
1923	goto done;
1924
1925	EVP_MD_CTX_set_pkey_ctx(md_ctx, sctx);
1926	EVP_MD_CTX_set_pkey_ctx(md_ctx_verify, sctx);
1927
1928	if (!TEST_ptr(check_md = EVP_MD_fetch(testctx, "sm3", testpropq)))
1929	goto done;
1930
1931	if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, check_md, NULL, pkey)))
1932	goto done;
1933
1934	if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(sctx, sm2_id, sizeof(sm2_id)), 0))
1935	goto done;
1936
1937	if (!TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
1938	goto done;
1939
1940	/* Determine the size of the signature. */
1941	if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len)))
1942	goto done;
1943
1944	if (!TEST_ptr(sig = OPENSSL_malloc(sig_len)))
1945	goto done;
1946
1947	if (!TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
1948	goto done;
1949
1950	/* Ensure that the signature round-trips. */
1951
1952	if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, check_md, NULL,
1953	pkey)))
1954	goto done;
1955
1956	if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(sctx, sm2_id, sizeof(sm2_id)), 0))
1957	goto done;
1958
1959	if (!TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify, kMsg, sizeof(kMsg))))
1960	goto done;
1961
1962	if (!TEST_int_gt(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len), 0))
1963	goto done;
1964
1965	/*
1966	* Try verify again with non-matching 0 length id but ensure that it can
1967	* be set on the context and overrides the previous value.
1968	*/
1969
1970	if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, check_md, NULL,
1971	pkey)))
1972	goto done;
1973
1974	if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(sctx, NULL, 0), 0))
1975	goto done;
1976
1977	if (!TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify, kMsg, sizeof(kMsg))))
1978	goto done;
1979
1980	if (!TEST_int_eq(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len), 0))
1981	goto done;
1982
1983	/* now check encryption/decryption */
1984
1985	gparams[0] = OSSL_PARAM_construct_utf8_string(OSSL_ASYM_CIPHER_PARAM_DIGEST,
1986	mdname, sizeof(mdname));
1987	for (i = 0; i < 2; i++) {
1988	const char *mdnames[] = {
1989	#ifndef OPENSSL_NO_SM3
1990	"SM3",
1991	#else
1992	NULL,
1993	#endif
1994	"SHA2-256" };
1995	EVP_PKEY_CTX_free(cctx);
1996
1997	if (mdnames[i] == NULL)
1998	continue;
1999
2000	sparams[0] =
2001	OSSL_PARAM_construct_utf8_string(OSSL_ASYM_CIPHER_PARAM_DIGEST,
2002	(char *)mdnames[i], 0);
2003
2004	if (!TEST_ptr(cctx = EVP_PKEY_CTX_new_from_pkey(testctx,
2005	pkey, testpropq)))
2006	goto done;
2007
2008	if (!TEST_true(EVP_PKEY_encrypt_init(cctx)))
2009	goto done;
2010
2011	if (!TEST_true(EVP_PKEY_CTX_set_params(cctx, sparams)))
2012	goto done;
2013
2014	if (!TEST_true(EVP_PKEY_encrypt(cctx, ciphertext, &ctext_len, kMsg,
2015	sizeof(kMsg))))
2016	goto done;
2017
2018	if (!TEST_true(EVP_PKEY_decrypt_init(cctx)))
2019	goto done;
2020
2021	if (!TEST_true(EVP_PKEY_CTX_set_params(cctx, sparams)))
2022	goto done;
2023
2024	if (!TEST_int_gt(EVP_PKEY_decrypt(cctx, plaintext, &ptext_len, ciphertext,
2025	ctext_len), 0))
2026	goto done;
2027
2028	if (!TEST_true(EVP_PKEY_CTX_get_params(cctx, gparams)))
2029	goto done;
2030
2031	/*
2032	* Test we're still using the digest we think we are.
2033	* Because of aliases, the easiest is to fetch the digest and
2034	* check the name with EVP_MD_is_a().
2035	*/
2036	EVP_MD_free(check_md);
2037	if (!TEST_ptr(check_md = EVP_MD_fetch(testctx, mdname, testpropq)))
2038	goto done;
2039	if (!TEST_true(EVP_MD_is_a(check_md, mdnames[i]))) {
2040	TEST_info("Fetched md %s isn't %s", mdname, mdnames[i]);
2041	goto done;
2042	}
2043
2044	if (!TEST_true(ptext_len == sizeof(kMsg)))
2045	goto done;
2046
2047	if (!TEST_true(memcmp(plaintext, kMsg, sizeof(kMsg)) == 0))
2048	goto done;
2049	}
2050
2051	ret = 1;
2052	done:
2053	EVP_PKEY_CTX_free(pctx);
2054	EVP_PKEY_CTX_free(kctx);
2055	EVP_PKEY_CTX_free(sctx);
2056	EVP_PKEY_CTX_free(cctx);
2057	EVP_PKEY_free(pkey);
2058	EVP_PKEY_free(pkeyparams);
2059	EVP_MD_CTX_free(md_ctx);
2060	EVP_MD_CTX_free(md_ctx_verify);
2061	EVP_MD_free(check_md);
2062	OPENSSL_free(sig);
2063	return ret;
2064	}
2065
2066	#endif
2067
2068	static struct keys_st {
2069	int type;
2070	char *priv;
2071	char *pub;
2072	} keys[] = {
2073	{
2074	EVP_PKEY_HMAC, "0123456789", NULL
2075	},
2076	{
2077	EVP_PKEY_HMAC, "", NULL
2078	#ifndef OPENSSL_NO_POLY1305
2079	}, {
2080	EVP_PKEY_POLY1305, "01234567890123456789012345678901", NULL
2081	#endif
2082	#ifndef OPENSSL_NO_SIPHASH
2083	}, {
2084	EVP_PKEY_SIPHASH, "0123456789012345", NULL
2085	#endif
2086	},
2087	#ifndef OPENSSL_NO_EC
2088	{
2089	EVP_PKEY_X25519, "01234567890123456789012345678901",
2090	"abcdefghijklmnopqrstuvwxyzabcdef"
2091	}, {
2092	EVP_PKEY_ED25519, "01234567890123456789012345678901",
2093	"abcdefghijklmnopqrstuvwxyzabcdef"
2094	}, {
2095	EVP_PKEY_X448,
2096	"01234567890123456789012345678901234567890123456789012345",
2097	"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd"
2098	}, {
2099	EVP_PKEY_ED448,
2100	"012345678901234567890123456789012345678901234567890123456",
2101	"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcde"
2102	}
2103	#endif
2104	};
2105
2106	static int test_set_get_raw_keys_int(int tst, int pub, int uselibctx)
2107	{
2108	int ret = 0;
2109	unsigned char buf[80];
2110	unsigned char *in;
2111	size_t inlen, len = 0, shortlen = 1;
2112	EVP_PKEY *pkey;
2113
2114	/* Check if this algorithm supports public keys */
2115	if (pub && keys[tst].pub == NULL)
2116	return 1;
2117
2118	memset(buf, 0, sizeof(buf));
2119
2120	if (pub) {
2121	#ifndef OPENSSL_NO_EC
2122	inlen = strlen(keys[tst].pub);
2123	in = (unsigned char *)keys[tst].pub;
2124	if (uselibctx) {
2125	pkey = EVP_PKEY_new_raw_public_key_ex(
2126	testctx,
2127	OBJ_nid2sn(keys[tst].type),
2128	NULL,
2129	in,
2130	inlen);
2131	} else {
2132	pkey = EVP_PKEY_new_raw_public_key(keys[tst].type,
2133	NULL,
2134	in,
2135	inlen);
2136	}
2137	#else
2138	return 1;
2139	#endif
2140	} else {
2141	inlen = strlen(keys[tst].priv);
2142	in = (unsigned char *)keys[tst].priv;
2143	if (uselibctx) {
2144	pkey = EVP_PKEY_new_raw_private_key_ex(
2145	testctx, OBJ_nid2sn(keys[tst].type),
2146	NULL,
2147	in,
2148	inlen);
2149	} else {
2150	pkey = EVP_PKEY_new_raw_private_key(keys[tst].type,
2151	NULL,
2152	in,
2153	inlen);
2154	}
2155	}
2156
2157	if (!TEST_ptr(pkey)
2158	\|\| !TEST_int_eq(EVP_PKEY_eq(pkey, pkey), 1)
2159	\|\| (!pub && !TEST_true(EVP_PKEY_get_raw_private_key(pkey, NULL, &len)))
2160	\|\| (pub && !TEST_true(EVP_PKEY_get_raw_public_key(pkey, NULL, &len)))
2161	\|\| !TEST_true(len == inlen))
2162	goto done;
2163	if (tst != 1) {
2164	/*
2165	* Test that supplying a buffer that is too small fails. Doesn't apply
2166	* to HMAC with a zero length key
2167	*/
2168	if ((!pub && !TEST_false(EVP_PKEY_get_raw_private_key(pkey, buf,
2169	&shortlen)))
2170	\|\| (pub && !TEST_false(EVP_PKEY_get_raw_public_key(pkey, buf,
2171	&shortlen))))
2172	goto done;
2173	}
2174	if ((!pub && !TEST_true(EVP_PKEY_get_raw_private_key(pkey, buf, &len)))
2175	\|\| (pub && !TEST_true(EVP_PKEY_get_raw_public_key(pkey, buf, &len)))
2176	\|\| !TEST_mem_eq(in, inlen, buf, len))
2177	goto done;
2178
2179	ret = 1;
2180	done:
2181	EVP_PKEY_free(pkey);
2182	return ret;
2183	}
2184
2185	static int test_set_get_raw_keys(int tst)
2186	{
2187	return (nullprov != NULL \|\| test_set_get_raw_keys_int(tst, 0, 0))
2188	&& test_set_get_raw_keys_int(tst, 0, 1)
2189	&& (nullprov != NULL \|\| test_set_get_raw_keys_int(tst, 1, 0))
2190	&& test_set_get_raw_keys_int(tst, 1, 1);
2191	}
2192
2193	#ifndef OPENSSL_NO_DEPRECATED_3_0
2194	static int pkey_custom_check(EVP_PKEY *pkey)
2195	{
2196	return 0xbeef;
2197	}
2198
2199	static int pkey_custom_pub_check(EVP_PKEY *pkey)
2200	{
2201	return 0xbeef;
2202	}
2203
2204	static int pkey_custom_param_check(EVP_PKEY *pkey)
2205	{
2206	return 0xbeef;
2207	}
2208
2209	static EVP_PKEY_METHOD *custom_pmeth;
2210	#endif
2211
2212	static int test_EVP_PKEY_check(int i)
2213	{
2214	int ret = 0;
2215	EVP_PKEY *pkey = NULL;
2216	EVP_PKEY_CTX *ctx = NULL;
2217	#ifndef OPENSSL_NO_DEPRECATED_3_0
2218	EVP_PKEY_CTX *ctx2 = NULL;
2219	#endif
2220	const APK_DATA *ak = &keycheckdata[i];
2221	const unsigned char *input = ak->kder;
2222	size_t input_len = ak->size;
2223	int expected_id = ak->evptype;
2224	int expected_check = ak->check;
2225	int expected_pub_check = ak->pub_check;
2226	int expected_param_check = ak->param_check;
2227	int type = ak->type;
2228
2229	if (!TEST_ptr(pkey = load_example_key(ak->keytype, input, input_len)))
2230	goto done;
2231	if (type == 0
2232	&& !TEST_int_eq(EVP_PKEY_get_id(pkey), expected_id))
2233	goto done;
2234
2235	if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_pkey(testctx, pkey, testpropq)))
2236	goto done;
2237
2238	if (!TEST_int_eq(EVP_PKEY_check(ctx), expected_check))
2239	goto done;
2240
2241	if (!TEST_int_eq(EVP_PKEY_public_check(ctx), expected_pub_check))
2242	goto done;
2243
2244	if (!TEST_int_eq(EVP_PKEY_param_check(ctx), expected_param_check))
2245	goto done;
2246
2247	#ifndef OPENSSL_NO_DEPRECATED_3_0
2248	ctx2 = EVP_PKEY_CTX_new_id(0xdefaced, NULL);
2249	/* assign the pkey directly, as an internal test */
2250	EVP_PKEY_up_ref(pkey);
2251	ctx2->pkey = pkey;
2252
2253	if (!TEST_int_eq(EVP_PKEY_check(ctx2), 0xbeef))
2254	goto done;
2255
2256	if (!TEST_int_eq(EVP_PKEY_public_check(ctx2), 0xbeef))
2257	goto done;
2258
2259	if (!TEST_int_eq(EVP_PKEY_param_check(ctx2), 0xbeef))
2260	goto done;
2261	#endif
2262
2263	ret = 1;
2264
2265	done:
2266	EVP_PKEY_CTX_free(ctx);
2267	#ifndef OPENSSL_NO_DEPRECATED_3_0
2268	EVP_PKEY_CTX_free(ctx2);
2269	#endif
2270	EVP_PKEY_free(pkey);
2271	return ret;
2272	}
2273
2274	#ifndef OPENSSL_NO_CMAC
2275	static int get_cmac_val(EVP_PKEY pkey, unsigned char mac)
2276	{
2277	EVP_MD_CTX *mdctx = EVP_MD_CTX_new();
2278	const char msg[] = "Hello World";
2279	size_t maclen = AES_BLOCK_SIZE;
2280	int ret = 1;
2281
2282	if (!TEST_ptr(mdctx)
2283	\|\| !TEST_true(EVP_DigestSignInit_ex(mdctx, NULL, NULL, testctx,
2284	testpropq, pkey, NULL))
2285	\|\| !TEST_true(EVP_DigestSignUpdate(mdctx, msg, sizeof(msg)))
2286	\|\| !TEST_true(EVP_DigestSignFinal(mdctx, mac, &maclen))
2287	\|\| !TEST_size_t_eq(maclen, AES_BLOCK_SIZE))
2288	ret = 0;
2289
2290	EVP_MD_CTX_free(mdctx);
2291
2292	return ret;
2293	}
2294	static int test_CMAC_keygen(void)
2295	{
2296	static unsigned char key[] = {
2297	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
2298	0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
2299	0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
2300	};
2301	EVP_PKEY_CTX *kctx = NULL;
2302	int ret = 0;
2303	EVP_PKEY *pkey = NULL;
2304	unsigned char mac[AES_BLOCK_SIZE];
2305	# if !defined(OPENSSL_NO_DEPRECATED_3_0)
2306	unsigned char mac2[AES_BLOCK_SIZE];
2307	# endif
2308
2309	if (nullprov != NULL)
2310	return TEST_skip("Test does not support a non-default library context");
2311
2312	/*
2313	* This is a legacy method for CMACs, but should still work.
2314	* This verifies that it works without an ENGINE.
2315	*/
2316	kctx = EVP_PKEY_CTX_new_id(EVP_PKEY_CMAC, NULL);
2317
2318	/* Test a CMAC key created using the "generated" method */
2319	if (!TEST_int_gt(EVP_PKEY_keygen_init(kctx), 0)
2320	\|\| !TEST_int_gt(EVP_PKEY_CTX_ctrl(kctx, -1, EVP_PKEY_OP_KEYGEN,
2321	EVP_PKEY_CTRL_CIPHER,
2322	0, (void *)EVP_aes_256_ecb()), 0)
2323	\|\| !TEST_int_gt(EVP_PKEY_CTX_ctrl(kctx, -1, EVP_PKEY_OP_KEYGEN,
2324	EVP_PKEY_CTRL_SET_MAC_KEY,
2325	sizeof(key), (void *)key), 0)
2326	\|\| !TEST_int_gt(EVP_PKEY_keygen(kctx, &pkey), 0)
2327	\|\| !TEST_ptr(pkey)
2328	\|\| !TEST_true(get_cmac_val(pkey, mac)))
2329	goto done;
2330
2331	# if !defined(OPENSSL_NO_DEPRECATED_3_0)
2332	EVP_PKEY_free(pkey);
2333
2334	/*
2335	* Test a CMAC key using the direct method, and compare with the mac
2336	* created above.
2337	*/
2338	pkey = EVP_PKEY_new_CMAC_key(NULL, key, sizeof(key), EVP_aes_256_ecb());
2339	if (!TEST_ptr(pkey)
2340	\|\| !TEST_true(get_cmac_val(pkey, mac2))
2341	\|\| !TEST_mem_eq(mac, sizeof(mac), mac2, sizeof(mac2)))
2342	goto done;
2343	# endif
2344
2345	ret = 1;
2346
2347	done:
2348	EVP_PKEY_free(pkey);
2349	EVP_PKEY_CTX_free(kctx);
2350	return ret;
2351	}
2352	#endif
2353
2354	static int test_HKDF(void)
2355	{
2356	EVP_PKEY_CTX *pctx;
2357	unsigned char out[20];
2358	size_t outlen;
2359	int i, ret = 0;
2360	unsigned char salt[] = "0123456789";
2361	unsigned char key[] = "012345678901234567890123456789";
2362	unsigned char info[] = "infostring";
2363	const unsigned char expected[] = {
2364	0xe5, 0x07, 0x70, 0x7f, 0xc6, 0x78, 0xd6, 0x54, 0x32, 0x5f, 0x7e, 0xc5,
2365	0x7b, 0x59, 0x3e, 0xd8, 0x03, 0x6b, 0xed, 0xca
2366	};
2367	size_t expectedlen = sizeof(expected);
2368
2369	if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_from_name(testctx, "HKDF", testpropq)))
2370	goto done;
2371
2372	/* We do this twice to test reuse of the EVP_PKEY_CTX */
2373	for (i = 0; i < 2; i++) {
2374	outlen = sizeof(out);
2375	memset(out, 0, outlen);
2376
2377	if (!TEST_int_gt(EVP_PKEY_derive_init(pctx), 0)
2378	\|\| !TEST_int_gt(EVP_PKEY_CTX_set_hkdf_md(pctx, EVP_sha256()), 0)
2379	\|\| !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_salt(pctx, salt,
2380	sizeof(salt) - 1), 0)
2381	\|\| !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_key(pctx, key,
2382	sizeof(key) - 1), 0)
2383	\|\| !TEST_int_gt(EVP_PKEY_CTX_add1_hkdf_info(pctx, info,
2384	sizeof(info) - 1), 0)
2385	\|\| !TEST_int_gt(EVP_PKEY_derive(pctx, out, &outlen), 0)
2386	\|\| !TEST_mem_eq(out, outlen, expected, expectedlen))
2387	goto done;
2388	}
2389
2390	ret = 1;
2391
2392	done:
2393	EVP_PKEY_CTX_free(pctx);
2394
2395	return ret;
2396	}
2397
2398	static int test_emptyikm_HKDF(void)
2399	{
2400	EVP_PKEY_CTX *pctx;
2401	unsigned char out[20];
2402	size_t outlen;
2403	int ret = 0;
2404	unsigned char salt[] = "9876543210";
2405	unsigned char key[] = "";
2406	unsigned char info[] = "stringinfo";
2407	const unsigned char expected[] = {
2408	0x68, 0x81, 0xa5, 0x3e, 0x5b, 0x9c, 0x7b, 0x6f, 0x2e, 0xec, 0xc8, 0x47,
2409	0x7c, 0xfa, 0x47, 0x35, 0x66, 0x82, 0x15, 0x30
2410	};
2411	size_t expectedlen = sizeof(expected);
2412
2413	if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_from_name(testctx, "HKDF", testpropq)))
2414	goto done;
2415
2416	outlen = sizeof(out);
2417	memset(out, 0, outlen);
2418
2419	if (!TEST_int_gt(EVP_PKEY_derive_init(pctx), 0)
2420	\|\| !TEST_int_gt(EVP_PKEY_CTX_set_hkdf_md(pctx, EVP_sha256()), 0)
2421	\|\| !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_salt(pctx, salt,
2422	sizeof(salt) - 1), 0)
2423	\|\| !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_key(pctx, key,
2424	sizeof(key) - 1), 0)
2425	\|\| !TEST_int_gt(EVP_PKEY_CTX_add1_hkdf_info(pctx, info,
2426	sizeof(info) - 1), 0)
2427	\|\| !TEST_int_gt(EVP_PKEY_derive(pctx, out, &outlen), 0)
2428	\|\| !TEST_mem_eq(out, outlen, expected, expectedlen))
2429	goto done;
2430
2431	ret = 1;
2432
2433	done:
2434	EVP_PKEY_CTX_free(pctx);
2435
2436	return ret;
2437	}
2438
2439	#ifndef OPENSSL_NO_EC
2440	static int test_X509_PUBKEY_inplace(void)
2441	{
2442	int ret = 0;
2443	X509_PUBKEY *xp = X509_PUBKEY_new_ex(testctx, testpropq);
2444	const unsigned char *p = kExampleECPubKeyDER;
2445	size_t input_len = sizeof(kExampleECPubKeyDER);
2446
2447	if (!TEST_ptr(xp))
2448	goto done;
2449	if (!TEST_ptr(d2i_X509_PUBKEY(&xp, &p, input_len)))
2450	goto done;
2451
2452	if (!TEST_ptr(X509_PUBKEY_get0(xp)))
2453	goto done;
2454
2455	p = kExampleBadECPubKeyDER;
2456	input_len = sizeof(kExampleBadECPubKeyDER);
2457
2458	if (!TEST_ptr(xp = d2i_X509_PUBKEY(&xp, &p, input_len)))
2459	goto done;
2460
2461	if (!TEST_true(X509_PUBKEY_get0(xp) == NULL))
2462	goto done;
2463
2464	ret = 1;
2465
2466	done:
2467	X509_PUBKEY_free(xp);
2468	return ret;
2469	}
2470
2471	static int test_X509_PUBKEY_dup(void)
2472	{
2473	int ret = 0;
2474	X509_PUBKEY xp = NULL, xq = NULL;
2475	const unsigned char *p = kExampleECPubKeyDER;
2476	size_t input_len = sizeof(kExampleECPubKeyDER);
2477
2478	xp = X509_PUBKEY_new_ex(testctx, testpropq);
2479	if (!TEST_ptr(xp)
2480	\|\| !TEST_ptr(d2i_X509_PUBKEY(&xp, &p, input_len))
2481	\|\| !TEST_ptr(xq = X509_PUBKEY_dup(xp))
2482	\|\| !TEST_ptr_ne(xp, xq))
2483	goto done;
2484
2485	if (!TEST_ptr(X509_PUBKEY_get0(xq))
2486	\|\| !TEST_ptr(X509_PUBKEY_get0(xp))
2487	\|\| !TEST_ptr_ne(X509_PUBKEY_get0(xq), X509_PUBKEY_get0(xp)))
2488	goto done;
2489
2490	X509_PUBKEY_free(xq);
2491	xq = NULL;
2492	p = kExampleBadECPubKeyDER;
2493	input_len = sizeof(kExampleBadECPubKeyDER);
2494
2495	if (!TEST_ptr(xp = d2i_X509_PUBKEY(&xp, &p, input_len))
2496	\|\| !TEST_ptr(xq = X509_PUBKEY_dup(xp)))
2497	goto done;
2498
2499	X509_PUBKEY_free(xp);
2500	xp = NULL;
2501	if (!TEST_true(X509_PUBKEY_get0(xq) == NULL))
2502	goto done;
2503
2504	ret = 1;
2505
2506	done:
2507	X509_PUBKEY_free(xp);
2508	X509_PUBKEY_free(xq);
2509	return ret;
2510	}
2511	#endif /* OPENSSL_NO_EC */
2512
2513	/* Test getting and setting parameters on an EVP_PKEY_CTX */
2514	static int test_EVP_PKEY_CTX_get_set_params(EVP_PKEY *pkey)
2515	{
2516	EVP_MD_CTX *mdctx = NULL;
2517	EVP_PKEY_CTX *ctx = NULL;
2518	const OSSL_PARAM *params;
2519	OSSL_PARAM ourparams[2], param = ourparams, param_md;
2520	int ret = 0;
2521	const EVP_MD *md;
2522	char mdname[OSSL_MAX_NAME_SIZE];
2523	char ssl3ms[48];
2524
2525	/* Initialise a sign operation */
2526	ctx = EVP_PKEY_CTX_new_from_pkey(testctx, pkey, testpropq);
2527	if (!TEST_ptr(ctx)
2528	\|\| !TEST_int_gt(EVP_PKEY_sign_init(ctx), 0))
2529	goto err;
2530
2531	/*
2532	* We should be able to query the parameters now.
2533	*/
2534	params = EVP_PKEY_CTX_settable_params(ctx);
2535	if (!TEST_ptr(params)
2536	\|\| !TEST_ptr(OSSL_PARAM_locate_const(params,
2537	OSSL_SIGNATURE_PARAM_DIGEST)))
2538	goto err;
2539
2540	params = EVP_PKEY_CTX_gettable_params(ctx);
2541	if (!TEST_ptr(params)
2542	\|\| !TEST_ptr(OSSL_PARAM_locate_const(params,
2543	OSSL_SIGNATURE_PARAM_ALGORITHM_ID))
2544	\|\| !TEST_ptr(OSSL_PARAM_locate_const(params,
2545	OSSL_SIGNATURE_PARAM_DIGEST)))
2546	goto err;
2547
2548	/*
2549	* Test getting and setting params via EVP_PKEY_CTX_set_params() and
2550	* EVP_PKEY_CTX_get_params()
2551	*/
2552	strcpy(mdname, "SHA512");
2553	param_md = param;
2554	*param++ = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
2555	mdname, 0);
2556	*param++ = OSSL_PARAM_construct_end();
2557
2558	if (!TEST_true(EVP_PKEY_CTX_set_params(ctx, ourparams)))
2559	goto err;
2560
2561	mdname[0] = '\0';
2562	*param_md = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
2563	mdname, sizeof(mdname));
2564	if (!TEST_true(EVP_PKEY_CTX_get_params(ctx, ourparams))
2565	\|\| !TEST_str_eq(mdname, "SHA512"))
2566	goto err;
2567
2568	/*
2569	* Test the TEST_PKEY_CTX_set_signature_md() and
2570	* TEST_PKEY_CTX_get_signature_md() functions
2571	*/
2572	if (!TEST_int_gt(EVP_PKEY_CTX_set_signature_md(ctx, EVP_sha256()), 0)
2573	\|\| !TEST_int_gt(EVP_PKEY_CTX_get_signature_md(ctx, &md), 0)
2574	\|\| !TEST_ptr_eq(md, EVP_sha256()))
2575	goto err;
2576
2577	/*
2578	* Test getting MD parameters via an associated EVP_PKEY_CTX
2579	*/
2580	mdctx = EVP_MD_CTX_new();
2581	if (!TEST_ptr(mdctx)
2582	\|\| !TEST_true(EVP_DigestSignInit_ex(mdctx, NULL, "SHA1", testctx, testpropq,
2583	pkey, NULL)))
2584	goto err;
2585
2586	/*
2587	* We now have an EVP_MD_CTX with an EVP_PKEY_CTX inside it. We should be
2588	* able to obtain the digest's settable parameters from the provider.
2589	*/
2590	params = EVP_MD_CTX_settable_params(mdctx);
2591	if (!TEST_ptr(params)
2592	\|\| !TEST_int_eq(strcmp(params[0].key, OSSL_DIGEST_PARAM_SSL3_MS), 0)
2593	/* The final key should be NULL */
2594	\|\| !TEST_ptr_null(params[1].key))
2595	goto err;
2596
2597	param = ourparams;
2598	memset(ssl3ms, 0, sizeof(ssl3ms));
2599	*param++ = OSSL_PARAM_construct_octet_string(OSSL_DIGEST_PARAM_SSL3_MS,
2600	ssl3ms, sizeof(ssl3ms));
2601	*param++ = OSSL_PARAM_construct_end();
2602
2603	if (!TEST_true(EVP_MD_CTX_set_params(mdctx, ourparams)))
2604	goto err;
2605
2606	ret = 1;
2607
2608	err:
2609	EVP_MD_CTX_free(mdctx);
2610	EVP_PKEY_CTX_free(ctx);
2611
2612	return ret;
2613	}
2614
2615	#ifndef OPENSSL_NO_DSA
2616	static int test_DSA_get_set_params(void)
2617	{
2618	OSSL_PARAM_BLD *bld = NULL;
2619	OSSL_PARAM *params = NULL;
2620	BIGNUM p = NULL, q = NULL, g = NULL, pub = NULL, *priv = NULL;
2621	EVP_PKEY_CTX *pctx = NULL;
2622	EVP_PKEY *pkey = NULL;
2623	int ret = 0;
2624
2625	/*
2626	* Setup the parameters for our DSA object. For our purposes they don't
2627	* have to actually be valid parameters. We just need to set something.
2628	*/
2629	if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_from_name(testctx, "DSA", NULL))
2630	\|\| !TEST_ptr(bld = OSSL_PARAM_BLD_new())
2631	\|\| !TEST_ptr(p = BN_new())
2632	\|\| !TEST_ptr(q = BN_new())
2633	\|\| !TEST_ptr(g = BN_new())
2634	\|\| !TEST_ptr(pub = BN_new())
2635	\|\| !TEST_ptr(priv = BN_new()))
2636	goto err;
2637	if (!TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_P, p))
2638	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_Q, q))
2639	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_G, g))
2640	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PUB_KEY,
2641	pub))
2642	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY,
2643	priv)))
2644	goto err;
2645	if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld)))
2646	goto err;
2647
2648	if (!TEST_int_gt(EVP_PKEY_fromdata_init(pctx), 0)
2649	\|\| !TEST_int_gt(EVP_PKEY_fromdata(pctx, &pkey, EVP_PKEY_KEYPAIR,
2650	params), 0))
2651	goto err;
2652
2653	if (!TEST_ptr(pkey))
2654	goto err;
2655
2656	ret = test_EVP_PKEY_CTX_get_set_params(pkey);
2657
2658	err:
2659	EVP_PKEY_free(pkey);
2660	EVP_PKEY_CTX_free(pctx);
2661	OSSL_PARAM_free(params);
2662	OSSL_PARAM_BLD_free(bld);
2663	BN_free(p);
2664	BN_free(q);
2665	BN_free(g);
2666	BN_free(pub);
2667	BN_free(priv);
2668
2669	return ret;
2670	}
2671
2672	/*
2673	* Test combinations of private, public, missing and private + public key
2674	* params to ensure they are all accepted
2675	*/
2676	static int test_DSA_priv_pub(void)
2677	{
2678	return test_EVP_PKEY_ffc_priv_pub("DSA");
2679	}
2680
2681	#endif /* !OPENSSL_NO_DSA */
2682
2683	static int test_RSA_get_set_params(void)
2684	{
2685	OSSL_PARAM_BLD *bld = NULL;
2686	OSSL_PARAM *params = NULL;
2687	BIGNUM n = NULL, e = NULL, *d = NULL;
2688	EVP_PKEY_CTX *pctx = NULL;
2689	EVP_PKEY *pkey = NULL;
2690	int ret = 0;
2691
2692	/*
2693	* Setup the parameters for our RSA object. For our purposes they don't
2694	* have to actually be valid parameters. We just need to set something.
2695	*/
2696	if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_from_name(testctx, "RSA", NULL))
2697	\|\| !TEST_ptr(bld = OSSL_PARAM_BLD_new())
2698	\|\| !TEST_ptr(n = BN_new())
2699	\|\| !TEST_ptr(e = BN_new())
2700	\|\| !TEST_ptr(d = BN_new()))
2701	goto err;
2702	if (!TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, n))
2703	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E, e))
2704	\|\| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_D, d)))
2705	goto err;
2706	if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld)))
2707	goto err;
2708
2709	if (!TEST_int_gt(EVP_PKEY_fromdata_init(pctx), 0)
2710	\|\| !TEST_int_gt(EVP_PKEY_fromdata(pctx, &pkey, EVP_PKEY_KEYPAIR,
2711	params), 0))
2712	goto err;
2713
2714	if (!TEST_ptr(pkey))
2715	goto err;
2716
2717	ret = test_EVP_PKEY_CTX_get_set_params(pkey);
2718
2719	err:
2720	EVP_PKEY_free(pkey);
2721	EVP_PKEY_CTX_free(pctx);
2722	OSSL_PARAM_free(params);
2723	OSSL_PARAM_BLD_free(bld);
2724	BN_free(n);
2725	BN_free(e);
2726	BN_free(d);
2727
2728	return ret;
2729	}
2730
2731	#if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
2732	static int test_decrypt_null_chunks(void)
2733	{
2734	EVP_CIPHER_CTX* ctx = NULL;
2735	EVP_CIPHER *cipher = NULL;
2736	const unsigned char key[32] = {
2737	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
2738	0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
2739	0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1
2740	};
2741	unsigned char iv[12] = {
2742	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b
2743	};
2744	unsigned char msg[] = "It was the best of times, it was the worst of times";
2745	unsigned char ciphertext[80];
2746	unsigned char plaintext[80];
2747	/* We initialise tmp to a non zero value on purpose */
2748	int ctlen, ptlen, tmp = 99;
2749	int ret = 0;
2750	const int enc_offset = 10, dec_offset = 20;
2751
2752	if (!TEST_ptr(cipher = EVP_CIPHER_fetch(testctx, "ChaCha20-Poly1305", testpropq))
2753	\|\| !TEST_ptr(ctx = EVP_CIPHER_CTX_new())
2754	\|\| !TEST_true(EVP_EncryptInit_ex(ctx, cipher, NULL,
2755	key, iv))
2756	\|\| !TEST_true(EVP_EncryptUpdate(ctx, ciphertext, &ctlen, msg,
2757	enc_offset))
2758	/* Deliberate add a zero length update */
2759	\|\| !TEST_true(EVP_EncryptUpdate(ctx, ciphertext + ctlen, &tmp, NULL,
2760	0))
2761	\|\| !TEST_int_eq(tmp, 0)
2762	\|\| !TEST_true(EVP_EncryptUpdate(ctx, ciphertext + ctlen, &tmp,
2763	msg + enc_offset,
2764	sizeof(msg) - enc_offset))
2765	\|\| !TEST_int_eq(ctlen += tmp, sizeof(msg))
2766	\|\| !TEST_true(EVP_EncryptFinal(ctx, ciphertext + ctlen, &tmp))
2767	\|\| !TEST_int_eq(tmp, 0))
2768	goto err;
2769
2770	/* Deliberately initialise tmp to a non zero value */
2771	tmp = 99;
2772	if (!TEST_true(EVP_DecryptInit_ex(ctx, cipher, NULL, key, iv))
2773	\|\| !TEST_true(EVP_DecryptUpdate(ctx, plaintext, &ptlen, ciphertext,
2774	dec_offset))
2775	/*
2776	* Deliberately add a zero length update. We also deliberately do
2777	* this at a different offset than for encryption.
2778	*/
2779	\|\| !TEST_true(EVP_DecryptUpdate(ctx, plaintext + ptlen, &tmp, NULL,
2780	0))
2781	\|\| !TEST_int_eq(tmp, 0)
2782	\|\| !TEST_true(EVP_DecryptUpdate(ctx, plaintext + ptlen, &tmp,
2783	ciphertext + dec_offset,
2784	ctlen - dec_offset))
2785	\|\| !TEST_int_eq(ptlen += tmp, sizeof(msg))
2786	\|\| !TEST_true(EVP_DecryptFinal(ctx, plaintext + ptlen, &tmp))
2787	\|\| !TEST_int_eq(tmp, 0)
2788	\|\| !TEST_mem_eq(msg, sizeof(msg), plaintext, ptlen))
2789	goto err;
2790
2791	ret = 1;
2792	err:
2793	EVP_CIPHER_CTX_free(ctx);
2794	EVP_CIPHER_free(cipher);
2795	return ret;
2796	}
2797	#endif /* !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305) */
2798
2799	#ifndef OPENSSL_NO_DH
2800	/*
2801	* Test combinations of private, public, missing and private + public key
2802	* params to ensure they are all accepted
2803	*/
2804	static int test_DH_priv_pub(void)
2805	{
2806	return test_EVP_PKEY_ffc_priv_pub("DH");
2807	}
2808
2809	# ifndef OPENSSL_NO_DEPRECATED_3_0
2810	static int test_EVP_PKEY_set1_DH(void)
2811	{
2812	DH x942dh = NULL, noqdh = NULL;
2813	EVP_PKEY pkey1 = NULL, pkey2 = NULL;
2814	int ret = 0;
2815	BIGNUM p, g = NULL;
2816	BIGNUM *pubkey = NULL;
2817	unsigned char pub[2048 / 8];
2818	size_t len = 0;
2819
2820	if (!TEST_ptr(p = BN_new())
2821	\|\| !TEST_ptr(g = BN_new())
2822	\|\| !TEST_ptr(pubkey = BN_new())
2823	\|\| !TEST_true(BN_set_word(p, 9999))
2824	\|\| !TEST_true(BN_set_word(g, 2))
2825	\|\| !TEST_true(BN_set_word(pubkey, 4321))
2826	\|\| !TEST_ptr(noqdh = DH_new())
2827	\|\| !TEST_true(DH_set0_pqg(noqdh, p, NULL, g))
2828	\|\| !TEST_true(DH_set0_key(noqdh, pubkey, NULL))
2829	\|\| !TEST_ptr(pubkey = BN_new())
2830	\|\| !TEST_true(BN_set_word(pubkey, 4321)))
2831	goto err;
2832	p = g = NULL;
2833
2834	x942dh = DH_get_2048_256();
2835	pkey1 = EVP_PKEY_new();
2836	pkey2 = EVP_PKEY_new();
2837	if (!TEST_ptr(x942dh)
2838	\|\| !TEST_ptr(noqdh)
2839	\|\| !TEST_ptr(pkey1)
2840	\|\| !TEST_ptr(pkey2)
2841	\|\| !TEST_true(DH_set0_key(x942dh, pubkey, NULL)))
2842	goto err;
2843	pubkey = NULL;
2844
2845	if (!TEST_true(EVP_PKEY_set1_DH(pkey1, x942dh))
2846	\|\| !TEST_int_eq(EVP_PKEY_get_id(pkey1), EVP_PKEY_DHX))
2847	goto err;
2848
2849	if (!TEST_true(EVP_PKEY_get_bn_param(pkey1, OSSL_PKEY_PARAM_PUB_KEY,
2850	&pubkey))
2851	\|\| !TEST_ptr(pubkey))
2852	goto err;
2853
2854	if (!TEST_true(EVP_PKEY_set1_DH(pkey2, noqdh))
2855	\|\| !TEST_int_eq(EVP_PKEY_get_id(pkey2), EVP_PKEY_DH))
2856	goto err;
2857
2858	if (!TEST_true(EVP_PKEY_get_octet_string_param(pkey2,
2859	OSSL_PKEY_PARAM_PUB_KEY,
2860	pub, sizeof(pub), &len))
2861	\|\| !TEST_size_t_ne(len, 0))
2862	goto err;
2863
2864	ret = 1;
2865	err:
2866	BN_free(p);
2867	BN_free(g);
2868	BN_free(pubkey);
2869	EVP_PKEY_free(pkey1);
2870	EVP_PKEY_free(pkey2);
2871	DH_free(x942dh);
2872	DH_free(noqdh);
2873
2874	return ret;
2875	}
2876	# endif /* !OPENSSL_NO_DEPRECATED_3_0 */
2877	#endif /* !OPENSSL_NO_DH */
2878
2879	/*
2880	* We test what happens with an empty template. For the sake of this test,
2881	* the template must be ignored, and we know that's the case for RSA keys
2882	* (this might arguably be a misfeature, but that's what we currently do,
2883	* even in provider code, since that's how the legacy RSA implementation
2884	* does things)
2885	*/
2886	static int test_keygen_with_empty_template(int n)
2887	{
2888	EVP_PKEY_CTX *ctx = NULL;
2889	EVP_PKEY *pkey = NULL;
2890	EVP_PKEY *tkey = NULL;
2891	int ret = 0;
2892
2893	if (nullprov != NULL)
2894	return TEST_skip("Test does not support a non-default library context");
2895
2896	switch (n) {
2897	case 0:
2898	/* We do test with no template at all as well */
2899	if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL)))
2900	goto err;
2901	break;
2902	case 1:
2903	/* Here we create an empty RSA key that serves as our template */
2904	if (!TEST_ptr(tkey = EVP_PKEY_new())
2905	\|\| !TEST_true(EVP_PKEY_set_type(tkey, EVP_PKEY_RSA))
2906	\|\| !TEST_ptr(ctx = EVP_PKEY_CTX_new(tkey, NULL)))
2907	goto err;
2908	break;
2909	}
2910
2911	if (!TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
2912	\|\| !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0))
2913	goto err;
2914
2915	ret = 1;
2916	err:
2917	EVP_PKEY_CTX_free(ctx);
2918	EVP_PKEY_free(pkey);
2919	EVP_PKEY_free(tkey);
2920	return ret;
2921	}
2922
2923	/*
2924	* Test that we fail if we attempt to use an algorithm that is not available
2925	* in the current library context (unless we are using an algorithm that
2926	* should be made available via legacy codepaths).
2927	*
2928	* 0: RSA
2929	* 1: SM2
2930	*/
2931	static int test_pkey_ctx_fail_without_provider(int tst)
2932	{
2933	OSSL_LIB_CTX *tmpctx = OSSL_LIB_CTX_new();
2934	OSSL_PROVIDER *tmpnullprov = NULL;
2935	EVP_PKEY_CTX *pctx = NULL;
2936	const char *keytype = NULL;
2937	int expect_null = 0;
2938	int ret = 0;
2939
2940	if (!TEST_ptr(tmpctx))
2941	goto err;
2942
2943	tmpnullprov = OSSL_PROVIDER_load(tmpctx, "null");
2944	if (!TEST_ptr(tmpnullprov))
2945	goto err;
2946
2947	/*
2948	* We check for certain algos in the null provider.
2949	* If an algo is expected to have a provider keymgmt, contructing an
2950	* EVP_PKEY_CTX is expected to fail (return NULL).
2951	* Otherwise, if it's expected to have legacy support, contructing an
2952	* EVP_PKEY_CTX is expected to succeed (return non-NULL).
2953	*/
2954	switch (tst) {
2955	case 0:
2956	keytype = "RSA";
2957	expect_null = 1;
2958	break;
2959	case 1:
2960	keytype = "SM2";
2961	expect_null = 1;
2962	#ifdef OPENSSL_NO_EC
2963	TEST_info("EC disable, skipping SM2 check...");
2964	goto end;
2965	#endif
2966	#ifdef OPENSSL_NO_SM2
2967	TEST_info("SM2 disable, skipping SM2 check...");
2968	goto end;
2969	#endif
2970	break;
2971	default:
2972	TEST_error("No test for case %d", tst);
2973	goto err;
2974	}
2975
2976	pctx = EVP_PKEY_CTX_new_from_name(tmpctx, keytype, "");
2977	if (expect_null ? !TEST_ptr_null(pctx) : !TEST_ptr(pctx))
2978	goto err;
2979
2980	#if defined(OPENSSL_NO_EC) \|\| defined(OPENSSL_NO_SM2)
2981	end:
2982	#endif
2983	ret = 1;
2984
2985	err:
2986	EVP_PKEY_CTX_free(pctx);
2987	OSSL_PROVIDER_unload(tmpnullprov);
2988	OSSL_LIB_CTX_free(tmpctx);
2989	return ret;
2990	}
2991
2992	static int test_rand_agglomeration(void)
2993	{
2994	EVP_RAND *rand;
2995	EVP_RAND_CTX *ctx;
2996	OSSL_PARAM params[3], *p = params;
2997	int res;
2998	unsigned int step = 7;
2999	static unsigned char seed[] = "It does not matter how slowly you go "
3000	"as long as you do not stop.";
3001	unsigned char out[sizeof(seed)];
3002
3003	if (!TEST_int_ne(sizeof(seed) % step, 0)
3004	\|\| !TEST_ptr(rand = EVP_RAND_fetch(testctx, "TEST-RAND", testpropq)))
3005	return 0;
3006	ctx = EVP_RAND_CTX_new(rand, NULL);
3007	EVP_RAND_free(rand);
3008	if (!TEST_ptr(ctx))
3009	return 0;
3010
3011	memset(out, 0, sizeof(out));
3012	*p++ = OSSL_PARAM_construct_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY,
3013	seed, sizeof(seed));
3014	*p++ = OSSL_PARAM_construct_uint(OSSL_RAND_PARAM_MAX_REQUEST, &step);
3015	*p = OSSL_PARAM_construct_end();
3016	res = TEST_true(EVP_RAND_CTX_set_params(ctx, params))
3017	&& TEST_true(EVP_RAND_generate(ctx, out, sizeof(out), 0, 1, NULL, 0))
3018	&& TEST_mem_eq(seed, sizeof(seed), out, sizeof(out));
3019	EVP_RAND_CTX_free(ctx);
3020	return res;
3021	}
3022
3023	/*
3024	* Test that we correctly return the original or "running" IV after
3025	* an encryption operation.
3026	* Run multiple times for some different relevant algorithms/modes.
3027	*/
3028	static int test_evp_iv_aes(int idx)
3029	{
3030	int ret = 0;
3031	EVP_CIPHER_CTX *ctx = NULL;
3032	unsigned char key[16] = {0x4c, 0x43, 0xdb, 0xdd, 0x42, 0x73, 0x47, 0xd1,
3033	0xe5, 0x62, 0x7d, 0xcd, 0x4d, 0x76, 0x4d, 0x57};
3034	unsigned char init_iv[EVP_MAX_IV_LENGTH] =
3035	{0x57, 0x71, 0x7d, 0xad, 0xdb, 0x9b, 0x98, 0x82,
3036	0x5a, 0x55, 0x91, 0x81, 0x42, 0xa8, 0x89, 0x34};
3037	static const unsigned char msg[] = { 1, 2, 3, 4, 5, 6, 7, 8,
3038	9, 10, 11, 12, 13, 14, 15, 16 };
3039	unsigned char ciphertext[32], oiv[16], iv[16];
3040	unsigned char *ref_iv;
3041	unsigned char cbc_state[16] = {0x10, 0x2f, 0x05, 0xcc, 0xc2, 0x55, 0x72, 0xb9,
3042	0x88, 0xe6, 0x4a, 0x17, 0x10, 0x74, 0x22, 0x5e};
3043
3044	unsigned char ofb_state[16] = {0x76, 0xe6, 0x66, 0x61, 0xd0, 0x8a, 0xe4, 0x64,
3045	0xdd, 0x66, 0xbf, 0x00, 0xf0, 0xe3, 0x6f, 0xfd};
3046	unsigned char cfb_state[16] = {0x77, 0xe4, 0x65, 0x65, 0xd5, 0x8c, 0xe3, 0x6c,
3047	0xd4, 0x6c, 0xb4, 0x0c, 0xfd, 0xed, 0x60, 0xed};
3048	unsigned char gcm_state[12] = {0x57, 0x71, 0x7d, 0xad, 0xdb, 0x9b,
3049	0x98, 0x82, 0x5a, 0x55, 0x91, 0x81};
3050	unsigned char ccm_state[7] = {0x57, 0x71, 0x7d, 0xad, 0xdb, 0x9b, 0x98};
3051	#ifndef OPENSSL_NO_OCB
3052	unsigned char ocb_state[12] = {0x57, 0x71, 0x7d, 0xad, 0xdb, 0x9b,
3053	0x98, 0x82, 0x5a, 0x55, 0x91, 0x81};
3054	#endif
3055	int len = sizeof(ciphertext);
3056	size_t ivlen, ref_len;
3057	const EVP_CIPHER *type = NULL;
3058	int iv_reset = 0;
3059
3060	if (nullprov != NULL && idx < 6)
3061	return TEST_skip("Test does not support a non-default library context");
3062
3063	switch(idx) {
3064	case 0:
3065	type = EVP_aes_128_cbc();
3066	/* FALLTHROUGH */
3067	case 6:
3068	type = (type != NULL) ? type :
3069	EVP_CIPHER_fetch(testctx, "aes-128-cbc", testpropq);
3070	ref_iv = cbc_state;
3071	ref_len = sizeof(cbc_state);
3072	iv_reset = 1;
3073	break;
3074	case 1:
3075	type = EVP_aes_128_ofb();
3076	/* FALLTHROUGH */
3077	case 7:
3078	type = (type != NULL) ? type :
3079	EVP_CIPHER_fetch(testctx, "aes-128-ofb", testpropq);
3080	ref_iv = ofb_state;
3081	ref_len = sizeof(ofb_state);
3082	iv_reset = 1;
3083	break;
3084	case 2:
3085	type = EVP_aes_128_cfb();
3086	/* FALLTHROUGH */
3087	case 8:
3088	type = (type != NULL) ? type :
3089	EVP_CIPHER_fetch(testctx, "aes-128-cfb", testpropq);
3090	ref_iv = cfb_state;
3091	ref_len = sizeof(cfb_state);
3092	iv_reset = 1;
3093	break;
3094	case 3:
3095	type = EVP_aes_128_gcm();
3096	/* FALLTHROUGH */
3097	case 9:
3098	type = (type != NULL) ? type :
3099	EVP_CIPHER_fetch(testctx, "aes-128-gcm", testpropq);
3100	ref_iv = gcm_state;
3101	ref_len = sizeof(gcm_state);
3102	break;
3103	case 4:
3104	type = EVP_aes_128_ccm();
3105	/* FALLTHROUGH */
3106	case 10:
3107	type = (type != NULL) ? type :
3108	EVP_CIPHER_fetch(testctx, "aes-128-ccm", testpropq);
3109	ref_iv = ccm_state;
3110	ref_len = sizeof(ccm_state);
3111	break;
3112	#ifdef OPENSSL_NO_OCB
3113	case 5:
3114	case 11:
3115	return 1;
3116	#else
3117	case 5:
3118	type = EVP_aes_128_ocb();
3119	/* FALLTHROUGH */
3120	case 11:
3121	type = (type != NULL) ? type :
3122	EVP_CIPHER_fetch(testctx, "aes-128-ocb", testpropq);
3123	ref_iv = ocb_state;
3124	ref_len = sizeof(ocb_state);
3125	break;
3126	#endif
3127	default:
3128	return 0;
3129	}
3130
3131	if (!TEST_ptr(type)
3132	\|\| !TEST_ptr((ctx = EVP_CIPHER_CTX_new()))
3133	\|\| !TEST_true(EVP_EncryptInit_ex(ctx, type, NULL, key, init_iv))
3134	\|\| !TEST_true(EVP_EncryptUpdate(ctx, ciphertext, &len, msg,
3135	(int)sizeof(msg)))
3136	\|\| !TEST_true(EVP_CIPHER_CTX_get_original_iv(ctx, oiv, sizeof(oiv)))
3137	\|\| !TEST_true(EVP_CIPHER_CTX_get_updated_iv(ctx, iv, sizeof(iv)))
3138	\|\| !TEST_true(EVP_EncryptFinal_ex(ctx, ciphertext, &len)))
3139	goto err;
3140	ivlen = EVP_CIPHER_CTX_get_iv_length(ctx);
3141	if (!TEST_mem_eq(init_iv, ivlen, oiv, ivlen)
3142	\|\| !TEST_mem_eq(ref_iv, ref_len, iv, ivlen))
3143	goto err;
3144
3145	/* CBC, OFB, and CFB modes: the updated iv must be reset after reinit */
3146	if (!TEST_true(EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, NULL))
3147	\|\| !TEST_true(EVP_CIPHER_CTX_get_updated_iv(ctx, iv, sizeof(iv))))
3148	goto err;
3149	if (iv_reset) {
3150	if (!TEST_mem_eq(init_iv, ivlen, iv, ivlen))
3151	goto err;
3152	} else {
3153	if (!TEST_mem_eq(ref_iv, ivlen, iv, ivlen))
3154	goto err;
3155	}
3156
3157	ret = 1;
3158	err:
3159	EVP_CIPHER_CTX_free(ctx);
3160	if (idx >= 6)
3161	EVP_CIPHER_free((EVP_CIPHER *)type);
3162	return ret;
3163	}
3164
3165	#ifndef OPENSSL_NO_DES
3166	static int test_evp_iv_des(int idx)
3167	{
3168	int ret = 0;
3169	EVP_CIPHER_CTX *ctx = NULL;
3170	static const unsigned char key[24] = {
3171	0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
3172	0xf1, 0xe0, 0xd3, 0xc2, 0xb5, 0xa4, 0x97, 0x86,
3173	0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
3174	};
3175	static const unsigned char init_iv[8] = {
3176	0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
3177	};
3178	static const unsigned char msg[] = { 1, 2, 3, 4, 5, 6, 7, 8,
3179	9, 10, 11, 12, 13, 14, 15, 16 };
3180	unsigned char ciphertext[32], oiv[8], iv[8];
3181	unsigned const char *ref_iv;
3182	static const unsigned char cbc_state_des[8] = {
3183	0x4f, 0xa3, 0x85, 0xcd, 0x8b, 0xf3, 0x06, 0x2a
3184	};
3185	static const unsigned char cbc_state_3des[8] = {
3186	0x35, 0x27, 0x7d, 0x65, 0x6c, 0xfb, 0x50, 0xd9
3187	};
3188	static const unsigned char ofb_state_des[8] = {
3189	0xa7, 0x0d, 0x1d, 0x45, 0xf9, 0x96, 0x3f, 0x2c
3190	};
3191	static const unsigned char ofb_state_3des[8] = {
3192	0xab, 0x16, 0x24, 0xbb, 0x5b, 0xac, 0xed, 0x5e
3193	};
3194	static const unsigned char cfb_state_des[8] = {
3195	0x91, 0xeb, 0x6d, 0x29, 0x4b, 0x08, 0xbd, 0x73
3196	};
3197	static const unsigned char cfb_state_3des[8] = {
3198	0x34, 0xdd, 0xfb, 0x47, 0x33, 0x1c, 0x61, 0xf7
3199	};
3200	int len = sizeof(ciphertext);
3201	size_t ivlen, ref_len;
3202	EVP_CIPHER *type = NULL;
3203
3204	if (lgcyprov == NULL && idx < 3)
3205	return TEST_skip("Test requires legacy provider to be loaded");
3206
3207	switch(idx) {
3208	case 0:
3209	type = EVP_CIPHER_fetch(testctx, "des-cbc", testpropq);
3210	ref_iv = cbc_state_des;
3211	ref_len = sizeof(cbc_state_des);
3212	break;
3213	case 1:
3214	type = EVP_CIPHER_fetch(testctx, "des-ofb", testpropq);
3215	ref_iv = ofb_state_des;
3216	ref_len = sizeof(ofb_state_des);
3217	break;
3218	case 2:
3219	type = EVP_CIPHER_fetch(testctx, "des-cfb", testpropq);
3220	ref_iv = cfb_state_des;
3221	ref_len = sizeof(cfb_state_des);
3222	break;
3223	case 3:
3224	type = EVP_CIPHER_fetch(testctx, "des-ede3-cbc", testpropq);
3225	ref_iv = cbc_state_3des;
3226	ref_len = sizeof(cbc_state_3des);
3227	break;
3228	case 4:
3229	type = EVP_CIPHER_fetch(testctx, "des-ede3-ofb", testpropq);
3230	ref_iv = ofb_state_3des;
3231	ref_len = sizeof(ofb_state_3des);
3232	break;
3233	case 5:
3234	type = EVP_CIPHER_fetch(testctx, "des-ede3-cfb", testpropq);
3235	ref_iv = cfb_state_3des;
3236	ref_len = sizeof(cfb_state_3des);
3237	break;
3238	default:
3239	return 0;
3240	}
3241
3242	if (!TEST_ptr(type)
3243	\|\| !TEST_ptr((ctx = EVP_CIPHER_CTX_new()))
3244	\|\| !TEST_true(EVP_EncryptInit_ex(ctx, type, NULL, key, init_iv))
3245	\|\| !TEST_true(EVP_EncryptUpdate(ctx, ciphertext, &len, msg,
3246	(int)sizeof(msg)))
3247	\|\| !TEST_true(EVP_CIPHER_CTX_get_original_iv(ctx, oiv, sizeof(oiv)))
3248	\|\| !TEST_true(EVP_CIPHER_CTX_get_updated_iv(ctx, iv, sizeof(iv)))
3249	\|\| !TEST_true(EVP_EncryptFinal_ex(ctx, ciphertext, &len)))
3250	goto err;
3251	ivlen = EVP_CIPHER_CTX_get_iv_length(ctx);
3252	if (!TEST_mem_eq(init_iv, ivlen, oiv, ivlen)
3253	\|\| !TEST_mem_eq(ref_iv, ref_len, iv, ivlen))
3254	goto err;
3255
3256	if (!TEST_true(EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, NULL))
3257	\|\| !TEST_true(EVP_CIPHER_CTX_get_updated_iv(ctx, iv, sizeof(iv))))
3258	goto err;
3259	if (!TEST_mem_eq(init_iv, ivlen, iv, ivlen))
3260	goto err;
3261
3262	ret = 1;
3263	err:
3264	EVP_CIPHER_CTX_free(ctx);
3265	EVP_CIPHER_free(type);
3266	return ret;
3267	}
3268	#endif
3269
3270	#ifndef OPENSSL_NO_EC
3271	static int ecpub_nids[] = {
3272	NID_brainpoolP256r1, NID_X9_62_prime256v1,
3273	NID_secp384r1, NID_secp521r1,
3274	# ifndef OPENSSL_NO_EC2M
3275	NID_sect233k1, NID_sect233r1, NID_sect283r1,
3276	NID_sect409k1, NID_sect409r1, NID_sect571k1, NID_sect571r1,
3277	# endif
3278	NID_brainpoolP384r1, NID_brainpoolP512r1
3279	};
3280
3281	static int test_ecpub(int idx)
3282	{
3283	int ret = 0, len, savelen;
3284	int nid;
3285	unsigned char buf[1024];
3286	unsigned char *p;
3287	EVP_PKEY *pkey = NULL;
3288	EVP_PKEY_CTX *ctx = NULL;
3289	# ifndef OPENSSL_NO_DEPRECATED_3_0
3290	const unsigned char *q;
3291	EVP_PKEY *pkey2 = NULL;
3292	EC_KEY *ec = NULL;
3293	# endif
3294
3295	if (nullprov != NULL)
3296	return TEST_skip("Test does not support a non-default library context");
3297
3298	nid = ecpub_nids[idx];
3299
3300	ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
3301	if (!TEST_ptr(ctx)
3302	\|\| !TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
3303	\|\| !TEST_true(EVP_PKEY_CTX_set_ec_paramgen_curve_nid(ctx, nid))
3304	\|\| !TEST_true(EVP_PKEY_keygen(ctx, &pkey)))
3305	goto done;
3306	len = i2d_PublicKey(pkey, NULL);
3307	savelen = len;
3308	if (!TEST_int_ge(len, 1)
3309	\|\| !TEST_int_lt(len, 1024))
3310	goto done;
3311	p = buf;
3312	len = i2d_PublicKey(pkey, &p);
3313	if (!TEST_int_ge(len, 1)
3314	\|\| !TEST_int_eq(len, savelen))
3315	goto done;
3316
3317	# ifndef OPENSSL_NO_DEPRECATED_3_0
3318	/* Now try to decode the just-created DER. */
3319	q = buf;
3320	if (!TEST_ptr((pkey2 = EVP_PKEY_new()))
3321	\|\| !TEST_ptr((ec = EC_KEY_new_by_curve_name(nid)))
3322	\|\| !TEST_true(EVP_PKEY_assign_EC_KEY(pkey2, ec)))
3323	goto done;
3324	/* EC_KEY ownership transferred */
3325	ec = NULL;
3326	if (!TEST_ptr(d2i_PublicKey(EVP_PKEY_EC, &pkey2, &q, savelen)))
3327	goto done;
3328	/* The keys should match. */
3329	if (!TEST_int_eq(EVP_PKEY_eq(pkey, pkey2), 1))
3330	goto done;
3331	# endif
3332
3333	ret = 1;
3334
3335	done:
3336	EVP_PKEY_CTX_free(ctx);
3337	EVP_PKEY_free(pkey);
3338	# ifndef OPENSSL_NO_DEPRECATED_3_0
3339	EVP_PKEY_free(pkey2);
3340	EC_KEY_free(ec);
3341	# endif
3342	return ret;
3343	}
3344	#endif
3345
3346	static int test_EVP_rsa_pss_with_keygen_bits(void)
3347	{
3348	int ret = 0;
3349	EVP_PKEY_CTX *ctx = NULL;
3350	EVP_PKEY *pkey = NULL;
3351	EVP_MD *md;
3352
3353	md = EVP_MD_fetch(testctx, "sha256", testpropq);
3354	ret = TEST_ptr(md)
3355	&& TEST_ptr((ctx = EVP_PKEY_CTX_new_from_name(testctx, "RSA", testpropq)))
3356	&& TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
3357	&& TEST_int_gt(EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, 512), 0)
3358	&& TEST_true(EVP_PKEY_CTX_set_rsa_pss_keygen_md(ctx, md))
3359	&& TEST_true(EVP_PKEY_keygen(ctx, &pkey));
3360
3361	EVP_MD_free(md);
3362	EVP_PKEY_free(pkey);
3363	EVP_PKEY_CTX_free(ctx);
3364	return ret;
3365	}
3366
3367	static int test_EVP_rsa_pss_set_saltlen(void)
3368	{
3369	int ret = 0;
3370	EVP_PKEY *pkey = NULL;
3371	EVP_PKEY_CTX *pkey_ctx = NULL;
3372	EVP_MD *sha256 = NULL;
3373	EVP_MD_CTX *sha256_ctx = NULL;
3374	int saltlen = 9999; /* buggy EVP_PKEY_CTX_get_rsa_pss_saltlen() didn't update this */
3375	const int test_value = 32;
3376
3377	ret = TEST_ptr(pkey = load_example_rsa_key())
3378	&& TEST_ptr(sha256 = EVP_MD_fetch(testctx, "sha256", NULL))
3379	&& TEST_ptr(sha256_ctx = EVP_MD_CTX_new())
3380	&& TEST_true(EVP_DigestSignInit(sha256_ctx, &pkey_ctx, sha256, NULL, pkey))
3381	&& TEST_true(EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, RSA_PKCS1_PSS_PADDING))
3382	&& TEST_true(EVP_PKEY_CTX_set_rsa_pss_saltlen(pkey_ctx, test_value))
3383	&& TEST_true(EVP_PKEY_CTX_get_rsa_pss_saltlen(pkey_ctx, &saltlen))
3384	&& TEST_int_eq(saltlen, test_value);
3385
3386	EVP_MD_CTX_free(sha256_ctx);
3387	EVP_PKEY_free(pkey);
3388	EVP_MD_free(sha256);
3389
3390	return ret;
3391	}
3392
3393	static int success = 1;
3394	static void md_names(const char name, void vctx)
3395	{
3396	OSSL_LIB_CTX ctx = (OSSL_LIB_CTX )vctx;
3397	/* Force a namemap update */
3398	EVP_CIPHER *aes128 = EVP_CIPHER_fetch(ctx, "AES-128-CBC", NULL);
3399
3400	if (!TEST_ptr(aes128))
3401	success = 0;
3402
3403	EVP_CIPHER_free(aes128);
3404	}
3405
3406	/*
3407	* Test that changing the namemap in a user callback works in a names_do_all
3408	* function.
3409	*/
3410	static int test_names_do_all(void)
3411	{
3412	/* We use a custom libctx so that we know the state of the namemap */
3413	OSSL_LIB_CTX *ctx = OSSL_LIB_CTX_new();
3414	EVP_MD *sha256 = NULL;
3415	int testresult = 0;
3416
3417	if (!TEST_ptr(ctx))
3418	goto err;
3419
3420	sha256 = EVP_MD_fetch(ctx, "SHA2-256", NULL);
3421	if (!TEST_ptr(sha256))
3422	goto err;
3423
3424	/*
3425	* We loop through all the names for a given digest. This should still work
3426	* even if the namemap changes part way through.
3427	*/
3428	if (!TEST_true(EVP_MD_names_do_all(sha256, md_names, ctx)))
3429	goto err;
3430
3431	if (!TEST_true(success))
3432	goto err;
3433
3434	testresult = 1;
3435	err:
3436	EVP_MD_free(sha256);
3437	OSSL_LIB_CTX_free(ctx);
3438	return testresult;
3439	}
3440
3441	typedef struct {
3442	const char *cipher;
3443	const unsigned char *key;
3444	const unsigned char *iv;
3445	const unsigned char *input;
3446	const unsigned char *expected;
3447	const unsigned char *tag;
3448	size_t ivlen; /* 0 if we do not need to set a specific IV len */
3449	size_t inlen;
3450	size_t expectedlen;
3451	size_t taglen;
3452	int keyfirst;
3453	int initenc;
3454	int finalenc;
3455	} EVP_INIT_TEST_st;
3456
3457	static const EVP_INIT_TEST_st evp_init_tests[] = {
3458	{
3459	"aes-128-cfb", kCFBDefaultKey, iCFBIV, cfbPlaintext,
3460	cfbCiphertext, NULL, 0, sizeof(cfbPlaintext), sizeof(cfbCiphertext),
3461	0, 1, 0, 1
3462	},
3463	{
3464	"aes-256-gcm", kGCMDefaultKey, iGCMDefaultIV, gcmDefaultPlaintext,
3465	gcmDefaultCiphertext, gcmDefaultTag, sizeof(iGCMDefaultIV),
3466	sizeof(gcmDefaultPlaintext), sizeof(gcmDefaultCiphertext),
3467	sizeof(gcmDefaultTag), 1, 0, 1
3468	},
3469	{
3470	"aes-128-cfb", kCFBDefaultKey, iCFBIV, cfbPlaintext,
3471	cfbCiphertext, NULL, 0, sizeof(cfbPlaintext), sizeof(cfbCiphertext),
3472	0, 0, 0, 1
3473	},
3474	{
3475	"aes-256-gcm", kGCMDefaultKey, iGCMDefaultIV, gcmDefaultPlaintext,
3476	gcmDefaultCiphertext, gcmDefaultTag, sizeof(iGCMDefaultIV),
3477	sizeof(gcmDefaultPlaintext), sizeof(gcmDefaultCiphertext),
3478	sizeof(gcmDefaultTag), 0, 0, 1
3479	},
3480	{
3481	"aes-128-cfb", kCFBDefaultKey, iCFBIV, cfbCiphertext,
3482	cfbPlaintext, NULL, 0, sizeof(cfbCiphertext), sizeof(cfbPlaintext),
3483	0, 1, 1, 0
3484	},
3485	{
3486	"aes-256-gcm", kGCMDefaultKey, iGCMDefaultIV, gcmDefaultCiphertext,
3487	gcmDefaultPlaintext, gcmDefaultTag, sizeof(iGCMDefaultIV),
3488	sizeof(gcmDefaultCiphertext), sizeof(gcmDefaultPlaintext),
3489	sizeof(gcmDefaultTag), 1, 1, 0
3490	},
3491	{
3492	"aes-128-cfb", kCFBDefaultKey, iCFBIV, cfbCiphertext,
3493	cfbPlaintext, NULL, 0, sizeof(cfbCiphertext), sizeof(cfbPlaintext),
3494	0, 0, 1, 0
3495	},
3496	{
3497	"aes-256-gcm", kGCMDefaultKey, iGCMDefaultIV, gcmDefaultCiphertext,
3498	gcmDefaultPlaintext, gcmDefaultTag, sizeof(iGCMDefaultIV),
3499	sizeof(gcmDefaultCiphertext), sizeof(gcmDefaultPlaintext),
3500	sizeof(gcmDefaultTag), 0, 1, 0
3501	}
3502	};
3503
3504	static int evp_init_seq_set_iv(EVP_CIPHER_CTX ctx, const EVP_INIT_TEST_st t)
3505	{
3506	int res = 0;
3507
3508	if (t->ivlen != 0) {
3509	if (!TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN, t->ivlen, NULL)))
3510	goto err;
3511	}
3512	if (!TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, NULL, t->iv, -1)))
3513	goto err;
3514	res = 1;
3515	err:
3516	return res;
3517	}
3518
3519	/*
3520	* Test step-wise cipher initialization via EVP_CipherInit_ex where the
3521	* arguments are given one at a time and a final adjustment to the enc
3522	* parameter sets the correct operation.
3523	*/
3524	static int test_evp_init_seq(int idx)
3525	{
3526	int outlen1, outlen2;
3527	int testresult = 0;
3528	unsigned char outbuf[1024];
3529	unsigned char tag[16];
3530	const EVP_INIT_TEST_st *t = &evp_init_tests[idx];
3531	EVP_CIPHER_CTX *ctx = NULL;
3532	EVP_CIPHER *type = NULL;
3533	size_t taglen = sizeof(tag);
3534	char *errmsg = NULL;
3535
3536	ctx = EVP_CIPHER_CTX_new();
3537	if (ctx == NULL) {
3538	errmsg = "CTX_ALLOC";
3539	goto err;
3540	}
3541	if (!TEST_ptr(type = EVP_CIPHER_fetch(testctx, t->cipher, testpropq))) {
3542	errmsg = "CIPHER_FETCH";
3543	goto err;
3544	}
3545	if (!TEST_true(EVP_CipherInit_ex(ctx, type, NULL, NULL, NULL, t->initenc))) {
3546	errmsg = "EMPTY_ENC_INIT";
3547	goto err;
3548	}
3549	if (!TEST_true(EVP_CIPHER_CTX_set_padding(ctx, 0))) {
3550	errmsg = "PADDING";
3551	goto err;
3552	}
3553	if (t->keyfirst && !TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, t->key, NULL, -1))) {
3554	errmsg = "KEY_INIT (before iv)";
3555	goto err;
3556	}
3557	if (!evp_init_seq_set_iv(ctx, t)) {
3558	errmsg = "IV_INIT";
3559	goto err;
3560	}
3561	if (t->keyfirst == 0 && !TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, t->key, NULL, -1))) {
3562	errmsg = "KEY_INIT (after iv)";
3563	goto err;
3564	}
3565	if (!TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, NULL, NULL, t->finalenc))) {
3566	errmsg = "FINAL_ENC_INIT";
3567	goto err;
3568	}
3569	if (!TEST_true(EVP_CipherUpdate(ctx, outbuf, &outlen1, t->input, t->inlen))) {
3570	errmsg = "CIPHER_UPDATE";
3571	goto err;
3572	}
3573	if (t->finalenc == 0 && t->tag != NULL) {
3574	/* Set expected tag */
3575	if (!TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
3576	t->taglen, (void *)t->tag))) {
3577	errmsg = "SET_TAG";
3578	goto err;
3579	}
3580	}
3581	if (!TEST_true(EVP_CipherFinal_ex(ctx, outbuf + outlen1, &outlen2))) {
3582	errmsg = "CIPHER_FINAL";
3583	goto err;
3584	}
3585	if (!TEST_mem_eq(t->expected, t->expectedlen, outbuf, outlen1 + outlen2)) {
3586	errmsg = "WRONG_RESULT";
3587	goto err;
3588	}
3589	if (t->finalenc != 0 && t->tag != NULL) {
3590	if (!TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, taglen, tag))) {
3591	errmsg = "GET_TAG";
3592	goto err;
3593	}
3594	if (!TEST_mem_eq(t->tag, t->taglen, tag, taglen)) {
3595	errmsg = "TAG_ERROR";
3596	goto err;
3597	}
3598	}
3599	testresult = 1;
3600	err:
3601	if (errmsg != NULL)
3602	TEST_info("evp_init_test %d: %s", idx, errmsg);
3603	EVP_CIPHER_CTX_free(ctx);
3604	EVP_CIPHER_free(type);
3605	return testresult;
3606	}
3607
3608	typedef struct {
3609	const unsigned char *input;
3610	const unsigned char *expected;
3611	size_t inlen;
3612	size_t expectedlen;
3613	int enc;
3614	} EVP_RESET_TEST_st;
3615
3616	static const EVP_RESET_TEST_st evp_reset_tests[] = {
3617	{
3618	cfbPlaintext, cfbCiphertext,
3619	sizeof(cfbPlaintext), sizeof(cfbCiphertext), 1
3620	},
3621	{
3622	cfbCiphertext, cfbPlaintext,
3623	sizeof(cfbCiphertext), sizeof(cfbPlaintext), 0
3624	}
3625	};
3626
3627	/*
3628	* Test a reset of a cipher via EVP_CipherInit_ex after the cipher has already
3629	* been used.
3630	*/
3631	static int test_evp_reset(int idx)
3632	{
3633	const EVP_RESET_TEST_st *t = &evp_reset_tests[idx];
3634	int outlen1, outlen2;
3635	int testresult = 0;
3636	unsigned char outbuf[1024];
3637	EVP_CIPHER_CTX *ctx = NULL;
3638	EVP_CIPHER *type = NULL;
3639	char *errmsg = NULL;
3640
3641	if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())) {
3642	errmsg = "CTX_ALLOC";
3643	goto err;
3644	}
3645	if (!TEST_ptr(type = EVP_CIPHER_fetch(testctx, "aes-128-cfb", testpropq))) {
3646	errmsg = "CIPHER_FETCH";
3647	goto err;
3648	}
3649	if (!TEST_true(EVP_CipherInit_ex(ctx, type, NULL, kCFBDefaultKey, iCFBIV, t->enc))) {
3650	errmsg = "CIPHER_INIT";
3651	goto err;
3652	}
3653	if (!TEST_true(EVP_CIPHER_CTX_set_padding(ctx, 0))) {
3654	errmsg = "PADDING";
3655	goto err;
3656	}
3657	if (!TEST_true(EVP_CipherUpdate(ctx, outbuf, &outlen1, t->input, t->inlen))) {
3658	errmsg = "CIPHER_UPDATE";
3659	goto err;
3660	}
3661	if (!TEST_true(EVP_CipherFinal_ex(ctx, outbuf + outlen1, &outlen2))) {
3662	errmsg = "CIPHER_FINAL";
3663	goto err;
3664	}
3665	if (!TEST_mem_eq(t->expected, t->expectedlen, outbuf, outlen1 + outlen2)) {
3666	errmsg = "WRONG_RESULT";
3667	goto err;
3668	}
3669	if (!TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, NULL, NULL, -1))) {
3670	errmsg = "CIPHER_REINIT";
3671	goto err;
3672	}
3673	if (!TEST_true(EVP_CipherUpdate(ctx, outbuf, &outlen1, t->input, t->inlen))) {
3674	errmsg = "CIPHER_UPDATE (reinit)";
3675	goto err;
3676	}
3677	if (!TEST_true(EVP_CipherFinal_ex(ctx, outbuf + outlen1, &outlen2))) {
3678	errmsg = "CIPHER_FINAL (reinit)";
3679	goto err;
3680	}
3681	if (!TEST_mem_eq(t->expected, t->expectedlen, outbuf, outlen1 + outlen2)) {
3682	errmsg = "WRONG_RESULT (reinit)";
3683	goto err;
3684	}
3685	testresult = 1;
3686	err:
3687	if (errmsg != NULL)
3688	TEST_info("test_evp_reset %d: %s", idx, errmsg);
3689	EVP_CIPHER_CTX_free(ctx);
3690	EVP_CIPHER_free(type);
3691	return testresult;
3692	}
3693
3694	typedef struct {
3695	const char *cipher;
3696	int enc;
3697	} EVP_UPDATED_IV_TEST_st;
3698
3699	static const EVP_UPDATED_IV_TEST_st evp_updated_iv_tests[] = {
3700	{
3701	"aes-128-cfb", 1
3702	},
3703	{
3704	"aes-128-cfb", 0
3705	},
3706	{
3707	"aes-128-cfb1", 1
3708	},
3709	{
3710	"aes-128-cfb1", 0
3711	},
3712	{
3713	"aes-128-cfb8", 1
3714	},
3715	{
3716	"aes-128-cfb8", 0
3717	},
3718	{
3719	"aes-128-ofb", 1
3720	},
3721	{
3722	"aes-128-ofb", 0
3723	},
3724	{
3725	"aes-128-ctr", 1
3726	},
3727	{
3728	"aes-128-ctr", 0
3729	},
3730	{
3731	"aes-128-cbc", 1
3732	},
3733	{
3734	"aes-128-cbc", 0
3735	}
3736	};
3737
3738	/*
3739	* Test that the IV in the context is updated during a crypto operation for CFB
3740	* and OFB.
3741	*/
3742	static int test_evp_updated_iv(int idx)
3743	{
3744	const EVP_UPDATED_IV_TEST_st *t = &evp_updated_iv_tests[idx];
3745	int outlen1, outlen2;
3746	int testresult = 0;
3747	unsigned char outbuf[1024];
3748	EVP_CIPHER_CTX *ctx = NULL;
3749	EVP_CIPHER *type = NULL;
3750	unsigned char updated_iv[EVP_MAX_IV_LENGTH];
3751	int iv_len;
3752	char *errmsg = NULL;
3753
3754	if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())) {
3755	errmsg = "CTX_ALLOC";
3756	goto err;
3757	}
3758	if ((type = EVP_CIPHER_fetch(testctx, t->cipher, testpropq)) == NULL) {
3759	TEST_info("cipher %s not supported, skipping", t->cipher);
3760	goto ok;
3761	}
3762
3763	if (!TEST_true(EVP_CipherInit_ex(ctx, type, NULL, kCFBDefaultKey, iCFBIV, t->enc))) {
3764	errmsg = "CIPHER_INIT";
3765	goto err;
3766	}
3767	if (!TEST_true(EVP_CIPHER_CTX_set_padding(ctx, 0))) {
3768	errmsg = "PADDING";
3769	goto err;
3770	}
3771	if (!TEST_true(EVP_CipherUpdate(ctx, outbuf, &outlen1, cfbPlaintext, sizeof(cfbPlaintext)))) {
3772	errmsg = "CIPHER_UPDATE";
3773	goto err;
3774	}
3775	if (!TEST_true(EVP_CIPHER_CTX_get_updated_iv(ctx, updated_iv, sizeof(updated_iv)))) {
3776	errmsg = "CIPHER_CTX_GET_UPDATED_IV";
3777	goto err;
3778	}
3779	if (!TEST_true(iv_len = EVP_CIPHER_CTX_get_iv_length(ctx))) {
3780	errmsg = "CIPHER_CTX_GET_IV_LEN";
3781	goto err;
3782	}
3783	if (!TEST_mem_ne(iCFBIV, sizeof(iCFBIV), updated_iv, iv_len)) {
3784	errmsg = "IV_NOT_UPDATED";
3785	goto err;
3786	}
3787	if (!TEST_true(EVP_CipherFinal_ex(ctx, outbuf + outlen1, &outlen2))) {
3788	errmsg = "CIPHER_FINAL";
3789	goto err;
3790	}
3791	ok:
3792	testresult = 1;
3793	err:
3794	if (errmsg != NULL)
3795	TEST_info("test_evp_updated_iv %d: %s", idx, errmsg);
3796	EVP_CIPHER_CTX_free(ctx);
3797	EVP_CIPHER_free(type);
3798	return testresult;
3799	}
3800
3801	typedef struct {
3802	const unsigned char *iv1;
3803	const unsigned char *iv2;
3804	const unsigned char *expected1;
3805	const unsigned char *expected2;
3806	const unsigned char *tag1;
3807	const unsigned char *tag2;
3808	size_t ivlen1;
3809	size_t ivlen2;
3810	size_t expectedlen1;
3811	size_t expectedlen2;
3812	} TEST_GCM_IV_REINIT_st;
3813
3814	static const TEST_GCM_IV_REINIT_st gcm_reinit_tests[] = {
3815	{
3816	iGCMResetIV1, iGCMResetIV2, gcmResetCiphertext1, gcmResetCiphertext2,
3817	gcmResetTag1, gcmResetTag2, sizeof(iGCMResetIV1), sizeof(iGCMResetIV2),
3818	sizeof(gcmResetCiphertext1), sizeof(gcmResetCiphertext2)
3819	},
3820	{
3821	iGCMResetIV2, iGCMResetIV1, gcmResetCiphertext2, gcmResetCiphertext1,
3822	gcmResetTag2, gcmResetTag1, sizeof(iGCMResetIV2), sizeof(iGCMResetIV1),
3823	sizeof(gcmResetCiphertext2), sizeof(gcmResetCiphertext1)
3824	}
3825	};
3826
3827	static int test_gcm_reinit(int idx)
3828	{
3829	int outlen1, outlen2, outlen3;
3830	int testresult = 0;
3831	unsigned char outbuf[1024];
3832	unsigned char tag[16];
3833	const TEST_GCM_IV_REINIT_st *t = &gcm_reinit_tests[idx];
3834	EVP_CIPHER_CTX *ctx = NULL;
3835	EVP_CIPHER *type = NULL;
3836	size_t taglen = sizeof(tag);
3837	char *errmsg = NULL;
3838
3839	if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())) {
3840	errmsg = "CTX_ALLOC";
3841	goto err;
3842	}
3843	if (!TEST_ptr(type = EVP_CIPHER_fetch(testctx, "aes-256-gcm", testpropq))) {
3844	errmsg = "CIPHER_FETCH";
3845	goto err;
3846	}
3847	if (!TEST_true(EVP_CipherInit_ex(ctx, type, NULL, NULL, NULL, 1))) {
3848	errmsg = "ENC_INIT";
3849	goto err;
3850	}
3851	if (!TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN, t->ivlen1, NULL))) {
3852	errmsg = "SET_IVLEN1";
3853	goto err;
3854	}
3855	if (!TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, kGCMResetKey, t->iv1, 1))) {
3856	errmsg = "SET_IV1";
3857	goto err;
3858	}
3859	if (!TEST_true(EVP_CipherUpdate(ctx, NULL, &outlen3, gcmAAD, sizeof(gcmAAD)))) {
3860	errmsg = "AAD1";
3861	goto err;
3862	}
3863	EVP_CIPHER_CTX_set_padding(ctx, 0);
3864	if (!TEST_true(EVP_CipherUpdate(ctx, outbuf, &outlen1, gcmResetPlaintext,
3865	sizeof(gcmResetPlaintext)))) {
3866	errmsg = "CIPHER_UPDATE1";
3867	goto err;
3868	}
3869	if (!TEST_true(EVP_CipherFinal_ex(ctx, outbuf + outlen1, &outlen2))) {
3870	errmsg = "CIPHER_FINAL1";
3871	goto err;
3872	}
3873	if (!TEST_mem_eq(t->expected1, t->expectedlen1, outbuf, outlen1 + outlen2)) {
3874	errmsg = "WRONG_RESULT1";
3875	goto err;
3876	}
3877	if (!TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, taglen, tag))) {
3878	errmsg = "GET_TAG1";
3879	goto err;
3880	}
3881	if (!TEST_mem_eq(t->tag1, taglen, tag, taglen)) {
3882	errmsg = "TAG_ERROR1";
3883	goto err;
3884	}
3885	/* Now reinit */
3886	if (!TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN, t->ivlen2, NULL))) {
3887	errmsg = "SET_IVLEN2";
3888	goto err;
3889	}
3890	if (!TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, NULL, t->iv2, -1))) {
3891	errmsg = "SET_IV2";
3892	goto err;
3893	}
3894	if (!TEST_true(EVP_CipherUpdate(ctx, NULL, &outlen3, gcmAAD, sizeof(gcmAAD)))) {
3895	errmsg = "AAD2";
3896	goto err;
3897	}
3898	if (!TEST_true(EVP_CipherUpdate(ctx, outbuf, &outlen1, gcmResetPlaintext,
3899	sizeof(gcmResetPlaintext)))) {
3900	errmsg = "CIPHER_UPDATE2";
3901	goto err;
3902	}
3903	if (!TEST_true(EVP_CipherFinal_ex(ctx, outbuf + outlen1, &outlen2))) {
3904	errmsg = "CIPHER_FINAL2";
3905	goto err;
3906	}
3907	if (!TEST_mem_eq(t->expected2, t->expectedlen2, outbuf, outlen1 + outlen2)) {
3908	errmsg = "WRONG_RESULT2";
3909	goto err;
3910	}
3911	if (!TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, taglen, tag))) {
3912	errmsg = "GET_TAG2";
3913	goto err;
3914	}
3915	if (!TEST_mem_eq(t->tag2, taglen, tag, taglen)) {
3916	errmsg = "TAG_ERROR2";
3917	goto err;
3918	}
3919	testresult = 1;
3920	err:
3921	if (errmsg != NULL)
3922	TEST_info("evp_init_test %d: %s", idx, errmsg);
3923	EVP_CIPHER_CTX_free(ctx);
3924	EVP_CIPHER_free(type);
3925	return testresult;
3926	}
3927
3928	#ifndef OPENSSL_NO_DEPRECATED_3_0
3929	static EVP_PKEY_METHOD *custom_pmeth = NULL;
3930	static const EVP_PKEY_METHOD *orig_pmeth = NULL;
3931
3932	# define EVP_PKEY_CTRL_MY_COMMAND 9999
3933
3934	static int custom_pmeth_init(EVP_PKEY_CTX *ctx)
3935	{
3936	int (pinit)(EVP_PKEY_CTX ctx);
3937
3938	EVP_PKEY_meth_get_init(orig_pmeth, &pinit);
3939	return pinit(ctx);
3940	}
3941
3942	static void custom_pmeth_cleanup(EVP_PKEY_CTX *ctx)
3943	{
3944	void (pcleanup)(EVP_PKEY_CTX ctx);
3945
3946	EVP_PKEY_meth_get_cleanup(orig_pmeth, &pcleanup);
3947	pcleanup(ctx);
3948	}
3949
3950	static int custom_pmeth_sign(EVP_PKEY_CTX ctx, unsigned char out,
3951	size_t outlen, const unsigned char in,
3952	size_t inlen)
3953	{
3954	int (psign)(EVP_PKEY_CTX ctx, unsigned char sig, size_t siglen,
3955	const unsigned char *tbs, size_t tbslen);
3956
3957	EVP_PKEY_meth_get_sign(orig_pmeth, NULL, &psign);
3958	return psign(ctx, out, outlen, in, inlen);
3959	}
3960
3961	static int custom_pmeth_digestsign(EVP_MD_CTX ctx, unsigned char sig,
3962	size_t siglen, const unsigned char tbs,
3963	size_t tbslen)
3964	{
3965	int (pdigestsign)(EVP_MD_CTX ctx, unsigned char sig, size_t siglen,
3966	const unsigned char *tbs, size_t tbslen);
3967
3968	EVP_PKEY_meth_get_digestsign(orig_pmeth, &pdigestsign);
3969	return pdigestsign(ctx, sig, siglen, tbs, tbslen);
3970	}
3971
3972	static int custom_pmeth_derive(EVP_PKEY_CTX ctx, unsigned char key,
3973	size_t *keylen)
3974	{
3975	int (pderive)(EVP_PKEY_CTX ctx, unsigned char key, size_t keylen);
3976
3977	EVP_PKEY_meth_get_derive(orig_pmeth, NULL, &pderive);
3978	return pderive(ctx, key, keylen);
3979	}
3980
3981	static int custom_pmeth_copy(EVP_PKEY_CTX dst, const EVP_PKEY_CTX src)
3982	{
3983	int (pcopy)(EVP_PKEY_CTX dst, const EVP_PKEY_CTX *src);
3984
3985	EVP_PKEY_meth_get_copy(orig_pmeth, &pcopy);
3986	return pcopy(dst, src);
3987	}
3988
3989	static int ctrl_called;
3990
3991	static int custom_pmeth_ctrl(EVP_PKEY_CTX ctx, int type, int p1, void p2)
3992	{
3993	int (pctrl)(EVP_PKEY_CTX ctx, int type, int p1, void *p2);
3994
3995	EVP_PKEY_meth_get_ctrl(orig_pmeth, &pctrl, NULL);
3996
3997	if (type == EVP_PKEY_CTRL_MY_COMMAND) {
3998	ctrl_called = 1;
3999	return 1;
4000	}
4001
4002	return pctrl(ctx, type, p1, p2);
4003	}
4004
4005	static int test_custom_pmeth(int idx)
4006	{
4007	EVP_PKEY_CTX *pctx = NULL;
4008	EVP_MD_CTX *ctx = NULL;
4009	EVP_PKEY *pkey = NULL;
4010	int id, orig_id, orig_flags;
4011	int testresult = 0;
4012	size_t reslen;
4013	unsigned char *res = NULL;
4014	unsigned char msg[] = { 'H', 'e', 'l', 'l', 'o' };
4015	const EVP_MD *md = EVP_sha256();
4016	int doderive = 0;
4017
4018	ctrl_called = 0;
4019
4020	/* We call deprecated APIs so this test doesn't support a custom libctx */
4021	if (testctx != NULL)
4022	return 1;
4023
4024	switch(idx) {
4025	case 0:
4026	case 6:
4027	id = EVP_PKEY_RSA;
4028	pkey = load_example_rsa_key();
4029	break;
4030	case 1:
4031	case 7:
4032	# ifndef OPENSSL_NO_DSA
4033	id = EVP_PKEY_DSA;
4034	pkey = load_example_dsa_key();
4035	break;
4036	# else
4037	return 1;
4038	# endif
4039	case 2:
4040	case 8:
4041	# ifndef OPENSSL_NO_EC
4042	id = EVP_PKEY_EC;
4043	pkey = load_example_ec_key();
4044	break;
4045	# else
4046	return 1;
4047	# endif
4048	case 3:
4049	case 9:
4050	# ifndef OPENSSL_NO_EC
4051	id = EVP_PKEY_ED25519;
4052	md = NULL;
4053	pkey = load_example_ed25519_key();
4054	break;
4055	# else
4056	return 1;
4057	# endif
4058	case 4:
4059	case 10:
4060	# ifndef OPENSSL_NO_DH
4061	id = EVP_PKEY_DH;
4062	doderive = 1;
4063	pkey = load_example_dh_key();
4064	break;
4065	# else
4066	return 1;
4067	# endif
4068	case 5:
4069	case 11:
4070	# ifndef OPENSSL_NO_EC
4071	id = EVP_PKEY_X25519;
4072	doderive = 1;
4073	pkey = load_example_x25519_key();
4074	break;
4075	# else
4076	return 1;
4077	# endif
4078	default:
4079	TEST_error("Should not happen");
4080	goto err;
4081	}
4082
4083	if (!TEST_ptr(pkey))
4084	goto err;
4085
4086	if (idx < 6) {
4087	if (!TEST_true(evp_pkey_is_provided(pkey)))
4088	goto err;
4089	} else {
4090	EVP_PKEY *tmp = pkey;
4091
4092	/* Convert to a legacy key */
4093	pkey = EVP_PKEY_new();
4094	if (!TEST_ptr(pkey)) {
4095	pkey = tmp;
4096	goto err;
4097	}
4098	if (!TEST_true(evp_pkey_copy_downgraded(&pkey, tmp))) {
4099	EVP_PKEY_free(tmp);
4100	goto err;
4101	}
4102	EVP_PKEY_free(tmp);
4103	if (!TEST_true(evp_pkey_is_legacy(pkey)))
4104	goto err;
4105	}
4106
4107	if (!TEST_ptr(orig_pmeth = EVP_PKEY_meth_find(id))
4108	\|\| !TEST_ptr(pkey))
4109	goto err;
4110
4111	EVP_PKEY_meth_get0_info(&orig_id, &orig_flags, orig_pmeth);
4112	if (!TEST_int_eq(orig_id, id)
4113	\|\| !TEST_ptr(custom_pmeth = EVP_PKEY_meth_new(id, orig_flags)))
4114	goto err;
4115
4116	if (id == EVP_PKEY_ED25519) {
4117	EVP_PKEY_meth_set_digestsign(custom_pmeth, custom_pmeth_digestsign);
4118	} if (id == EVP_PKEY_DH \|\| id == EVP_PKEY_X25519) {
4119	EVP_PKEY_meth_set_derive(custom_pmeth, NULL, custom_pmeth_derive);
4120	} else {
4121	EVP_PKEY_meth_set_sign(custom_pmeth, NULL, custom_pmeth_sign);
4122	}
4123	if (id != EVP_PKEY_ED25519 && id != EVP_PKEY_X25519) {
4124	EVP_PKEY_meth_set_init(custom_pmeth, custom_pmeth_init);
4125	EVP_PKEY_meth_set_cleanup(custom_pmeth, custom_pmeth_cleanup);
4126	EVP_PKEY_meth_set_copy(custom_pmeth, custom_pmeth_copy);
4127	}
4128	EVP_PKEY_meth_set_ctrl(custom_pmeth, custom_pmeth_ctrl, NULL);
4129	if (!TEST_true(EVP_PKEY_meth_add0(custom_pmeth)))
4130	goto err;
4131
4132	if (doderive) {
4133	pctx = EVP_PKEY_CTX_new(pkey, NULL);
4134	if (!TEST_ptr(pctx)
4135	\|\| !TEST_int_eq(EVP_PKEY_derive_init(pctx), 1)
4136	\|\| !TEST_int_ge(EVP_PKEY_CTX_ctrl(pctx, -1, -1,
4137	EVP_PKEY_CTRL_MY_COMMAND, 0, NULL),
4138	1)
4139	\|\| !TEST_int_eq(ctrl_called, 1)
4140	\|\| !TEST_int_ge(EVP_PKEY_derive_set_peer(pctx, pkey), 1)
4141	\|\| !TEST_int_ge(EVP_PKEY_derive(pctx, NULL, &reslen), 1)
4142	\|\| !TEST_ptr(res = OPENSSL_malloc(reslen))
4143	\|\| !TEST_int_ge(EVP_PKEY_derive(pctx, res, &reslen), 1))
4144	goto err;
4145	} else {
4146	ctx = EVP_MD_CTX_new();
4147	reslen = EVP_PKEY_size(pkey);
4148	res = OPENSSL_malloc(reslen);
4149	if (!TEST_ptr(ctx)
4150	\|\| !TEST_ptr(res)
4151	\|\| !TEST_true(EVP_DigestSignInit(ctx, &pctx, md, NULL, pkey))
4152	\|\| !TEST_int_ge(EVP_PKEY_CTX_ctrl(pctx, -1, -1,
4153	EVP_PKEY_CTRL_MY_COMMAND, 0, NULL),
4154	1)
4155	\|\| !TEST_int_eq(ctrl_called, 1))
4156	goto err;
4157
4158	if (id == EVP_PKEY_ED25519) {
4159	if (!TEST_true(EVP_DigestSign(ctx, res, &reslen, msg, sizeof(msg))))
4160	goto err;
4161	} else {
4162	if (!TEST_true(EVP_DigestUpdate(ctx, msg, sizeof(msg)))
4163	\|\| !TEST_true(EVP_DigestSignFinal(ctx, res, &reslen)))
4164	goto err;
4165	}
4166	}
4167
4168	testresult = 1;
4169	err:
4170	OPENSSL_free(res);
4171	EVP_MD_CTX_free(ctx);
4172	if (doderive)
4173	EVP_PKEY_CTX_free(pctx);
4174	EVP_PKEY_free(pkey);
4175	EVP_PKEY_meth_remove(custom_pmeth);
4176	EVP_PKEY_meth_free(custom_pmeth);
4177	custom_pmeth = NULL;
4178	return testresult;
4179	}
4180
4181	static int test_evp_md_cipher_meth(void)
4182	{
4183	EVP_MD *md = EVP_MD_meth_dup(EVP_sha256());
4184	EVP_CIPHER *ciph = EVP_CIPHER_meth_dup(EVP_aes_128_cbc());
4185	int testresult = 0;
4186
4187	if (!TEST_ptr(md) \|\| !TEST_ptr(ciph))
4188	goto err;
4189
4190	testresult = 1;
4191
4192	err:
4193	EVP_MD_meth_free(md);
4194	EVP_CIPHER_meth_free(ciph);
4195
4196	return testresult;
4197	}
4198
4199	typedef struct {
4200	int data;
4201	} custom_dgst_ctx;
4202
4203	static int custom_md_init_called = 0;
4204	static int custom_md_cleanup_called = 0;
4205
4206	static int custom_md_init(EVP_MD_CTX *ctx)
4207	{
4208	custom_dgst_ctx *p = EVP_MD_CTX_md_data(ctx);
4209
4210	if (p == NULL)
4211	return 0;
4212
4213	custom_md_init_called++;
4214	return 1;
4215	}
4216
4217	static int custom_md_cleanup(EVP_MD_CTX *ctx)
4218	{
4219	custom_dgst_ctx *p = EVP_MD_CTX_md_data(ctx);
4220
4221	if (p == NULL)
4222	/* Nothing to do */
4223	return 1;
4224
4225	custom_md_cleanup_called++;
4226	return 1;
4227	}
4228
4229	static int test_custom_md_meth(void)
4230	{
4231	EVP_MD_CTX *mdctx = NULL;
4232	EVP_MD *tmp = NULL;
4233	char mess[] = "Test Message\n";
4234	unsigned char md_value[EVP_MAX_MD_SIZE];
4235	unsigned int md_len;
4236	int testresult = 0;
4237	int nid;
4238
4239	/*
4240	* We are testing deprecated functions. We don't support a non-default
4241	* library context in this test.
4242	*/
4243	if (testctx != NULL)
4244	return 1;
4245
4246	custom_md_init_called = custom_md_cleanup_called = 0;
4247
4248	nid = OBJ_create("1.3.6.1.4.1.16604.998866.1", "custom-md", "custom-md");
4249	if (!TEST_int_ne(nid, NID_undef))
4250	goto err;
4251	tmp = EVP_MD_meth_new(nid, NID_undef);
4252	if (!TEST_ptr(tmp))
4253	goto err;
4254
4255	if (!TEST_true(EVP_MD_meth_set_init(tmp, custom_md_init))
4256	\|\| !TEST_true(EVP_MD_meth_set_cleanup(tmp, custom_md_cleanup))
4257	\|\| !TEST_true(EVP_MD_meth_set_app_datasize(tmp,
4258	sizeof(custom_dgst_ctx))))
4259	goto err;
4260
4261	mdctx = EVP_MD_CTX_new();
4262	if (!TEST_ptr(mdctx)
4263	/*
4264	* Initing our custom md and then initing another md should
4265	* result in the init and cleanup functions of the custom md
4266	* from being called.
4267	*/
4268	\|\| !TEST_true(EVP_DigestInit_ex(mdctx, tmp, NULL))
4269	\|\| !TEST_true(EVP_DigestInit_ex(mdctx, EVP_sha256(), NULL))
4270	\|\| !TEST_true(EVP_DigestUpdate(mdctx, mess, strlen(mess)))
4271	\|\| !TEST_true(EVP_DigestFinal_ex(mdctx, md_value, &md_len))
4272	\|\| !TEST_int_eq(custom_md_init_called, 1)
4273	\|\| !TEST_int_eq(custom_md_cleanup_called, 1))
4274	goto err;
4275
4276	testresult = 1;
4277	err:
4278	EVP_MD_CTX_free(mdctx);
4279	EVP_MD_meth_free(tmp);
4280	return testresult;
4281	}
4282
4283	# ifndef OPENSSL_NO_DYNAMIC_ENGINE
4284	/* Test we can create a signature keys with an associated ENGINE */
4285	static int test_signatures_with_engine(int tst)
4286	{
4287	ENGINE *e;
4288	const char *engine_id = "dasync";
4289	EVP_PKEY *pkey = NULL;
4290	const unsigned char badcmackey[] = { 0x00, 0x01 };
4291	const unsigned char cmackey[] = {
4292	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
4293	0x0c, 0x0d, 0x0e, 0x0f
4294	};
4295	const unsigned char ed25519key[] = {
4296	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
4297	0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
4298	0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
4299	};
4300	const unsigned char msg[] = { 0x00, 0x01, 0x02, 0x03 };
4301	int testresult = 0;
4302	EVP_MD_CTX *ctx = NULL;
4303	unsigned char *mac = NULL;
4304	size_t maclen = 0;
4305	int ret;
4306
4307	# ifdef OPENSSL_NO_CMAC
4308	/* Skip CMAC tests in a no-cmac build */
4309	if (tst <= 1)
4310	return 1;
4311	# endif
4312
4313	if (!TEST_ptr(e = ENGINE_by_id(engine_id)))
4314	return 0;
4315
4316	if (!TEST_true(ENGINE_init(e))) {
4317	ENGINE_free(e);
4318	return 0;
4319	}
4320
4321	switch (tst) {
4322	case 0:
4323	pkey = EVP_PKEY_new_CMAC_key(e, cmackey, sizeof(cmackey),
4324	EVP_aes_128_cbc());
4325	break;
4326	case 1:
4327	pkey = EVP_PKEY_new_CMAC_key(e, badcmackey, sizeof(badcmackey),
4328	EVP_aes_128_cbc());
4329	break;
4330	case 2:
4331	pkey = EVP_PKEY_new_raw_private_key(EVP_PKEY_ED25519, e, ed25519key,
4332	sizeof(ed25519key));
4333	break;
4334	default:
4335	TEST_error("Invalid test case");
4336	goto err;
4337	}
4338	if (!TEST_ptr(pkey))
4339	goto err;
4340
4341	if (!TEST_ptr(ctx = EVP_MD_CTX_new()))
4342	goto err;
4343
4344	ret = EVP_DigestSignInit(ctx, NULL, tst == 2 ? NULL : EVP_sha256(), NULL,
4345	pkey);
4346	if (tst == 0) {
4347	if (!TEST_true(ret))
4348	goto err;
4349
4350	if (!TEST_true(EVP_DigestSignUpdate(ctx, msg, sizeof(msg)))
4351	\|\| !TEST_true(EVP_DigestSignFinal(ctx, NULL, &maclen)))
4352	goto err;
4353
4354	if (!TEST_ptr(mac = OPENSSL_malloc(maclen)))
4355	goto err;
4356
4357	if (!TEST_true(EVP_DigestSignFinal(ctx, mac, &maclen)))
4358	goto err;
4359	} else {
4360	/* We used a bad key. We expect a failure here */
4361	if (!TEST_false(ret))
4362	goto err;
4363	}
4364
4365	testresult = 1;
4366	err:
4367	EVP_MD_CTX_free(ctx);
4368	OPENSSL_free(mac);
4369	EVP_PKEY_free(pkey);
4370	ENGINE_finish(e);
4371	ENGINE_free(e);
4372
4373	return testresult;
4374	}
4375
4376	static int test_cipher_with_engine(void)
4377	{
4378	ENGINE *e;
4379	const char *engine_id = "dasync";
4380	const unsigned char keyiv[] = {
4381	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
4382	0x0c, 0x0d, 0x0e, 0x0f
4383	};
4384	const unsigned char msg[] = { 0x00, 0x01, 0x02, 0x03 };
4385	int testresult = 0;
4386	EVP_CIPHER_CTX ctx = NULL, ctx2 = NULL;
4387	unsigned char buf[AES_BLOCK_SIZE];
4388	int len = 0;
4389
4390	if (!TEST_ptr(e = ENGINE_by_id(engine_id)))
4391	return 0;
4392
4393	if (!TEST_true(ENGINE_init(e))) {
4394	ENGINE_free(e);
4395	return 0;
4396	}
4397
4398	if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())
4399	\|\| !TEST_ptr(ctx2 = EVP_CIPHER_CTX_new()))
4400	goto err;
4401
4402	if (!TEST_true(EVP_EncryptInit_ex(ctx, EVP_aes_128_cbc(), e, keyiv, keyiv)))
4403	goto err;
4404
4405	/* Copy the ctx, and complete the operation with the new ctx */
4406	if (!TEST_true(EVP_CIPHER_CTX_copy(ctx2, ctx)))
4407	goto err;
4408
4409	if (!TEST_true(EVP_EncryptUpdate(ctx2, buf, &len, msg, sizeof(msg)))
4410	\|\| !TEST_true(EVP_EncryptFinal_ex(ctx2, buf + len, &len)))
4411	goto err;
4412
4413	testresult = 1;
4414	err:
4415	EVP_CIPHER_CTX_free(ctx);
4416	EVP_CIPHER_CTX_free(ctx2);
4417	ENGINE_finish(e);
4418	ENGINE_free(e);
4419
4420	return testresult;
4421	}
4422	# endif /* OPENSSL_NO_DYNAMIC_ENGINE */
4423	#endif /* OPENSSL_NO_DEPRECATED_3_0 */
4424
4425	static int ecxnids[] = {
4426	NID_X25519,
4427	NID_X448,
4428	NID_ED25519,
4429	NID_ED448
4430	};
4431
4432	/* Test that creating ECX keys with a short private key fails as expected */
4433	static int test_ecx_short_keys(int tst)
4434	{
4435	unsigned char ecxkeydata = 1;
4436	EVP_PKEY *pkey;
4437
4438
4439	pkey = EVP_PKEY_new_raw_private_key(ecxnids[tst], NULL, &ecxkeydata, 1);
4440	if (!TEST_ptr_null(pkey)) {
4441	EVP_PKEY_free(pkey);
4442	return 0;
4443	}
4444	return 1;
4445	}
4446
4447	typedef enum OPTION_choice {
4448	OPT_ERR = -1,
4449	OPT_EOF = 0,
4450	OPT_CONTEXT,
4451	OPT_TEST_ENUM
4452	} OPTION_CHOICE;
4453
4454	const OPTIONS *test_get_options(void)
4455	{
4456	static const OPTIONS options[] = {
4457	OPT_TEST_OPTIONS_DEFAULT_USAGE,
4458	{ "context", OPT_CONTEXT, '-', "Explicitly use a non-default library context" },
4459	{ NULL }
4460	};
4461	return options;
4462	}
4463
4464	int setup_tests(void)
4465	{
4466	OPTION_CHOICE o;
4467
4468	while ((o = opt_next()) != OPT_EOF) {
4469	switch (o) {
4470	case OPT_CONTEXT:
4471	/* Set up an alternate library context */
4472	testctx = OSSL_LIB_CTX_new();
4473	if (!TEST_ptr(testctx))
4474	return 0;
4475	/* Swap the libctx to test non-default context only */
4476	nullprov = OSSL_PROVIDER_load(NULL, "null");
4477	deflprov = OSSL_PROVIDER_load(testctx, "default");
4478	lgcyprov = OSSL_PROVIDER_load(testctx, "legacy");
4479	break;
4480	case OPT_TEST_CASES:
4481	break;
4482	default:
4483	return 0;
4484	}
4485	}
4486
4487	ADD_TEST(test_EVP_set_default_properties);
4488	ADD_ALL_TESTS(test_EVP_DigestSignInit, 30);
4489	ADD_TEST(test_EVP_DigestVerifyInit);
4490	#ifndef OPENSSL_NO_SIPHASH
4491	ADD_TEST(test_siphash_digestsign);
4492	#endif
4493	ADD_TEST(test_EVP_Digest);
4494	ADD_TEST(test_EVP_md_null);
4495	ADD_ALL_TESTS(test_EVP_PKEY_sign, 3);
4496	ADD_ALL_TESTS(test_EVP_Enveloped, 2);
4497	ADD_ALL_TESTS(test_d2i_AutoPrivateKey, OSSL_NELEM(keydata));
4498	ADD_TEST(test_privatekey_to_pkcs8);
4499	ADD_TEST(test_EVP_PKCS82PKEY_wrong_tag);
4500	#ifndef OPENSSL_NO_EC
4501	ADD_TEST(test_EVP_PKCS82PKEY);
4502	#endif
4503	#ifndef OPENSSL_NO_EC
4504	ADD_ALL_TESTS(test_EC_keygen_with_enc, OSSL_NELEM(ec_encodings));
4505	#endif
4506	#if !defined(OPENSSL_NO_SM2) && !defined(FIPS_MODULE)
4507	ADD_TEST(test_EVP_SM2);
4508	ADD_TEST(test_EVP_SM2_verify);
4509	#endif
4510	ADD_ALL_TESTS(test_set_get_raw_keys, OSSL_NELEM(keys));
4511	#ifndef OPENSSL_NO_DEPRECATED_3_0
4512	custom_pmeth = EVP_PKEY_meth_new(0xdefaced, 0);
4513	if (!TEST_ptr(custom_pmeth))
4514	return 0;
4515	EVP_PKEY_meth_set_check(custom_pmeth, pkey_custom_check);
4516	EVP_PKEY_meth_set_public_check(custom_pmeth, pkey_custom_pub_check);
4517	EVP_PKEY_meth_set_param_check(custom_pmeth, pkey_custom_param_check);
4518	if (!TEST_int_eq(EVP_PKEY_meth_add0(custom_pmeth), 1))
4519	return 0;
4520	#endif
4521	ADD_ALL_TESTS(test_EVP_PKEY_check, OSSL_NELEM(keycheckdata));
4522	#ifndef OPENSSL_NO_CMAC
4523	ADD_TEST(test_CMAC_keygen);
4524	#endif
4525	ADD_TEST(test_HKDF);
4526	ADD_TEST(test_emptyikm_HKDF);
4527	#ifndef OPENSSL_NO_EC
4528	ADD_TEST(test_X509_PUBKEY_inplace);
4529	ADD_TEST(test_X509_PUBKEY_dup);
4530	ADD_ALL_TESTS(test_invalide_ec_char2_pub_range_decode,
4531	OSSL_NELEM(ec_der_pub_keys));
4532	#endif
4533	#ifndef OPENSSL_NO_DSA
4534	ADD_TEST(test_DSA_get_set_params);
4535	ADD_TEST(test_DSA_priv_pub);
4536	#endif
4537	ADD_TEST(test_RSA_get_set_params);
4538	#if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
4539	ADD_TEST(test_decrypt_null_chunks);
4540	#endif
4541	#ifndef OPENSSL_NO_DH
4542	ADD_TEST(test_DH_priv_pub);
4543	# ifndef OPENSSL_NO_DEPRECATED_3_0
4544	ADD_TEST(test_EVP_PKEY_set1_DH);
4545	# endif
4546	#endif
4547	#ifndef OPENSSL_NO_EC
4548	ADD_TEST(test_EC_priv_pub);
4549	# ifndef OPENSSL_NO_DEPRECATED_3_0
4550	ADD_TEST(test_EC_priv_only_legacy);
4551	# endif
4552	#endif
4553	ADD_ALL_TESTS(test_keygen_with_empty_template, 2);
4554	ADD_ALL_TESTS(test_pkey_ctx_fail_without_provider, 2);
4555
4556	ADD_TEST(test_rand_agglomeration);
4557	ADD_ALL_TESTS(test_evp_iv_aes, 12);
4558	#ifndef OPENSSL_NO_DES
4559	ADD_ALL_TESTS(test_evp_iv_des, 6);
4560	#endif
4561	ADD_TEST(test_EVP_rsa_pss_with_keygen_bits);
4562	ADD_TEST(test_EVP_rsa_pss_set_saltlen);
4563	#ifndef OPENSSL_NO_EC
4564	ADD_ALL_TESTS(test_ecpub, OSSL_NELEM(ecpub_nids));
4565	#endif
4566
4567	ADD_TEST(test_names_do_all);
4568
4569	ADD_ALL_TESTS(test_evp_init_seq, OSSL_NELEM(evp_init_tests));
4570	ADD_ALL_TESTS(test_evp_reset, OSSL_NELEM(evp_reset_tests));
4571	ADD_ALL_TESTS(test_gcm_reinit, OSSL_NELEM(gcm_reinit_tests));
4572	ADD_ALL_TESTS(test_evp_updated_iv, OSSL_NELEM(evp_updated_iv_tests));
4573
4574	#ifndef OPENSSL_NO_DEPRECATED_3_0
4575	ADD_ALL_TESTS(test_custom_pmeth, 12);
4576	ADD_TEST(test_evp_md_cipher_meth);
4577	ADD_TEST(test_custom_md_meth);
4578
4579	# ifndef OPENSSL_NO_DYNAMIC_ENGINE
4580	/* Tests only support the default libctx */
4581	if (testctx == NULL) {
4582	# ifndef OPENSSL_NO_EC
4583	ADD_ALL_TESTS(test_signatures_with_engine, 3);
4584	# else
4585	ADD_ALL_TESTS(test_signatures_with_engine, 2);
4586	# endif
4587	ADD_TEST(test_cipher_with_engine);
4588	}
4589	# endif
4590	#endif
4591
4592	ADD_ALL_TESTS(test_ecx_short_keys, OSSL_NELEM(ecxnids));
4593
4594	return 1;
4595	}
4596
4597	void cleanup_tests(void)
4598	{
4599	OSSL_PROVIDER_unload(nullprov);
4600	OSSL_PROVIDER_unload(deflprov);
4601	OSSL_PROVIDER_unload(lgcyprov);
4602	OSSL_LIB_CTX_free(testctx);
4603	}

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/libs/openssl-3.0.3/test/evp_extra_test.c@ 96408

以其他格式下載: