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