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, ¶ms), 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