evp_extra_test.c@ 108206

Last change on this file since 108206 was 108206, checked in by vboxsync, 3 months ago
openssl-3.3.2: Exported all files to OSE and removed .scm-settings bugref:10757
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 192.4 KB

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

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

source: vbox/trunk/src/libs/openssl-3.3.2/test/evp_extra_test.c@ 108206

Download in other formats: