xref: /openssl/test/evp_extra_test2.c (revision 0c64b1ca) 
1 /*
2  * Copyright 2015-2024 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9 
10 /* We need to use some deprecated APIs */
11 #define OPENSSL_SUPPRESS_DEPRECATED
12 
13 /*
14  * Really these tests should be in evp_extra_test - but that doesn't
15  * yet support testing with a non-default libctx. Once it does we should move
16  * everything into one file. Consequently some things are duplicated between
17  * the two files.
18  */
19 
20 #include <openssl/evp.h>
21 #include <openssl/pem.h>
22 #include <openssl/provider.h>
23 #include <openssl/rsa.h>
24 #include <openssl/dh.h>
25 #include <openssl/core_names.h>
26 #include <openssl/ui.h>
27 
28 #include "testutil.h"
29 #include "internal/nelem.h"
30 #include "crypto/evp.h"
31 #include "../crypto/evp/evp_local.h"
32 
33 /* Defined in tls-provider.c */
34 int tls_provider_init(const OSSL_CORE_HANDLE *handle,
35                       const OSSL_DISPATCH *in,
36                       const OSSL_DISPATCH **out,
37                       void **provctx);
38 
39 static OSSL_LIB_CTX *mainctx = NULL;
40 static OSSL_PROVIDER *nullprov = NULL;
41 
42 /*
43  * kExampleRSAKeyDER is an RSA private key in ASN.1, DER format. Of course, you
44  * should never use this key anywhere but in an example.
45  */
46 static const unsigned char kExampleRSAKeyDER[] = {
47     0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xf8,
48     0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5, 0xb4, 0x59,
49     0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e, 0xd3, 0x37,
50     0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34, 0x75, 0x71,
51     0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde, 0x97, 0x8a,
52     0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8, 0x50, 0xe4,
53     0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b, 0xdc, 0xec,
54     0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83, 0x58, 0x76,
55     0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48, 0x1a, 0xd8,
56     0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a, 0x5c, 0xd7,
57     0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2, 0xa7, 0x2c,
58     0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01, 0x00, 0x01,
59     0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a, 0x6d, 0xc7,
60     0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5, 0x32, 0x85,
61     0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6, 0x5f, 0xee,
62     0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8, 0x66, 0x85,
63     0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6, 0xa4, 0x0a,
64     0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f, 0xc2, 0x15,
65     0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c, 0x5b, 0x83,
66     0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78, 0x80, 0x1b,
67     0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71, 0x99, 0x73,
68     0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60, 0x1f, 0x99,
69     0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d, 0xb1, 0x02,
70     0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3, 0x40, 0x41,
71     0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d, 0x3d, 0x59,
72     0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18, 0xc6, 0xd9,
73     0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d, 0x9f, 0xef,
74     0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32, 0x46, 0x87,
75     0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc, 0x2c, 0xdf,
76     0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63, 0x55, 0xf5,
77     0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05, 0xcd, 0xb5,
78     0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16, 0xb3, 0x62,
79     0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3, 0x9b, 0x64,
80     0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85, 0xfa, 0xb8,
81     0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97, 0xe8, 0xba,
82     0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7, 0xe7, 0xfe,
83     0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99, 0x75, 0xe7,
84     0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4, 0x9d, 0xfe,
85     0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d, 0xf1, 0xdb,
86     0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40, 0x5a, 0x34,
87     0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26, 0x84, 0x27,
88     0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1, 0xe9, 0xc0,
89     0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c, 0xb9, 0xba,
90     0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30, 0x10, 0x06,
91     0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea, 0x52, 0x2c,
92     0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b, 0xc4, 0x1e,
93     0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e, 0x49, 0xaf,
94     0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9, 0xd1, 0x8a,
95     0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae, 0x17, 0x17,
96     0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d, 0x08, 0xf1,
97     0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
98 };
99 
100 /*
101  * kExampleRSAKeyPKCS8 is kExampleRSAKeyDER encoded in a PKCS #8
102  * PrivateKeyInfo.
103  */
104 static const unsigned char kExampleRSAKeyPKCS8[] = {
105     0x30, 0x82, 0x02, 0x76, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a,
106     0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82,
107     0x02, 0x60, 0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81,
108     0x00, 0xf8, 0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5,
109     0xb4, 0x59, 0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e,
110     0xd3, 0x37, 0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34,
111     0x75, 0x71, 0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde,
112     0x97, 0x8a, 0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8,
113     0x50, 0xe4, 0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b,
114     0xdc, 0xec, 0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83,
115     0x58, 0x76, 0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48,
116     0x1a, 0xd8, 0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a,
117     0x5c, 0xd7, 0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2,
118     0xa7, 0x2c, 0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01,
119     0x00, 0x01, 0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a,
120     0x6d, 0xc7, 0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5,
121     0x32, 0x85, 0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6,
122     0x5f, 0xee, 0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8,
123     0x66, 0x85, 0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6,
124     0xa4, 0x0a, 0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f,
125     0xc2, 0x15, 0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c,
126     0x5b, 0x83, 0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78,
127     0x80, 0x1b, 0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71,
128     0x99, 0x73, 0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60,
129     0x1f, 0x99, 0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d,
130     0xb1, 0x02, 0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3,
131     0x40, 0x41, 0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d,
132     0x3d, 0x59, 0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18,
133     0xc6, 0xd9, 0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d,
134     0x9f, 0xef, 0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32,
135     0x46, 0x87, 0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc,
136     0x2c, 0xdf, 0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63,
137     0x55, 0xf5, 0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05,
138     0xcd, 0xb5, 0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16,
139     0xb3, 0x62, 0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3,
140     0x9b, 0x64, 0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85,
141     0xfa, 0xb8, 0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97,
142     0xe8, 0xba, 0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7,
143     0xe7, 0xfe, 0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99,
144     0x75, 0xe7, 0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4,
145     0x9d, 0xfe, 0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d,
146     0xf1, 0xdb, 0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40,
147     0x5a, 0x34, 0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26,
148     0x84, 0x27, 0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1,
149     0xe9, 0xc0, 0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c,
150     0xb9, 0xba, 0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30,
151     0x10, 0x06, 0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea,
152     0x52, 0x2c, 0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b,
153     0xc4, 0x1e, 0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e,
154     0x49, 0xaf, 0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9,
155     0xd1, 0x8a, 0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae,
156     0x17, 0x17, 0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d,
157     0x08, 0xf1, 0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
158 };
159 
160 #ifndef OPENSSL_NO_DH
161 static const unsigned char kExampleDHPrivateKeyDER[] = {
162     0x30, 0x82, 0x02, 0x26, 0x02, 0x01, 0x00, 0x30, 0x82, 0x01, 0x17, 0x06,
163     0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x03, 0x01, 0x30, 0x82,
164     0x01, 0x08, 0x02, 0x82, 0x01, 0x01, 0x00, 0xD8, 0x4B, 0x0F, 0x0E, 0x6B,
165     0x79, 0xE9, 0x23, 0x4E, 0xE4, 0xBE, 0x9A, 0x8F, 0x7A, 0x5C, 0xA3, 0x20,
166     0xD0, 0x86, 0x6B, 0x95, 0x78, 0x39, 0x59, 0x7A, 0x11, 0x2A, 0x5B, 0x87,
167     0xA4, 0xFB, 0x2F, 0x99, 0xD0, 0x57, 0xF5, 0xE1, 0xA3, 0xAF, 0x41, 0xD1,
168     0xCD, 0xA3, 0x94, 0xBB, 0xE5, 0x5A, 0x68, 0xE2, 0xEE, 0x69, 0x56, 0x51,
169     0xB2, 0xEE, 0xF2, 0xFE, 0x10, 0xC9, 0x55, 0xE3, 0x82, 0x3C, 0x50, 0x0D,
170     0xF5, 0x82, 0x73, 0xE4, 0xD6, 0x3E, 0x45, 0xB4, 0x89, 0x80, 0xE4, 0xF0,
171     0x99, 0x85, 0x2B, 0x4B, 0xF9, 0xB8, 0xFD, 0x2C, 0x3C, 0x49, 0x2E, 0xB3,
172     0x56, 0x7E, 0x99, 0x07, 0xD3, 0xF7, 0xD9, 0xE4, 0x0C, 0x64, 0xC5, 0x7D,
173     0x03, 0x8E, 0x05, 0x3C, 0x0A, 0x40, 0x17, 0xAD, 0xA8, 0x0F, 0x9B, 0xF4,
174     0x8B, 0xA7, 0xDB, 0x16, 0x4F, 0x4A, 0x57, 0x0B, 0x89, 0x80, 0x0B, 0x9F,
175     0x26, 0x56, 0x3F, 0x1D, 0xFA, 0x52, 0x2D, 0x1A, 0x9E, 0xDC, 0x42, 0xA3,
176     0x2E, 0xA9, 0x87, 0xE3, 0x8B, 0x45, 0x5E, 0xEE, 0x99, 0xB8, 0x30, 0x15,
177     0x58, 0xA3, 0x5F, 0xB5, 0x69, 0xD8, 0x0C, 0xE8, 0x6B, 0x36, 0xD8, 0xAB,
178     0xD8, 0xE4, 0x77, 0x46, 0x13, 0xA2, 0x15, 0xB3, 0x9C, 0xAD, 0x99, 0x91,
179     0xE5, 0xA3, 0x30, 0x7D, 0x40, 0x70, 0xB3, 0x32, 0x5E, 0xAF, 0x96, 0x8D,
180     0xE6, 0x3F, 0x47, 0xA3, 0x18, 0xDA, 0xE1, 0x9A, 0x20, 0x11, 0xE1, 0x49,
181     0x51, 0x45, 0xE3, 0x8C, 0xA5, 0x56, 0x39, 0x67, 0xCB, 0x9D, 0xCF, 0xBA,
182     0xF4, 0x46, 0x4E, 0x0A, 0xB6, 0x0B, 0xA9, 0xB4, 0xF6, 0xF1, 0x6A, 0xC8,
183     0x63, 0xE2, 0xB4, 0xB2, 0x9F, 0x44, 0xAA, 0x0A, 0xDA, 0x53, 0xF7, 0x52,
184     0x14, 0x57, 0xEE, 0x2C, 0x5D, 0x31, 0x9C, 0x27, 0x03, 0x64, 0x9E, 0xC0,
185     0x1E, 0x4B, 0x1B, 0x4F, 0xEE, 0xA6, 0x3F, 0xC1, 0x3E, 0x61, 0x93, 0x02,
186     0x01, 0x02, 0x04, 0x82, 0x01, 0x04, 0x02, 0x82, 0x01, 0x00, 0x7E, 0xC2,
187     0x04, 0xF9, 0x95, 0xC7, 0xEF, 0x96, 0xBE, 0xA0, 0x9D, 0x2D, 0xC3, 0x0C,
188     0x3A, 0x67, 0x02, 0x7C, 0x7D, 0x3B, 0xC9, 0xB1, 0xDE, 0x13, 0x97, 0x64,
189     0xEF, 0x87, 0x80, 0x4F, 0xBF, 0xA2, 0xAC, 0x18, 0x6B, 0xD5, 0xB2, 0x42,
190     0x0F, 0xDA, 0x28, 0x40, 0x93, 0x40, 0xB2, 0x1E, 0x80, 0xB0, 0x6C, 0xDE,
191     0x9C, 0x54, 0xA4, 0xB4, 0x68, 0x29, 0xE0, 0x13, 0x57, 0x1D, 0xC9, 0x87,
192     0xC0, 0xDE, 0x2F, 0x1D, 0x72, 0xF0, 0xC0, 0xE4, 0x4E, 0x04, 0x48, 0xF5,
193     0x2D, 0x8D, 0x9A, 0x1B, 0xE5, 0xEB, 0x06, 0xAB, 0x7C, 0x74, 0x10, 0x3C,
194     0xA8, 0x2D, 0x39, 0xBC, 0xE3, 0x15, 0x3E, 0x63, 0x37, 0x8C, 0x1B, 0xF1,
195     0xB3, 0x99, 0xB6, 0xAE, 0x5A, 0xEB, 0xB3, 0x3D, 0x30, 0x39, 0x69, 0xDB,
196     0xF2, 0x4F, 0x94, 0xB7, 0x71, 0xAF, 0xBA, 0x5C, 0x1F, 0xF8, 0x6B, 0xE5,
197     0xD1, 0xB1, 0x00, 0x81, 0xE2, 0x6D, 0xEC, 0x65, 0xF7, 0x7E, 0xCE, 0x03,
198     0x84, 0x68, 0x42, 0x6A, 0x8B, 0x47, 0x8E, 0x4A, 0x88, 0xDE, 0x82, 0xDD,
199     0xAF, 0xA9, 0x6F, 0x18, 0xF7, 0xC6, 0xE2, 0xB9, 0x97, 0xCE, 0x47, 0x8F,
200     0x85, 0x19, 0x61, 0x42, 0x67, 0x21, 0x7D, 0x13, 0x6E, 0xB5, 0x5A, 0x62,
201     0xF3, 0x08, 0xE2, 0x70, 0x3B, 0x0E, 0x85, 0x3C, 0xA1, 0xD3, 0xED, 0x7A,
202     0x43, 0xD6, 0xDE, 0x30, 0x5C, 0x48, 0xB2, 0x99, 0xAB, 0x3E, 0x65, 0xA6,
203     0x66, 0x80, 0x22, 0xFF, 0x92, 0xC1, 0x42, 0x1C, 0x30, 0x87, 0x74, 0x1E,
204     0x53, 0x57, 0x7C, 0xF8, 0x77, 0x51, 0xF1, 0x74, 0x16, 0xF4, 0x45, 0x26,
205     0x77, 0x0A, 0x05, 0x96, 0x13, 0x12, 0x06, 0x86, 0x2B, 0xB8, 0x49, 0x82,
206     0x69, 0x43, 0x0A, 0x57, 0xA7, 0x30, 0x19, 0x4C, 0xB8, 0x47, 0x82, 0x6E,
207     0x64, 0x7A, 0x06, 0x13, 0x5A, 0x82, 0x98, 0xD6, 0x7A, 0x09, 0xEC, 0x03,
208     0x8D, 0x03
209 };
210 #endif /* OPENSSL_NO_DH */
211 
212 #ifndef OPENSSL_NO_EC
213 /*
214  * kExampleECKeyDER is a sample EC private key encoded as an ECPrivateKey
215  * structure.
216  */
217 static const unsigned char kExampleECKeyDER[] = {
218     0x30, 0x77, 0x02, 0x01, 0x01, 0x04, 0x20, 0x07, 0x0f, 0x08, 0x72, 0x7a,
219     0xd4, 0xa0, 0x4a, 0x9c, 0xdd, 0x59, 0xc9, 0x4d, 0x89, 0x68, 0x77, 0x08,
220     0xb5, 0x6f, 0xc9, 0x5d, 0x30, 0x77, 0x0e, 0xe8, 0xd1, 0xc9, 0xce, 0x0a,
221     0x8b, 0xb4, 0x6a, 0xa0, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
222     0x03, 0x01, 0x07, 0xa1, 0x44, 0x03, 0x42, 0x00, 0x04, 0xe6, 0x2b, 0x69,
223     0xe2, 0xbf, 0x65, 0x9f, 0x97, 0xbe, 0x2f, 0x1e, 0x0d, 0x94, 0x8a, 0x4c,
224     0xd5, 0x97, 0x6b, 0xb7, 0xa9, 0x1e, 0x0d, 0x46, 0xfb, 0xdd, 0xa9, 0xa9,
225     0x1e, 0x9d, 0xdc, 0xba, 0x5a, 0x01, 0xe7, 0xd6, 0x97, 0xa8, 0x0a, 0x18,
226     0xf9, 0xc3, 0xc4, 0xa3, 0x1e, 0x56, 0xe2, 0x7c, 0x83, 0x48, 0xdb, 0x16,
227     0x1a, 0x1c, 0xf5, 0x1d, 0x7e, 0xf1, 0x94, 0x2d, 0x4b, 0xcf, 0x72, 0x22,
228     0xc1,
229 };
230 
231 /* P-384 sample EC private key in PKCS8 format (no public key) */
232 static const unsigned char kExampleECKey2DER[] = {
233     0x30, 0x4E, 0x02, 0x01, 0x00, 0x30, 0x10, 0x06, 0x07, 0x2A, 0x86, 0x48,
234     0xCE, 0x3D, 0x02, 0x01, 0x06, 0x05, 0x2B, 0x81, 0x04, 0x00, 0x22, 0x04,
235     0x37, 0x30, 0x35, 0x02, 0x01, 0x01, 0x04, 0x30, 0x73, 0xE3, 0x3A, 0x05,
236     0xF2, 0xB6, 0x99, 0x6D, 0x0C, 0x33, 0x7F, 0x15, 0x9E, 0x10, 0xA9, 0x17,
237     0x4C, 0x0A, 0x82, 0x57, 0x71, 0x13, 0x7A, 0xAC, 0x46, 0xA2, 0x5E, 0x1C,
238     0xE0, 0xC7, 0xB2, 0xF8, 0x20, 0x40, 0xC2, 0x27, 0xC8, 0xBE, 0x02, 0x7E,
239     0x96, 0x69, 0xE0, 0x04, 0xCB, 0x89, 0x0B, 0x42
240 };
241 
242 # ifndef OPENSSL_NO_ECX
243 static const unsigned char kExampleECXKey2DER[] = {
244     0x30, 0x2E, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x6e,
245     0x04, 0x22, 0x04, 0x20, 0xc8, 0xa9, 0xd5, 0xa9, 0x10, 0x91, 0xad, 0x85,
246     0x1c, 0x66, 0x8b, 0x07, 0x36, 0xc1, 0xc9, 0xa0, 0x29, 0x36, 0xc0, 0xd3,
247     0xad, 0x62, 0x67, 0x08, 0x58, 0x08, 0x80, 0x47, 0xba, 0x05, 0x74, 0x75
248 };
249 # endif
250 #endif
251 
252 typedef struct APK_DATA_st {
253     const unsigned char *kder;
254     size_t size;
255     int evptype;
256 } APK_DATA;
257 
258 static APK_DATA keydata[] = {
259     {kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER), EVP_PKEY_RSA},
260     {kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8), EVP_PKEY_RSA},
261 #ifndef OPENSSL_NO_EC
262 # ifndef OPENSSL_NO_ECX
263     {kExampleECXKey2DER, sizeof(kExampleECXKey2DER), EVP_PKEY_X25519},
264 # endif
265     {kExampleECKeyDER, sizeof(kExampleECKeyDER), EVP_PKEY_EC},
266     {kExampleECKey2DER, sizeof(kExampleECKey2DER), EVP_PKEY_EC},
267 #endif
268 #ifndef OPENSSL_NO_DH
269     {kExampleDHPrivateKeyDER, sizeof(kExampleDHPrivateKeyDER), EVP_PKEY_DH},
270 #endif
271 };
272 
pkey_has_private(EVP_PKEY * key,const char * privtag,int use_octstring)273 static int pkey_has_private(EVP_PKEY *key, const char *privtag,
274                             int use_octstring)
275 {
276     int ret = 0;
277 
278     if (use_octstring) {
279         unsigned char buf[64];
280 
281         ret = EVP_PKEY_get_octet_string_param(key, privtag, buf, sizeof(buf),
282                                               NULL);
283     } else {
284         BIGNUM *bn = NULL;
285 
286         ret = EVP_PKEY_get_bn_param(key, privtag, &bn);
287         BN_free(bn);
288     }
289     return ret;
290 }
291 
do_pkey_tofrom_data_select(EVP_PKEY * key,const char * keytype)292 static int do_pkey_tofrom_data_select(EVP_PKEY *key, const char *keytype)
293 {
294     int ret = 0;
295     OSSL_PARAM *pub_params = NULL, *keypair_params = NULL;
296     EVP_PKEY *fromkey = NULL, *fromkeypair = NULL;
297     EVP_PKEY_CTX *fromctx = NULL;
298     const char *privtag = strcmp(keytype, "RSA") == 0 ? "d" : "priv";
299     const int use_octstring = strcmp(keytype, "X25519") == 0;
300 
301     /*
302      * Select only the public key component when using EVP_PKEY_todata() and
303      * check that the resulting param array does not contain a private key.
304      */
305     if (!TEST_int_eq(EVP_PKEY_todata(key, EVP_PKEY_PUBLIC_KEY, &pub_params), 1)
306         || !TEST_ptr_null(OSSL_PARAM_locate(pub_params, privtag)))
307         goto end;
308     /*
309      * Select the keypair when using EVP_PKEY_todata() and check that
310      * the param array contains a private key.
311      */
312     if (!TEST_int_eq(EVP_PKEY_todata(key, EVP_PKEY_KEYPAIR, &keypair_params), 1)
313         || !TEST_ptr(OSSL_PARAM_locate(keypair_params, privtag)))
314         goto end;
315 
316     /*
317      * Select only the public key when using EVP_PKEY_fromdata() and check that
318      * the resulting key does not contain a private key.
319      */
320     if (!TEST_ptr(fromctx = EVP_PKEY_CTX_new_from_name(mainctx, keytype, NULL))
321         || !TEST_int_eq(EVP_PKEY_fromdata_init(fromctx), 1)
322         || !TEST_int_eq(EVP_PKEY_fromdata(fromctx, &fromkey, EVP_PKEY_PUBLIC_KEY,
323                                           keypair_params), 1)
324         || !TEST_false(pkey_has_private(fromkey, privtag, use_octstring)))
325         goto end;
326     /*
327      * Select the keypair when using EVP_PKEY_fromdata() and check that
328      * the resulting key contains a private key.
329      */
330     if (!TEST_int_eq(EVP_PKEY_fromdata(fromctx, &fromkeypair,
331                                        EVP_PKEY_KEYPAIR, keypair_params), 1)
332         || !TEST_true(pkey_has_private(fromkeypair, privtag, use_octstring)))
333         goto end;
334     ret = 1;
335 end:
336     EVP_PKEY_free(fromkeypair);
337     EVP_PKEY_free(fromkey);
338     EVP_PKEY_CTX_free(fromctx);
339     OSSL_PARAM_free(keypair_params);
340     OSSL_PARAM_free(pub_params);
341     return ret;
342 }
343 
344 #ifndef OPENSSL_NO_DH
test_dh_tofrom_data_select(void)345 static int test_dh_tofrom_data_select(void)
346 {
347     int ret;
348     OSSL_PARAM params[2];
349     EVP_PKEY *key = NULL;
350     EVP_PKEY_CTX *gctx = NULL;
351 # ifndef OPENSSL_NO_DEPRECATED_3_0
352     const DH *dhkey;
353     const BIGNUM *privkey;
354 # endif
355 
356     params[0] = OSSL_PARAM_construct_utf8_string("group", "ffdhe2048", 0);
357     params[1] = OSSL_PARAM_construct_end();
358     ret = TEST_ptr(gctx = EVP_PKEY_CTX_new_from_name(mainctx, "DHX", NULL))
359           && TEST_int_gt(EVP_PKEY_keygen_init(gctx), 0)
360           && TEST_true(EVP_PKEY_CTX_set_params(gctx, params))
361           && TEST_int_gt(EVP_PKEY_generate(gctx, &key), 0)
362           && TEST_true(do_pkey_tofrom_data_select(key, "DHX"));
363 # ifndef OPENSSL_NO_DEPRECATED_3_0
364     ret = ret && TEST_ptr(dhkey = EVP_PKEY_get0_DH(key))
365               && TEST_ptr(privkey = DH_get0_priv_key(dhkey))
366               && TEST_int_le(BN_num_bits(privkey), 225);
367 # endif
368     EVP_PKEY_free(key);
369     EVP_PKEY_CTX_free(gctx);
370     return ret;
371 }
372 
test_dh_paramgen(void)373 static int test_dh_paramgen(void)
374 {
375     int ret;
376     OSSL_PARAM params[3];
377     EVP_PKEY *pkey = NULL;
378     EVP_PKEY_CTX *gctx = NULL;
379     unsigned int pbits = 512; /* minimum allowed for speed */
380 
381     params[0] = OSSL_PARAM_construct_uint(OSSL_PKEY_PARAM_FFC_PBITS, &pbits);
382     params[1] = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_FFC_TYPE,
383                                                  "generator", 0);
384     params[2] = OSSL_PARAM_construct_end();
385 
386     ret = TEST_ptr(gctx = EVP_PKEY_CTX_new_from_name(mainctx, "DH", NULL))
387           && TEST_int_gt(EVP_PKEY_paramgen_init(gctx), 0)
388           && TEST_true(EVP_PKEY_CTX_set_params(gctx, params))
389           && TEST_true(EVP_PKEY_paramgen(gctx, &pkey))
390           && TEST_ptr(pkey);
391 
392     EVP_PKEY_CTX_free(gctx);
393     gctx = NULL;
394 
395     ret = ret && TEST_ptr(gctx = EVP_PKEY_CTX_new_from_pkey(mainctx, pkey, NULL))
396               && TEST_int_eq(EVP_PKEY_param_check(gctx), 1)
397               && TEST_int_eq(EVP_PKEY_param_check_quick(gctx), 1);
398 
399     EVP_PKEY_CTX_free(gctx);
400     EVP_PKEY_free(pkey);
401     return ret;
402 }
403 
set_fromdata_string(EVP_PKEY_CTX * ctx,const char * name,char * value)404 static int set_fromdata_string(EVP_PKEY_CTX *ctx, const char *name, char *value)
405 {
406     int ret;
407     OSSL_PARAM params[2];
408     EVP_PKEY *pkey = NULL;
409 
410     if (EVP_PKEY_fromdata_init(ctx) != 1)
411         return -1;
412     params[0] = OSSL_PARAM_construct_utf8_string(name, value, 0);
413     params[1] = OSSL_PARAM_construct_end();
414     ret = EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_KEY_PARAMETERS, params);
415     EVP_PKEY_free(pkey);
416     return ret;
417 }
418 
set_fromdata_uint(EVP_PKEY_CTX * ctx,const char * name)419 static int set_fromdata_uint(EVP_PKEY_CTX *ctx, const char *name)
420 {
421     int ret;
422     unsigned int tmp = 0;
423     OSSL_PARAM params[2];
424     EVP_PKEY *pkey = NULL;
425 
426     if (EVP_PKEY_fromdata_init(ctx) != 1)
427         return -1;
428     params[0] = OSSL_PARAM_construct_uint(name, &tmp);
429     params[1] = OSSL_PARAM_construct_end();
430     ret = EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_KEY_PARAMETERS, params);
431     EVP_PKEY_free(pkey);
432     return ret;
433 }
434 
test_dh_paramfromdata(void)435 static int test_dh_paramfromdata(void)
436 {
437     EVP_PKEY_CTX *ctx = NULL;
438     int ret = 0;
439 
440     /* Test failure paths for FFC - mainly due to setting the wrong param type */
441     ret = TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(mainctx, "DH", NULL))
442           && TEST_int_eq(set_fromdata_uint(ctx, OSSL_PKEY_PARAM_GROUP_NAME), 0)
443           && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_GROUP_NAME, "bad"), 0)
444           && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_P, "bad"), 0)
445           && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_GINDEX, "bad"), 0)
446           && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_PCOUNTER, "bad"), 0)
447           && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_COFACTOR, "bad"), 0)
448           && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_H, "bad"), 0)
449           && TEST_int_eq(set_fromdata_uint(ctx, OSSL_PKEY_PARAM_FFC_SEED), 0)
450           && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_VALIDATE_PQ, "bad"), 0)
451           && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_VALIDATE_G, "bad"), 0)
452           && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_VALIDATE_LEGACY, "bad"), 0)
453           && TEST_int_eq(set_fromdata_uint(ctx, OSSL_PKEY_PARAM_FFC_DIGEST), 0);
454 
455     EVP_PKEY_CTX_free(ctx);
456     return ret;
457 }
458 
459 #endif
460 
461 /* Test that calling EVP_PKEY_Q_keygen() for a non-standard keytype works as expected */
test_new_keytype(void)462 static int test_new_keytype(void)
463 {
464     int ret = 0;
465     EVP_PKEY *key = NULL;
466     OSSL_PROVIDER *tlsprov = NULL;
467     EVP_PKEY_CTX *ctx = NULL;
468     size_t outlen, secretlen, secretlen2;
469     unsigned char *out = NULL, *secret = NULL, *secret2 = NULL;
470 
471     /* without tls-provider key should not be create-able */
472     if (TEST_ptr(key = EVP_PKEY_Q_keygen(mainctx, NULL, "XOR")))
473         goto err;
474     /* prepare & load tls-provider */
475     if (!TEST_true(OSSL_PROVIDER_add_builtin(mainctx, "tls-provider",
476                                              tls_provider_init))
477         || !TEST_ptr(tlsprov = OSSL_PROVIDER_load(mainctx, "tls-provider")))
478         goto err;
479     /* now try creating key again, should work this time */
480     if (!TEST_ptr(key = EVP_PKEY_Q_keygen(mainctx, NULL, "XOR")))
481         goto err;
482     /* now do encaps/decaps to validate all is good */
483     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new(key, NULL))
484         || !TEST_int_eq(EVP_PKEY_encapsulate_init(ctx, NULL), 1)
485         || !TEST_int_eq(EVP_PKEY_encapsulate(ctx, NULL, &outlen, NULL, &secretlen), 1))
486         goto err;
487     out = OPENSSL_malloc(outlen);
488     secret = OPENSSL_malloc(secretlen);
489     secret2 = OPENSSL_malloc(secretlen);
490     if (out == NULL || secret == NULL || secret2 == NULL
491         || !TEST_int_eq(EVP_PKEY_encapsulate(ctx, out, &outlen, secret, &secretlen), 1)
492         || !TEST_int_eq(EVP_PKEY_decapsulate_init(ctx, NULL), 1)
493         || !TEST_int_eq(EVP_PKEY_decapsulate(ctx, secret2, &secretlen2, out, outlen), 1)
494         || !TEST_mem_eq(secret, secretlen, secret2, secretlen2))
495         goto err;
496     ret = OSSL_PROVIDER_unload(tlsprov);
497 
498 err:
499     OPENSSL_free(out);
500     OPENSSL_free(secret);
501     OPENSSL_free(secret2);
502     EVP_PKEY_CTX_free(ctx);
503     EVP_PKEY_free(key);
504     return ret;
505 }
506 
507 #ifndef OPENSSL_NO_EC
508 
test_ec_d2i_i2d_pubkey(void)509 static int test_ec_d2i_i2d_pubkey(void)
510 {
511     int ret = 0;
512     FILE *fp = NULL;
513     EVP_PKEY *key = NULL, *outkey = NULL;
514     static const char *filename = "pubkey.der";
515 
516     if (!TEST_ptr(fp = fopen(filename, "wb"))
517         || !TEST_ptr(key = EVP_PKEY_Q_keygen(mainctx, NULL, "EC", "P-256"))
518         || !TEST_true(i2d_PUBKEY_fp(fp, key))
519         || !TEST_int_eq(fclose(fp), 0))
520         goto err;
521     fp = NULL;
522 
523     if (!TEST_ptr(fp = fopen(filename, "rb"))
524         || !TEST_ptr(outkey = d2i_PUBKEY_ex_fp(fp, NULL, mainctx, NULL))
525         || !TEST_int_eq(EVP_PKEY_eq(key, outkey), 1))
526         goto err;
527 
528     ret = 1;
529 
530 err:
531     EVP_PKEY_free(outkey);
532     EVP_PKEY_free(key);
533     fclose(fp);
534     return ret;
535 }
536 
test_ec_tofrom_data_select(void)537 static int test_ec_tofrom_data_select(void)
538 {
539     int ret;
540     EVP_PKEY *key = NULL;
541 
542     ret = TEST_ptr(key = EVP_PKEY_Q_keygen(mainctx, NULL, "EC", "P-256"))
543           && TEST_true(do_pkey_tofrom_data_select(key, "EC"));
544     EVP_PKEY_free(key);
545     return ret;
546 }
547 
548 # ifndef OPENSSL_NO_ECX
test_ecx_tofrom_data_select(void)549 static int test_ecx_tofrom_data_select(void)
550 {
551     int ret;
552     EVP_PKEY *key = NULL;
553 
554     ret = TEST_ptr(key = EVP_PKEY_Q_keygen(mainctx, NULL, "X25519"))
555           && TEST_true(do_pkey_tofrom_data_select(key, "X25519"));
556     EVP_PKEY_free(key);
557     return ret;
558 }
559 # endif
560 #endif
561 
562 #ifndef OPENSSL_NO_SM2
test_sm2_tofrom_data_select(void)563 static int test_sm2_tofrom_data_select(void)
564 {
565     int ret;
566     EVP_PKEY *key = NULL;
567 
568     ret = TEST_ptr(key = EVP_PKEY_Q_keygen(mainctx, NULL, "SM2"))
569           && TEST_true(do_pkey_tofrom_data_select(key, "SM2"));
570     EVP_PKEY_free(key);
571     return ret;
572 }
573 #endif
574 
test_rsa_tofrom_data_select(void)575 static int test_rsa_tofrom_data_select(void)
576 {
577     int ret;
578     EVP_PKEY *key = NULL;
579     const unsigned char *pdata = kExampleRSAKeyDER;
580     int pdata_len = sizeof(kExampleRSAKeyDER);
581 
582     ret = TEST_ptr(key = d2i_AutoPrivateKey_ex(NULL, &pdata, pdata_len,
583                                                mainctx, NULL))
584           && TEST_true(do_pkey_tofrom_data_select(key, "RSA"));
585     EVP_PKEY_free(key);
586     return ret;
587 }
588 
589 /* This is the equivalent of test_d2i_AutoPrivateKey in evp_extra_test */
test_d2i_AutoPrivateKey_ex(int i)590 static int test_d2i_AutoPrivateKey_ex(int i)
591 {
592     int ret = 0;
593     const unsigned char *p;
594     EVP_PKEY *pkey = NULL;
595     const APK_DATA *ak = &keydata[i];
596     const unsigned char *input = ak->kder;
597     size_t input_len = ak->size;
598     int expected_id = ak->evptype;
599     BIGNUM *p_bn = NULL;
600     BIGNUM *g_bn = NULL;
601     BIGNUM *priv_bn = NULL;
602 
603     p = input;
604     if (!TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &p, input_len, mainctx,
605                                                NULL))
606             || !TEST_ptr_eq(p, input + input_len)
607             || !TEST_int_eq(EVP_PKEY_get_id(pkey), expected_id))
608         goto done;
609 
610     if (ak->evptype == EVP_PKEY_RSA) {
611         if (!TEST_true(EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_RSA_D,
612                                              &priv_bn)))
613             goto done;
614     } else if (ak->evptype == EVP_PKEY_X25519) {
615         unsigned char buffer[32];
616         size_t len;
617 
618         if (!TEST_true(EVP_PKEY_get_octet_string_param(pkey,
619                                                        OSSL_PKEY_PARAM_PRIV_KEY,
620                                                        buffer, sizeof(buffer),
621                                                        &len)))
622             goto done;
623     } else {
624         if (!TEST_true(EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_PRIV_KEY,
625                                              &priv_bn)))
626             goto done;
627     }
628 
629     if (ak->evptype == EVP_PKEY_DH) {
630         if (!TEST_true(EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_FFC_P, &p_bn))
631             || !TEST_true(EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_FFC_G,
632                                                 &g_bn)))
633             goto done;
634     }
635 
636     ret = 1;
637 done:
638     BN_free(p_bn);
639     BN_free(g_bn);
640     BN_free(priv_bn);
641     EVP_PKEY_free(pkey);
642     return ret;
643 }
644 
645 #ifndef OPENSSL_NO_DES
test_pkcs8key_nid_bio(void)646 static int test_pkcs8key_nid_bio(void)
647 {
648     int ret;
649     const int nid = NID_pbe_WithSHA1And3_Key_TripleDES_CBC;
650     static const char pwd[] = "PASSWORD";
651     EVP_PKEY *pkey = NULL, *pkey_dec = NULL;
652     BIO *in = NULL, *enc_bio = NULL;
653     char *enc_data = NULL;
654     long enc_datalen = 0;
655     OSSL_PROVIDER *provider = NULL;
656 
657     ret = TEST_ptr(provider = OSSL_PROVIDER_load(NULL, "default"))
658           && TEST_ptr(enc_bio = BIO_new(BIO_s_mem()))
659           && TEST_ptr(in = BIO_new_mem_buf(kExampleRSAKeyPKCS8,
660                                            sizeof(kExampleRSAKeyPKCS8)))
661           && TEST_ptr(pkey = d2i_PrivateKey_ex_bio(in, NULL, NULL, NULL))
662           && TEST_int_eq(i2d_PKCS8PrivateKey_nid_bio(enc_bio, pkey, nid,
663                                                      pwd, sizeof(pwd) - 1,
664                                                      NULL, NULL), 1)
665           && TEST_int_gt(enc_datalen = BIO_get_mem_data(enc_bio, &enc_data), 0)
666           && TEST_ptr(pkey_dec = d2i_PKCS8PrivateKey_bio(enc_bio, NULL, NULL,
667                                                          (void *)pwd))
668           && TEST_true(EVP_PKEY_eq(pkey, pkey_dec));
669 
670     EVP_PKEY_free(pkey_dec);
671     EVP_PKEY_free(pkey);
672     BIO_free(in);
673     BIO_free(enc_bio);
674     OSSL_PROVIDER_unload(provider);
675     return ret;
676 }
677 #endif /* OPENSSL_NO_DES */
678 
test_alternative_default(void)679 static int test_alternative_default(void)
680 {
681     OSSL_LIB_CTX *oldctx;
682     EVP_MD *sha256;
683     int ok = 0;
684 
685     /*
686      * setup_tests() loaded the "null" provider in the current default, so
687      * we know this fetch should fail.
688      */
689     if (!TEST_ptr_null(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
690         goto err;
691 
692     /*
693      * Now we switch to our main library context, and try again.  Since no
694      * providers are loaded in this one, it should fall back to the default.
695      */
696     if (!TEST_ptr(oldctx = OSSL_LIB_CTX_set0_default(mainctx))
697         || !TEST_ptr(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
698         goto err;
699     EVP_MD_free(sha256);
700     sha256 = NULL;
701 
702     /*
703      * Switching back should give us our main library context back, and
704      * fetching SHA2-256 should fail again.
705      */
706     if (!TEST_ptr_eq(OSSL_LIB_CTX_set0_default(oldctx), mainctx)
707         || !TEST_ptr_null(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
708         goto err;
709 
710     ok = 1;
711  err:
712     EVP_MD_free(sha256);
713     return ok;
714 }
715 
test_provider_unload_effective(int testid)716 static int test_provider_unload_effective(int testid)
717 {
718     EVP_MD *sha256 = NULL;
719     OSSL_PROVIDER *provider = NULL;
720     int ok = 0;
721 
722     if (!TEST_ptr(provider = OSSL_PROVIDER_load(NULL, "default"))
723         || !TEST_ptr(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
724         goto err;
725 
726     if (testid > 0) {
727         OSSL_PROVIDER_unload(provider);
728         provider = NULL;
729         EVP_MD_free(sha256);
730         sha256 = NULL;
731     } else {
732         EVP_MD_free(sha256);
733         sha256 = NULL;
734         OSSL_PROVIDER_unload(provider);
735         provider = NULL;
736     }
737 
738     /*
739      * setup_tests() loaded the "null" provider in the current default, and
740      * we unloaded it above after the load so we know this fetch should fail.
741      */
742     if (!TEST_ptr_null(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
743         goto err;
744 
745     ok = 1;
746  err:
747     EVP_MD_free(sha256);
748     OSSL_PROVIDER_unload(provider);
749     return ok;
750 }
751 
test_d2i_PrivateKey_ex(int testid)752 static int test_d2i_PrivateKey_ex(int testid)
753 {
754     int ok = 0;
755     OSSL_PROVIDER *provider = NULL;
756     BIO *key_bio = NULL;
757     EVP_PKEY *pkey = NULL;
758     int id = (testid == 0) ? 0 : 2;
759 
760     if (!TEST_ptr(provider = OSSL_PROVIDER_load(NULL, "default")))
761         goto err;
762     if (!TEST_ptr(key_bio = BIO_new_mem_buf(keydata[id].kder, keydata[id].size)))
763         goto err;
764     if (!TEST_ptr_null(pkey = PEM_read_bio_PrivateKey(key_bio, NULL, NULL, NULL)))
765         goto err;
766 
767     ERR_clear_error();
768     if (!TEST_int_ge(BIO_seek(key_bio, 0), 0))
769         goto err;
770     ok = TEST_ptr(pkey = d2i_PrivateKey_bio(key_bio, NULL));
771     TEST_int_eq(ERR_peek_error(), 0);
772     test_openssl_errors();
773 
774  err:
775     EVP_PKEY_free(pkey);
776     BIO_free(key_bio);
777     OSSL_PROVIDER_unload(provider);
778 
779     return ok;
780 }
781 
test_PEM_read_bio_negative(int testid)782 static int test_PEM_read_bio_negative(int testid)
783 {
784     int ok = 0;
785     OSSL_PROVIDER *provider = NULL;
786     BIO *key_bio = NULL;
787     EVP_PKEY *pkey = NULL;
788 
789     if (!TEST_ptr(key_bio = BIO_new_mem_buf(keydata[testid].kder, keydata[testid].size)))
790         goto err;
791     ERR_clear_error();
792     if (!TEST_ptr_null(pkey = PEM_read_bio_PrivateKey(key_bio, NULL, NULL, NULL)))
793         goto err;
794     if (!TEST_int_ne(ERR_peek_error(), 0))
795         goto err;
796     if (!TEST_ptr(provider = OSSL_PROVIDER_load(NULL, "default")))
797         goto err;
798     if (!TEST_int_ge(BIO_seek(key_bio, 0), 0))
799         goto err;
800     ERR_clear_error();
801     if (!TEST_ptr_null(pkey = PEM_read_bio_PrivateKey(key_bio, NULL, NULL, NULL)))
802         goto err;
803     if (!TEST_int_ne(ERR_peek_error(), 0))
804         goto err;
805 
806     ok = 1;
807 
808  err:
809     test_openssl_errors();
810     EVP_PKEY_free(pkey);
811     BIO_free(key_bio);
812     OSSL_PROVIDER_unload(provider);
813 
814     return ok;
815 }
816 
test_PEM_read_bio_negative_wrong_password(int testid)817 static int test_PEM_read_bio_negative_wrong_password(int testid)
818 {
819     int ok = 0;
820     OSSL_PROVIDER *provider = OSSL_PROVIDER_load(NULL, "default");
821     EVP_PKEY *read_pkey = NULL;
822     EVP_PKEY *write_pkey = EVP_RSA_gen(1024);
823     BIO *key_bio = BIO_new(BIO_s_mem());
824     const UI_METHOD *undo_ui_method = NULL;
825     const UI_METHOD *ui_method = NULL;
826     if (testid > 0)
827         ui_method = UI_null();
828 
829     if (!TEST_ptr(provider))
830         goto err;
831     if (!TEST_ptr(key_bio))
832         goto err;
833     if (!TEST_ptr(write_pkey))
834         goto err;
835     undo_ui_method = UI_get_default_method();
836     UI_set_default_method(ui_method);
837 
838     if (/* Output Encrypted private key in PEM form */
839         !TEST_true(PEM_write_bio_PrivateKey(key_bio, write_pkey, EVP_aes_256_cbc(),
840                                            NULL, 0, NULL, "pass")))
841         goto err;
842 
843     ERR_clear_error();
844     read_pkey = PEM_read_bio_PrivateKey(key_bio, NULL, NULL, NULL);
845     if (!TEST_ptr_null(read_pkey))
846         goto err;
847 
848     if (!TEST_int_eq(ERR_GET_REASON(ERR_get_error()), PEM_R_PROBLEMS_GETTING_PASSWORD))
849         goto err;
850     ok = 1;
851 
852  err:
853     test_openssl_errors();
854     EVP_PKEY_free(read_pkey);
855     EVP_PKEY_free(write_pkey);
856     BIO_free(key_bio);
857     OSSL_PROVIDER_unload(provider);
858     UI_set_default_method(undo_ui_method);
859 
860     return ok;
861 }
862 
do_fromdata_key_is_equal(const OSSL_PARAM params[],const EVP_PKEY * expected,const char * type)863 static int do_fromdata_key_is_equal(const OSSL_PARAM params[],
864                                     const EVP_PKEY *expected, const char *type)
865 {
866     EVP_PKEY_CTX *ctx = NULL;
867     EVP_PKEY *pkey = NULL;
868     int ret;
869 
870     ret = TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(mainctx, type, NULL))
871           && TEST_int_eq(EVP_PKEY_fromdata_init(ctx), 1)
872           && TEST_int_eq(EVP_PKEY_fromdata(ctx, &pkey,
873                                            EVP_PKEY_KEYPAIR,
874                                            (OSSL_PARAM *)params), 1)
875           && TEST_true(EVP_PKEY_eq(pkey, expected));
876     EVP_PKEY_CTX_free(ctx);
877     EVP_PKEY_free(pkey);
878     return ret;
879 }
880 
881 #ifndef OPENSSL_NO_DSA
882 /*
883  * This data was generated using:
884  * > openssl genpkey \
885  *   -genparam -algorithm DSA -pkeyopt type:fips186_4 -text \
886  *   -pkeyopt gindex:5 -out dsa_param.pem
887  * > openssl genpkey \
888  *   -paramfile dsa_param.pem -pkeyopt type:fips186_4 -out dsa_priv.pem
889  */
890 static const unsigned char dsa_key[] = {
891     0x30, 0x82, 0x03, 0x4e, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x01, 0x00,
892     0xda, 0xb3, 0x46, 0x4d, 0x54, 0x57, 0xc7, 0xb4, 0x61, 0xa0, 0x6f, 0x66,
893     0x17, 0xda, 0xeb, 0x90, 0xf0, 0xa3, 0xd1, 0x29, 0xc9, 0x5f, 0xf2, 0x21,
894     0x3d, 0x85, 0xa3, 0x4a, 0xf0, 0xf8, 0x36, 0x39, 0x1b, 0xe3, 0xee, 0x37,
895     0x70, 0x06, 0x9b, 0xe8, 0xe3, 0x0a, 0xd2, 0xf1, 0xf6, 0xc4, 0x42, 0x23,
896     0x1f, 0x74, 0x78, 0xc2, 0x16, 0xf5, 0xce, 0xd6, 0xab, 0xa0, 0xc6, 0xe8,
897     0x99, 0x3d, 0xf8, 0x8b, 0xfb, 0x47, 0xf8, 0x5e, 0x05, 0x68, 0x6d, 0x8b,
898     0xa8, 0xad, 0xa1, 0xc2, 0x3a, 0x4e, 0xe0, 0xad, 0xec, 0x38, 0x75, 0x21,
899     0x55, 0x22, 0xce, 0xa2, 0xe9, 0xe5, 0x3b, 0xd7, 0x44, 0xeb, 0x5a, 0x03,
900     0x59, 0xa0, 0xc5, 0x7a, 0x92, 0x59, 0x7d, 0x7a, 0x07, 0x80, 0xfc, 0x4e,
901     0xf8, 0x56, 0x7e, 0xf1, 0x06, 0xe0, 0xba, 0xb2, 0xe7, 0x5b, 0x22, 0x55,
902     0xee, 0x4b, 0x42, 0x61, 0x67, 0x2c, 0x43, 0x9a, 0x38, 0x2b, 0x17, 0xc2,
903     0x62, 0x12, 0x8b, 0x0b, 0x22, 0x8c, 0x0c, 0x1c, 0x1c, 0x92, 0xb1, 0xec,
904     0x70, 0xce, 0x0f, 0x8c, 0xff, 0x8d, 0x21, 0xf9, 0x19, 0x68, 0x4d, 0x32,
905     0x59, 0x78, 0x42, 0x1d, 0x0c, 0xc5, 0x1a, 0xcb, 0x28, 0xe2, 0xc1, 0x1a,
906     0x35, 0xf1, 0x42, 0x0a, 0x19, 0x39, 0xfa, 0x83, 0xd1, 0xb4, 0xaa, 0x69,
907     0x0f, 0xc2, 0x8e, 0xf9, 0x59, 0x2c, 0xee, 0x11, 0xfc, 0x3e, 0x4b, 0x44,
908     0xfb, 0x9a, 0x32, 0xc8, 0x78, 0x23, 0x56, 0x85, 0x49, 0x21, 0x43, 0x12,
909     0x79, 0xbd, 0xa0, 0x70, 0x47, 0x2f, 0xae, 0xb6, 0xd7, 0x6c, 0xc6, 0x07,
910     0x76, 0xa9, 0x8a, 0xa2, 0x16, 0x02, 0x89, 0x1f, 0x1a, 0xd1, 0xa2, 0x96,
911     0x56, 0xd1, 0x1f, 0x10, 0xe1, 0xe5, 0x9f, 0x3f, 0xdd, 0x09, 0x0c, 0x40,
912     0x90, 0x71, 0xef, 0x14, 0x41, 0x02, 0x82, 0x3a, 0x6b, 0xe1, 0xf8, 0x2c,
913     0x5d, 0xbe, 0xfd, 0x1b, 0x02, 0x1d, 0x00, 0xe0, 0x20, 0xe0, 0x7c, 0x02,
914     0x16, 0xa7, 0x6c, 0x6a, 0x19, 0xba, 0xd5, 0x83, 0x73, 0xf3, 0x7d, 0x31,
915     0xef, 0xa7, 0xe1, 0x5d, 0x5b, 0x7f, 0xf3, 0xfc, 0xda, 0x84, 0x31, 0x02,
916     0x82, 0x01, 0x01, 0x00, 0x83, 0xdb, 0xa1, 0xbc, 0x3e, 0xc7, 0x29, 0xa5,
917     0x6a, 0x5c, 0x2c, 0xe8, 0x7a, 0x8c, 0x7e, 0xe8, 0xb8, 0x3e, 0x13, 0x47,
918     0xcd, 0x36, 0x7e, 0x79, 0x30, 0x7a, 0x28, 0x03, 0xd3, 0xd4, 0xd2, 0xe3,
919     0xee, 0x3b, 0x46, 0xda, 0xe0, 0x71, 0xe6, 0xcf, 0x46, 0x86, 0x0a, 0x37,
920     0x57, 0xb6, 0xe9, 0xcf, 0xa1, 0x78, 0x19, 0xb8, 0x72, 0x9f, 0x30, 0x8c,
921     0x2a, 0x04, 0x7c, 0x2f, 0x0c, 0x27, 0xa7, 0xb3, 0x23, 0xe0, 0x46, 0xf2,
922     0x75, 0x0c, 0x03, 0x4c, 0xad, 0xfb, 0xc1, 0xcb, 0x28, 0xcd, 0xa0, 0x63,
923     0xdb, 0x44, 0x88, 0xe0, 0xda, 0x6c, 0x5b, 0x89, 0xb2, 0x5b, 0x40, 0x6d,
924     0xeb, 0x78, 0x7a, 0xd5, 0xaf, 0x40, 0x52, 0x46, 0x63, 0x92, 0x13, 0x0d,
925     0xee, 0xee, 0xf9, 0x53, 0xca, 0x2d, 0x4e, 0x3b, 0x13, 0xd8, 0x0f, 0x50,
926     0xd0, 0x44, 0x57, 0x67, 0x0f, 0x45, 0x8f, 0x21, 0x30, 0x97, 0x9e, 0x80,
927     0xd9, 0xd0, 0x91, 0xb7, 0xc9, 0x5a, 0x69, 0xda, 0xeb, 0xd5, 0xea, 0x37,
928     0xf6, 0xb3, 0xbe, 0x1f, 0x24, 0xf1, 0x55, 0x14, 0x28, 0x05, 0xb5, 0xd8,
929     0x84, 0x0f, 0x62, 0x85, 0xaa, 0xec, 0x77, 0x64, 0xfd, 0x80, 0x7c, 0x41,
930     0x00, 0x88, 0xa3, 0x79, 0x7d, 0x4f, 0x6f, 0xe3, 0x76, 0xf4, 0xb5, 0x97,
931     0xb7, 0xeb, 0x67, 0x28, 0xba, 0x07, 0x1a, 0x59, 0x32, 0xc1, 0x53, 0xd9,
932     0x05, 0x6b, 0x63, 0x93, 0xce, 0xa1, 0xd9, 0x7a, 0xb2, 0xff, 0x1c, 0x12,
933     0x0a, 0x9a, 0xe5, 0x51, 0x1e, 0xba, 0xfc, 0x95, 0x2e, 0x28, 0xa9, 0xfc,
934     0x4c, 0xed, 0x7b, 0x05, 0xca, 0x67, 0xe0, 0x2d, 0xd7, 0x54, 0xb3, 0x05,
935     0x1c, 0x23, 0x2b, 0x35, 0x2e, 0x19, 0x48, 0x59, 0x0e, 0x58, 0xa8, 0x01,
936     0x56, 0xfb, 0x78, 0x90, 0xba, 0x08, 0x77, 0x94, 0x45, 0x05, 0x13, 0xc7,
937     0x6b, 0x96, 0xd2, 0xa3, 0xa6, 0x01, 0x9f, 0x34, 0x02, 0x82, 0x01, 0x00,
938     0x16, 0x1a, 0xb4, 0x6d, 0x9f, 0x16, 0x6c, 0xcc, 0x91, 0x66, 0xfe, 0x30,
939     0xeb, 0x8e, 0x44, 0xba, 0x2b, 0x7a, 0xc9, 0xa8, 0x95, 0xf2, 0xa6, 0x38,
940     0xd8, 0xaf, 0x3e, 0x91, 0x68, 0xe8, 0x52, 0xf3, 0x97, 0x37, 0x70, 0xf2,
941     0x47, 0xa3, 0xf4, 0x62, 0x26, 0xf5, 0x3b, 0x71, 0x52, 0x50, 0x15, 0x9c,
942     0x6d, 0xa6, 0x6d, 0x92, 0x4c, 0x48, 0x76, 0x31, 0x54, 0x48, 0xa5, 0x99,
943     0x7a, 0xd4, 0x61, 0xf7, 0x21, 0x44, 0xe7, 0xd8, 0x82, 0xc3, 0x50, 0xd3,
944     0xd9, 0xd4, 0x66, 0x20, 0xab, 0x70, 0x4c, 0x97, 0x9b, 0x8d, 0xac, 0x1f,
945     0x78, 0x27, 0x1e, 0x47, 0xf8, 0x3b, 0xd1, 0x55, 0x73, 0xf3, 0xb4, 0x8e,
946     0x6d, 0x45, 0x40, 0x54, 0xc6, 0xd8, 0x95, 0x15, 0x27, 0xb7, 0x5f, 0x65,
947     0xaa, 0xcb, 0x24, 0xc9, 0x49, 0x87, 0x32, 0xad, 0xcb, 0xf8, 0x35, 0x63,
948     0x56, 0x72, 0x7c, 0x4e, 0x6c, 0xad, 0x5f, 0x26, 0x8c, 0xd2, 0x80, 0x41,
949     0xaf, 0x88, 0x23, 0x20, 0x03, 0xa4, 0xd5, 0x3c, 0x53, 0x54, 0xb0, 0x3d,
950     0xed, 0x0e, 0x9e, 0x53, 0x0a, 0x63, 0x5f, 0xfd, 0x28, 0x57, 0x09, 0x07,
951     0x73, 0xf4, 0x0c, 0xd4, 0x71, 0x5d, 0x6b, 0xa0, 0xd7, 0x86, 0x99, 0x29,
952     0x9b, 0xca, 0xfb, 0xcc, 0xd6, 0x2f, 0xfe, 0xbe, 0x94, 0xef, 0x1a, 0x0e,
953     0x55, 0x84, 0xa7, 0xaf, 0x7b, 0xfa, 0xed, 0x77, 0x61, 0x28, 0x22, 0xee,
954     0x6b, 0x11, 0xdd, 0xb0, 0x17, 0x1e, 0x06, 0xe4, 0x29, 0x4c, 0xc2, 0x3f,
955     0xd6, 0x75, 0xb6, 0x08, 0x04, 0x55, 0x13, 0x48, 0x4f, 0x44, 0xea, 0x8d,
956     0xaf, 0xcb, 0xac, 0x22, 0xc4, 0x6a, 0xb3, 0x86, 0xe5, 0x47, 0xa9, 0xb5,
957     0x72, 0x17, 0x23, 0x11, 0x81, 0x7f, 0x00, 0x00, 0x67, 0x5c, 0xf4, 0x58,
958     0xcc, 0xe2, 0x46, 0xce, 0xf5, 0x6d, 0xd8, 0x18, 0x91, 0xc4, 0x20, 0xbf,
959     0x07, 0x48, 0x45, 0xfd, 0x02, 0x1c, 0x2f, 0x68, 0x44, 0xcb, 0xfb, 0x6b,
960     0xcb, 0x8d, 0x02, 0x49, 0x7c, 0xee, 0xd2, 0xa6, 0xd3, 0x43, 0xb8, 0xa4,
961     0x09, 0xb7, 0xc1, 0xd4, 0x4b, 0xc3, 0x66, 0xa7, 0xe0, 0x21,
962 };
963 static const unsigned char dsa_p[] = {
964     0x00, 0xda, 0xb3, 0x46, 0x4d, 0x54, 0x57, 0xc7, 0xb4, 0x61, 0xa0, 0x6f, 0x66, 0x17, 0xda,
965     0xeb, 0x90, 0xf0, 0xa3, 0xd1, 0x29, 0xc9, 0x5f, 0xf2, 0x21, 0x3d, 0x85, 0xa3, 0x4a, 0xf0,
966     0xf8, 0x36, 0x39, 0x1b, 0xe3, 0xee, 0x37, 0x70, 0x06, 0x9b, 0xe8, 0xe3, 0x0a, 0xd2, 0xf1,
967     0xf6, 0xc4, 0x42, 0x23, 0x1f, 0x74, 0x78, 0xc2, 0x16, 0xf5, 0xce, 0xd6, 0xab, 0xa0, 0xc6,
968     0xe8, 0x99, 0x3d, 0xf8, 0x8b, 0xfb, 0x47, 0xf8, 0x5e, 0x05, 0x68, 0x6d, 0x8b, 0xa8, 0xad,
969     0xa1, 0xc2, 0x3a, 0x4e, 0xe0, 0xad, 0xec, 0x38, 0x75, 0x21, 0x55, 0x22, 0xce, 0xa2, 0xe9,
970     0xe5, 0x3b, 0xd7, 0x44, 0xeb, 0x5a, 0x03, 0x59, 0xa0, 0xc5, 0x7a, 0x92, 0x59, 0x7d, 0x7a,
971     0x07, 0x80, 0xfc, 0x4e, 0xf8, 0x56, 0x7e, 0xf1, 0x06, 0xe0, 0xba, 0xb2, 0xe7, 0x5b, 0x22,
972     0x55, 0xee, 0x4b, 0x42, 0x61, 0x67, 0x2c, 0x43, 0x9a, 0x38, 0x2b, 0x17, 0xc2, 0x62, 0x12,
973     0x8b, 0x0b, 0x22, 0x8c, 0x0c, 0x1c, 0x1c, 0x92, 0xb1, 0xec, 0x70, 0xce, 0x0f, 0x8c, 0xff,
974     0x8d, 0x21, 0xf9, 0x19, 0x68, 0x4d, 0x32, 0x59, 0x78, 0x42, 0x1d, 0x0c, 0xc5, 0x1a, 0xcb,
975     0x28, 0xe2, 0xc1, 0x1a, 0x35, 0xf1, 0x42, 0x0a, 0x19, 0x39, 0xfa, 0x83, 0xd1, 0xb4, 0xaa,
976     0x69, 0x0f, 0xc2, 0x8e, 0xf9, 0x59, 0x2c, 0xee, 0x11, 0xfc, 0x3e, 0x4b, 0x44, 0xfb, 0x9a,
977     0x32, 0xc8, 0x78, 0x23, 0x56, 0x85, 0x49, 0x21, 0x43, 0x12, 0x79, 0xbd, 0xa0, 0x70, 0x47,
978     0x2f, 0xae, 0xb6, 0xd7, 0x6c, 0xc6, 0x07, 0x76, 0xa9, 0x8a, 0xa2, 0x16, 0x02, 0x89, 0x1f,
979     0x1a, 0xd1, 0xa2, 0x96, 0x56, 0xd1, 0x1f, 0x10, 0xe1, 0xe5, 0x9f, 0x3f, 0xdd, 0x09, 0x0c,
980     0x40, 0x90, 0x71, 0xef, 0x14, 0x41, 0x02, 0x82, 0x3a, 0x6b, 0xe1, 0xf8, 0x2c, 0x5d, 0xbe,
981     0xfd, 0x1b
982 };
983 static const unsigned char dsa_q[] = {
984     0x00, 0xe0, 0x20, 0xe0, 0x7c, 0x02, 0x16, 0xa7, 0x6c, 0x6a, 0x19, 0xba, 0xd5, 0x83, 0x73,
985     0xf3, 0x7d, 0x31, 0xef, 0xa7, 0xe1, 0x5d, 0x5b, 0x7f, 0xf3, 0xfc, 0xda, 0x84, 0x31
986 };
987 static const unsigned char dsa_g[] = {
988     0x00, 0x83, 0xdb, 0xa1, 0xbc, 0x3e, 0xc7, 0x29, 0xa5, 0x6a, 0x5c, 0x2c, 0xe8, 0x7a, 0x8c,
989     0x7e, 0xe8, 0xb8, 0x3e, 0x13, 0x47, 0xcd, 0x36, 0x7e, 0x79, 0x30, 0x7a, 0x28, 0x03, 0xd3,
990     0xd4, 0xd2, 0xe3, 0xee, 0x3b, 0x46, 0xda, 0xe0, 0x71, 0xe6, 0xcf, 0x46, 0x86, 0x0a, 0x37,
991     0x57, 0xb6, 0xe9, 0xcf, 0xa1, 0x78, 0x19, 0xb8, 0x72, 0x9f, 0x30, 0x8c, 0x2a, 0x04, 0x7c,
992     0x2f, 0x0c, 0x27, 0xa7, 0xb3, 0x23, 0xe0, 0x46, 0xf2, 0x75, 0x0c, 0x03, 0x4c, 0xad, 0xfb,
993     0xc1, 0xcb, 0x28, 0xcd, 0xa0, 0x63, 0xdb, 0x44, 0x88, 0xe0, 0xda, 0x6c, 0x5b, 0x89, 0xb2,
994     0x5b, 0x40, 0x6d, 0xeb, 0x78, 0x7a, 0xd5, 0xaf, 0x40, 0x52, 0x46, 0x63, 0x92, 0x13, 0x0d,
995     0xee, 0xee, 0xf9, 0x53, 0xca, 0x2d, 0x4e, 0x3b, 0x13, 0xd8, 0x0f, 0x50, 0xd0, 0x44, 0x57,
996     0x67, 0x0f, 0x45, 0x8f, 0x21, 0x30, 0x97, 0x9e, 0x80, 0xd9, 0xd0, 0x91, 0xb7, 0xc9, 0x5a,
997     0x69, 0xda, 0xeb, 0xd5, 0xea, 0x37, 0xf6, 0xb3, 0xbe, 0x1f, 0x24, 0xf1, 0x55, 0x14, 0x28,
998     0x05, 0xb5, 0xd8, 0x84, 0x0f, 0x62, 0x85, 0xaa, 0xec, 0x77, 0x64, 0xfd, 0x80, 0x7c, 0x41,
999     0x00, 0x88, 0xa3, 0x79, 0x7d, 0x4f, 0x6f, 0xe3, 0x76, 0xf4, 0xb5, 0x97, 0xb7, 0xeb, 0x67,
1000     0x28, 0xba, 0x07, 0x1a, 0x59, 0x32, 0xc1, 0x53, 0xd9, 0x05, 0x6b, 0x63, 0x93, 0xce, 0xa1,
1001     0xd9, 0x7a, 0xb2, 0xff, 0x1c, 0x12, 0x0a, 0x9a, 0xe5, 0x51, 0x1e, 0xba, 0xfc, 0x95, 0x2e,
1002     0x28, 0xa9, 0xfc, 0x4c, 0xed, 0x7b, 0x05, 0xca, 0x67, 0xe0, 0x2d, 0xd7, 0x54, 0xb3, 0x05,
1003     0x1c, 0x23, 0x2b, 0x35, 0x2e, 0x19, 0x48, 0x59, 0x0e, 0x58, 0xa8, 0x01, 0x56, 0xfb, 0x78,
1004     0x90, 0xba, 0x08, 0x77, 0x94, 0x45, 0x05, 0x13, 0xc7, 0x6b, 0x96, 0xd2, 0xa3, 0xa6, 0x01,
1005     0x9f, 0x34
1006 };
1007 static const unsigned char dsa_priv[] = {
1008     0x2f, 0x68, 0x44, 0xcb, 0xfb, 0x6b, 0xcb, 0x8d, 0x02, 0x49, 0x7c, 0xee, 0xd2, 0xa6, 0xd3,
1009     0x43, 0xb8, 0xa4, 0x09, 0xb7, 0xc1, 0xd4, 0x4b, 0xc3, 0x66, 0xa7, 0xe0, 0x21
1010 };
1011 static const unsigned char dsa_pub[] = {
1012     0x16, 0x1a, 0xb4, 0x6d, 0x9f, 0x16, 0x6c, 0xcc, 0x91, 0x66, 0xfe, 0x30, 0xeb, 0x8e, 0x44,
1013     0xba, 0x2b, 0x7a, 0xc9, 0xa8, 0x95, 0xf2, 0xa6, 0x38, 0xd8, 0xaf, 0x3e, 0x91, 0x68, 0xe8,
1014     0x52, 0xf3, 0x97, 0x37, 0x70, 0xf2, 0x47, 0xa3, 0xf4, 0x62, 0x26, 0xf5, 0x3b, 0x71, 0x52,
1015     0x50, 0x15, 0x9c, 0x6d, 0xa6, 0x6d, 0x92, 0x4c, 0x48, 0x76, 0x31, 0x54, 0x48, 0xa5, 0x99,
1016     0x7a, 0xd4, 0x61, 0xf7, 0x21, 0x44, 0xe7, 0xd8, 0x82, 0xc3, 0x50, 0xd3, 0xd9, 0xd4, 0x66,
1017     0x20, 0xab, 0x70, 0x4c, 0x97, 0x9b, 0x8d, 0xac, 0x1f, 0x78, 0x27, 0x1e, 0x47, 0xf8, 0x3b,
1018     0xd1, 0x55, 0x73, 0xf3, 0xb4, 0x8e, 0x6d, 0x45, 0x40, 0x54, 0xc6, 0xd8, 0x95, 0x15, 0x27,
1019     0xb7, 0x5f, 0x65, 0xaa, 0xcb, 0x24, 0xc9, 0x49, 0x87, 0x32, 0xad, 0xcb, 0xf8, 0x35, 0x63,
1020     0x56, 0x72, 0x7c, 0x4e, 0x6c, 0xad, 0x5f, 0x26, 0x8c, 0xd2, 0x80, 0x41, 0xaf, 0x88, 0x23,
1021     0x20, 0x03, 0xa4, 0xd5, 0x3c, 0x53, 0x54, 0xb0, 0x3d, 0xed, 0x0e, 0x9e, 0x53, 0x0a, 0x63,
1022     0x5f, 0xfd, 0x28, 0x57, 0x09, 0x07, 0x73, 0xf4, 0x0c, 0xd4, 0x71, 0x5d, 0x6b, 0xa0, 0xd7,
1023     0x86, 0x99, 0x29, 0x9b, 0xca, 0xfb, 0xcc, 0xd6, 0x2f, 0xfe, 0xbe, 0x94, 0xef, 0x1a, 0x0e,
1024     0x55, 0x84, 0xa7, 0xaf, 0x7b, 0xfa, 0xed, 0x77, 0x61, 0x28, 0x22, 0xee, 0x6b, 0x11, 0xdd,
1025     0xb0, 0x17, 0x1e, 0x06, 0xe4, 0x29, 0x4c, 0xc2, 0x3f, 0xd6, 0x75, 0xb6, 0x08, 0x04, 0x55,
1026     0x13, 0x48, 0x4f, 0x44, 0xea, 0x8d, 0xaf, 0xcb, 0xac, 0x22, 0xc4, 0x6a, 0xb3, 0x86, 0xe5,
1027     0x47, 0xa9, 0xb5, 0x72, 0x17, 0x23, 0x11, 0x81, 0x7f, 0x00, 0x00, 0x67, 0x5c, 0xf4, 0x58,
1028     0xcc, 0xe2, 0x46, 0xce, 0xf5, 0x6d, 0xd8, 0x18, 0x91, 0xc4, 0x20, 0xbf, 0x07, 0x48, 0x45,
1029     0xfd
1030 };
1031 
do_check_params(OSSL_PARAM key_params[],int expected)1032 static int do_check_params(OSSL_PARAM key_params[], int expected)
1033 {
1034     EVP_PKEY_CTX *gen_ctx = NULL, *check_ctx = NULL;
1035     EVP_PKEY *pkey = NULL;
1036     int ret;
1037 
1038     ret = TEST_ptr(gen_ctx = EVP_PKEY_CTX_new_from_name(mainctx, "DSA", NULL))
1039           && TEST_int_eq(EVP_PKEY_fromdata_init(gen_ctx), 1)
1040           && TEST_int_eq(EVP_PKEY_fromdata(gen_ctx, &pkey,
1041                                            EVP_PKEY_KEYPAIR, key_params), 1)
1042           && TEST_ptr(check_ctx = EVP_PKEY_CTX_new_from_pkey(mainctx, pkey,
1043                                                         NULL))
1044           && TEST_int_eq(EVP_PKEY_param_check(check_ctx), expected);
1045     EVP_PKEY_CTX_free(check_ctx);
1046     EVP_PKEY_CTX_free(gen_ctx);
1047     EVP_PKEY_free(pkey);
1048     return ret;
1049 }
1050 
do_check_bn(OSSL_PARAM params[],const char * key,const unsigned char * expected,size_t expected_len)1051 static int do_check_bn(OSSL_PARAM params[], const char *key,
1052                        const unsigned char *expected, size_t expected_len)
1053 {
1054     OSSL_PARAM *p;
1055     BIGNUM *bn = NULL;
1056     unsigned char buffer[256 + 1];
1057     int ret, len;
1058 
1059     ret = TEST_ptr(p = OSSL_PARAM_locate(params, key))
1060           && TEST_true(OSSL_PARAM_get_BN(p, &bn))
1061           && TEST_int_gt(len = BN_bn2binpad(bn, buffer, expected_len), 0)
1062           && TEST_mem_eq(expected, expected_len, buffer, len);
1063     BN_free(bn);
1064     return ret;
1065 }
1066 
do_check_int(OSSL_PARAM params[],const char * key,int expected)1067 static int do_check_int(OSSL_PARAM params[], const char *key, int expected)
1068 {
1069     OSSL_PARAM *p;
1070     int val = 0;
1071 
1072     return TEST_ptr(p = OSSL_PARAM_locate(params, key))
1073            && TEST_true(OSSL_PARAM_get_int(p, &val))
1074            && TEST_int_eq(val, expected);
1075 }
1076 
test_dsa_tofrom_data_select(void)1077 static int test_dsa_tofrom_data_select(void)
1078 {
1079     int ret;
1080     EVP_PKEY *key = NULL;
1081     const unsigned char *pkeydata = dsa_key;
1082 
1083     ret = TEST_ptr(key = d2i_AutoPrivateKey_ex(NULL, &pkeydata, sizeof(dsa_key),
1084                                                mainctx, NULL))
1085           && TEST_true(do_pkey_tofrom_data_select(key, "DSA"));
1086 
1087     EVP_PKEY_free(key);
1088     return ret;
1089 }
1090 
test_dsa_todata(void)1091 static int test_dsa_todata(void)
1092 {
1093     EVP_PKEY *pkey = NULL;
1094     OSSL_PARAM *to_params = NULL, *all_params = NULL;
1095     OSSL_PARAM gen_params[4];
1096     int ret = 0;
1097     const unsigned char *pkeydata = dsa_key;
1098 
1099     unsigned char dsa_seed[] = {
1100         0xbc, 0x8a, 0x81, 0x64, 0x9e, 0x9d, 0x63, 0xa7, 0xa3, 0x5d, 0x87, 0xdd,
1101         0x32, 0xf3, 0xc1, 0x9f, 0x18, 0x22, 0xeb, 0x73, 0x63, 0xad, 0x5e, 0x7b,
1102         0x90, 0xc1, 0xe3, 0xe0
1103     };
1104     int dsa_pcounter = 319;
1105     int dsa_gindex = 5;
1106 
1107     gen_params[0] = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_FFC_SEED,
1108                                                       (void*)dsa_seed,
1109                                                       sizeof(dsa_seed));
1110     gen_params[1] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_GINDEX,
1111                                              &dsa_gindex);
1112     gen_params[2] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_PCOUNTER,
1113                                              &dsa_pcounter);
1114     gen_params[3] = OSSL_PARAM_construct_end();
1115 
1116     if (!TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pkeydata, sizeof(dsa_key),
1117                                                mainctx, NULL))
1118         || !TEST_int_eq(EVP_PKEY_todata(pkey, EVP_PKEY_KEYPAIR, &to_params), 1)
1119         || !do_check_bn(to_params, OSSL_PKEY_PARAM_FFC_P, dsa_p, sizeof(dsa_p))
1120         || !do_check_bn(to_params, OSSL_PKEY_PARAM_FFC_Q, dsa_q, sizeof(dsa_q))
1121         || !do_check_bn(to_params, OSSL_PKEY_PARAM_FFC_G, dsa_g, sizeof(dsa_g))
1122         || !do_check_bn(to_params, OSSL_PKEY_PARAM_PUB_KEY, dsa_pub,
1123                         sizeof(dsa_pub))
1124         || !do_check_bn(to_params, OSSL_PKEY_PARAM_PRIV_KEY, dsa_priv,
1125                         sizeof(dsa_priv))
1126         || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_GINDEX, -1)
1127         || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_PCOUNTER, -1)
1128         || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_H, 0)
1129         || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_VALIDATE_PQ, 1)
1130         || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_VALIDATE_G, 1)
1131         || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_VALIDATE_LEGACY, 0)
1132         || !TEST_ptr_null(OSSL_PARAM_locate(to_params, OSSL_PKEY_PARAM_FFC_SEED)))
1133         goto err;
1134 
1135     if (!do_fromdata_key_is_equal(to_params, pkey, "DSA"))
1136         goto err;
1137 
1138     if (!TEST_ptr(all_params = OSSL_PARAM_merge(to_params, gen_params))
1139         || !do_check_params(all_params, 1))
1140         goto err;
1141     gen_params[1] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_GINDEX,
1142                                              &dsa_gindex);
1143     gen_params[2] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_PCOUNTER,
1144                                              &dsa_pcounter);
1145     /*
1146      * Check that modifying the shallow copy values used in OSSL_PARAM_merge()
1147      * results in an invalid key. This also verifies that the fips186-4
1148      * validation code is running.
1149      */
1150     dsa_gindex++;
1151     if (!do_check_params(all_params, 0))
1152         goto err;
1153     dsa_gindex--;
1154     dsa_pcounter++;
1155     if (!do_check_params(all_params, 0))
1156         goto err;
1157     dsa_pcounter--;
1158     dsa_seed[0] = 0xb0;
1159     if (!do_check_params(all_params, 0))
1160         goto err;
1161 
1162     ret = 1;
1163 err:
1164     EVP_PKEY_free(pkey);
1165     OSSL_PARAM_free(all_params);
1166     OSSL_PARAM_free(to_params);
1167     return ret;
1168 }
1169 
1170 /*
1171  * Test that OSSL_PKEY_PARAM_FFC_DIGEST_PROPS is set properly when using fromdata
1172  * This test:
1173  *   checks for failure when the property query is bad (tstid == 0)
1174  *   checks for success when the property query is valid (tstid == 1)
1175  */
test_dsa_fromdata_digest_prop(int tstid)1176 static int test_dsa_fromdata_digest_prop(int tstid)
1177 {
1178     EVP_PKEY_CTX *ctx = NULL, *gctx = NULL;
1179     EVP_PKEY *pkey = NULL,  *pkey2 = NULL;
1180     OSSL_PARAM params[4], *p = params;
1181     int ret = 0;
1182     int expected = (tstid == 0 ? 0 : 1);
1183     unsigned int pbits = 512; /* minimum allowed for speed */
1184 
1185     *p++ = OSSL_PARAM_construct_uint(OSSL_PKEY_PARAM_FFC_PBITS, &pbits);
1186     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_FFC_DIGEST, "SHA512", 0);
1187     /* Setting a bad prop query here should fail during paramgen - when it tries to do a fetch */
1188     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_FFC_DIGEST_PROPS,
1189                                             tstid == 0 ? "provider=unknown" : "provider=default", 0);
1190     *p++ = OSSL_PARAM_construct_end();
1191 
1192     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(mainctx, "DSA", NULL))
1193         || !TEST_int_eq(EVP_PKEY_fromdata_init(ctx), 1)
1194         || !TEST_int_eq(EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_KEY_PARAMETERS, params), 1))
1195         goto err;
1196 
1197     if (!TEST_ptr(gctx = EVP_PKEY_CTX_new_from_pkey(mainctx, pkey, NULL))
1198         || !TEST_int_eq(EVP_PKEY_paramgen_init(gctx), 1)
1199         || !TEST_int_eq(EVP_PKEY_paramgen(gctx, &pkey2), expected))
1200         goto err;
1201 
1202     ret = 1;
1203 err:
1204     EVP_PKEY_free(pkey2);
1205     EVP_PKEY_free(pkey);
1206     EVP_PKEY_CTX_free(ctx);
1207     EVP_PKEY_CTX_free(gctx);
1208     return ret;
1209 }
1210 #endif /* OPENSSL_NO_DSA */
1211 
test_pkey_todata_null(void)1212 static int test_pkey_todata_null(void)
1213 {
1214     OSSL_PARAM *params = NULL;
1215     EVP_PKEY *pkey = NULL;
1216     int ret = 0;
1217     const unsigned char *pdata = keydata[0].kder;
1218 
1219     ret = TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, keydata[0].size,
1220                                                 mainctx, NULL))
1221           && TEST_int_eq(EVP_PKEY_todata(NULL, EVP_PKEY_KEYPAIR, &params), 0)
1222           && TEST_int_eq(EVP_PKEY_todata(pkey, EVP_PKEY_KEYPAIR, NULL), 0);
1223     EVP_PKEY_free(pkey);
1224     return ret;
1225 }
1226 
1227 static OSSL_CALLBACK test_pkey_export_cb;
1228 
test_pkey_export_cb(const OSSL_PARAM params[],void * arg)1229 static int test_pkey_export_cb(const OSSL_PARAM params[], void *arg)
1230 {
1231     if (arg == NULL)
1232         return 0;
1233     return do_fromdata_key_is_equal(params, (EVP_PKEY *)arg, "RSA");
1234 }
1235 
test_pkey_export_null(void)1236 static int test_pkey_export_null(void)
1237 {
1238     EVP_PKEY *pkey = NULL;
1239     int ret = 0;
1240     const unsigned char *pdata = keydata[0].kder;
1241 
1242     ret = TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, keydata[0].size,
1243                                                 mainctx, NULL))
1244           && TEST_int_eq(EVP_PKEY_export(NULL, EVP_PKEY_KEYPAIR,
1245                                          test_pkey_export_cb, NULL), 0)
1246           && TEST_int_eq(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR, NULL, NULL), 0);
1247     EVP_PKEY_free(pkey);
1248     return ret;
1249 }
1250 
test_pkey_export(void)1251 static int test_pkey_export(void)
1252 {
1253     EVP_PKEY *pkey = NULL;
1254 #ifndef OPENSSL_NO_DEPRECATED_3_0
1255     RSA *rsa = NULL;
1256 #endif
1257     int ret = 1;
1258     const unsigned char *pdata = keydata[0].kder;
1259     int pdata_len = keydata[0].size;
1260 
1261     if (!TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, pdata_len,
1262                                                mainctx, NULL))
1263         || !TEST_true(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR,
1264                                        test_pkey_export_cb, pkey))
1265         || !TEST_false(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR,
1266                                        test_pkey_export_cb, NULL)))
1267         ret = 0;
1268     EVP_PKEY_free(pkey);
1269 
1270 #ifndef OPENSSL_NO_DEPRECATED_3_0
1271     /* Now, try with a legacy key */
1272     pdata = keydata[0].kder;
1273     pdata_len = keydata[0].size;
1274     if (!TEST_ptr(rsa = d2i_RSAPrivateKey(NULL, &pdata, pdata_len))
1275         || !TEST_ptr(pkey = EVP_PKEY_new())
1276         || !TEST_true(EVP_PKEY_assign_RSA(pkey, rsa))
1277         || !TEST_true(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR,
1278                                       test_pkey_export_cb, pkey))
1279         || !TEST_false(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR,
1280                                        test_pkey_export_cb, NULL)))
1281         ret = 0;
1282     EVP_PKEY_free(pkey);
1283 #endif
1284     return ret;
1285 }
1286 
test_rsa_pss_sign(void)1287 static int test_rsa_pss_sign(void)
1288 {
1289     EVP_PKEY *pkey = NULL;
1290     EVP_PKEY_CTX *pctx = NULL;
1291     int ret = 0;
1292     const unsigned char *pdata = keydata[0].kder;
1293     const char *mdname = "SHA2-256";
1294     OSSL_PARAM sig_params[3];
1295     unsigned char mdbuf[256 / 8] = { 0 };
1296     int padding = RSA_PKCS1_PSS_PADDING;
1297     unsigned char *sig = NULL;
1298     size_t sig_len = 0;
1299 
1300     sig_params[0] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_PAD_MODE,
1301                                              &padding);
1302     sig_params[1] = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
1303                                                      (char *)mdname, 0);
1304     sig_params[2] = OSSL_PARAM_construct_end();
1305 
1306     ret = TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, keydata[0].size,
1307                                                 mainctx, NULL))
1308           && TEST_ptr(pctx = EVP_PKEY_CTX_new_from_pkey(mainctx, pkey, NULL))
1309           && TEST_int_gt(EVP_PKEY_sign_init_ex(pctx, sig_params), 0)
1310           && TEST_int_gt(EVP_PKEY_sign(pctx, NULL, &sig_len, mdbuf,
1311                                        sizeof(mdbuf)), 0)
1312           && TEST_int_gt(sig_len, 0)
1313           && TEST_ptr(sig = OPENSSL_malloc(sig_len))
1314           && TEST_int_gt(EVP_PKEY_sign(pctx, sig, &sig_len, mdbuf,
1315                                        sizeof(mdbuf)), 0);
1316 
1317     EVP_PKEY_CTX_free(pctx);
1318     OPENSSL_free(sig);
1319     EVP_PKEY_free(pkey);
1320 
1321     return ret;
1322 }
1323 
test_evp_md_ctx_dup(void)1324 static int test_evp_md_ctx_dup(void)
1325 {
1326     EVP_MD_CTX *mdctx;
1327     EVP_MD_CTX *copyctx = NULL;
1328     int ret;
1329 
1330     /* test copying freshly initialized context */
1331     ret = TEST_ptr(mdctx = EVP_MD_CTX_new())
1332           && TEST_ptr(copyctx = EVP_MD_CTX_dup(mdctx));
1333 
1334     EVP_MD_CTX_free(mdctx);
1335     EVP_MD_CTX_free(copyctx);
1336     return ret;
1337 }
1338 
test_evp_md_ctx_copy(void)1339 static int test_evp_md_ctx_copy(void)
1340 {
1341     EVP_MD_CTX *mdctx = NULL;
1342     EVP_MD_CTX *copyctx = NULL;
1343     int ret;
1344 
1345     /* test copying freshly initialized context */
1346     ret = TEST_ptr(mdctx = EVP_MD_CTX_new())
1347           && TEST_ptr(copyctx = EVP_MD_CTX_new())
1348           && TEST_true(EVP_MD_CTX_copy_ex(copyctx, mdctx));
1349 
1350     EVP_MD_CTX_free(mdctx);
1351     EVP_MD_CTX_free(copyctx);
1352     return ret;
1353 }
1354 
test_evp_md_ctx_copy2(void)1355 static int test_evp_md_ctx_copy2(void)
1356 {
1357     int ret = 0;
1358     EVP_MD *md = NULL;
1359     OSSL_LIB_CTX *ctx = NULL;
1360     EVP_MD_CTX *inctx = NULL, *outctx = NULL;
1361     void *origin_algctx = NULL;
1362 
1363     if (!TEST_ptr(ctx = OSSL_LIB_CTX_new())
1364             || !TEST_ptr(md = EVP_MD_fetch(ctx, "sha256", NULL)))
1365         goto end;
1366 
1367     inctx = EVP_MD_CTX_new();
1368     outctx = EVP_MD_CTX_new();
1369 
1370     if (!TEST_ptr(inctx) || !TEST_ptr(outctx))
1371         goto end;
1372 
1373     /* init inctx and outctx, now the contexts are from same providers */
1374     if (!TEST_true(EVP_DigestInit_ex2(inctx, md, NULL)))
1375         goto end;
1376     if (!TEST_true(EVP_DigestInit_ex2(outctx, md, NULL)))
1377         goto end;
1378 
1379     /*
1380      * Test the EVP_MD_CTX_copy_ex function. After copying,
1381      * outctx->algctx should be the same as the original.
1382      */
1383     origin_algctx = outctx->algctx;
1384     ret = TEST_true(EVP_MD_CTX_copy_ex(outctx, inctx))
1385           && TEST_true(outctx->algctx == origin_algctx);
1386 
1387 end:
1388     EVP_MD_free(md);
1389     EVP_MD_CTX_free(inctx);
1390     EVP_MD_CTX_free(outctx);
1391     OSSL_LIB_CTX_free(ctx);
1392     return ret;
1393 }
1394 
1395 #if !defined OPENSSL_NO_DES && !defined OPENSSL_NO_MD5
test_evp_pbe_alg_add(void)1396 static int test_evp_pbe_alg_add(void)
1397 {
1398     int ret = 0;
1399     int cipher_nid = 0, md_nid = 0;
1400     EVP_PBE_KEYGEN_EX *keygen_ex = NULL;
1401     EVP_PBE_KEYGEN *keygen = NULL;
1402 
1403     if (!TEST_true(EVP_PBE_alg_add(NID_pbeWithMD5AndDES_CBC, EVP_des_cbc(), EVP_md5(),
1404                                    PKCS5_PBE_keyivgen)))
1405         goto err;
1406 
1407     if (!TEST_true(EVP_PBE_find_ex(EVP_PBE_TYPE_OUTER, NID_pbeWithMD5AndDES_CBC,
1408                                    &cipher_nid, &md_nid, &keygen, &keygen_ex)))
1409         goto err;
1410 
1411     if (!TEST_true(keygen != NULL))
1412         goto err;
1413     if (!TEST_true(keygen_ex == NULL))
1414         goto err;
1415 
1416     ret = 1;
1417 
1418 err:
1419     return ret;
1420 }
1421 #endif
1422 
1423 /*
1424  * Currently, EVP_<OBJ>_fetch doesn't support
1425  * colon separated alternative names for lookup
1426  * so add a test here to ensure that when one is provided
1427  * libcrypto returns an error
1428  */
evp_test_name_parsing(void)1429 static int evp_test_name_parsing(void)
1430 {
1431     EVP_MD *md;
1432 
1433     if (!TEST_ptr_null(md = EVP_MD_fetch(mainctx, "SHA256:BogusName", NULL))) {
1434         EVP_MD_free(md);
1435         return 0;
1436     }
1437 
1438     return 1;
1439 }
1440 
setup_tests(void)1441 int setup_tests(void)
1442 {
1443     if (!test_get_libctx(&mainctx, &nullprov, NULL, NULL, NULL)) {
1444         OSSL_LIB_CTX_free(mainctx);
1445         mainctx = NULL;
1446         return 0;
1447     }
1448 
1449     ADD_TEST(evp_test_name_parsing);
1450     ADD_TEST(test_alternative_default);
1451     ADD_ALL_TESTS(test_d2i_AutoPrivateKey_ex, OSSL_NELEM(keydata));
1452     ADD_TEST(test_new_keytype);
1453 #ifndef OPENSSL_NO_EC
1454     ADD_ALL_TESTS(test_d2i_PrivateKey_ex, 2);
1455     ADD_TEST(test_ec_tofrom_data_select);
1456 # ifndef OPENSSL_NO_ECX
1457     ADD_TEST(test_ecx_tofrom_data_select);
1458 # endif
1459     ADD_TEST(test_ec_d2i_i2d_pubkey);
1460 #else
1461     ADD_ALL_TESTS(test_d2i_PrivateKey_ex, 1);
1462 #endif
1463 #ifndef OPENSSL_NO_SM2
1464     ADD_TEST(test_sm2_tofrom_data_select);
1465 #endif
1466 #ifndef OPENSSL_NO_DSA
1467     ADD_TEST(test_dsa_todata);
1468     ADD_TEST(test_dsa_tofrom_data_select);
1469     ADD_ALL_TESTS(test_dsa_fromdata_digest_prop, 2);
1470 #endif
1471 #ifndef OPENSSL_NO_DH
1472     ADD_TEST(test_dh_tofrom_data_select);
1473     ADD_TEST(test_dh_paramgen);
1474     ADD_TEST(test_dh_paramfromdata);
1475 #endif
1476     ADD_TEST(test_rsa_tofrom_data_select);
1477 
1478     ADD_TEST(test_pkey_todata_null);
1479     ADD_TEST(test_pkey_export_null);
1480     ADD_TEST(test_pkey_export);
1481 #ifndef OPENSSL_NO_DES
1482     ADD_TEST(test_pkcs8key_nid_bio);
1483 #endif
1484     ADD_ALL_TESTS(test_PEM_read_bio_negative, OSSL_NELEM(keydata));
1485     ADD_ALL_TESTS(test_PEM_read_bio_negative_wrong_password, 2);
1486     ADD_TEST(test_rsa_pss_sign);
1487     ADD_TEST(test_evp_md_ctx_dup);
1488     ADD_TEST(test_evp_md_ctx_copy);
1489     ADD_TEST(test_evp_md_ctx_copy2);
1490     ADD_ALL_TESTS(test_provider_unload_effective, 2);
1491 #if !defined OPENSSL_NO_DES && !defined OPENSSL_NO_MD5
1492     ADD_TEST(test_evp_pbe_alg_add);
1493 #endif
1494     return 1;
1495 }
1496 
cleanup_tests(void)1497 void cleanup_tests(void)
1498 {
1499     OSSL_LIB_CTX_free(mainctx);
1500     OSSL_PROVIDER_unload(nullprov);
1501 }
1502