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