1 /*
2 * Copyright 2019-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 #include <stdio.h>
11 #include <stdlib.h>
12 #include <string.h>
13
14 #include "internal/nelem.h"
15 #include <openssl/crypto.h>
16 #include <openssl/bio.h>
17 #include <openssl/bn.h>
18 #include <openssl/rand.h>
19 #include <openssl/err.h>
20 #include <openssl/evp.h>
21 #include <openssl/ec.h>
22 #include "testutil.h"
23
24 #if defined(OPENSSL_NO_DH) && defined(OPENSSL_NO_DSA) && defined(OPENSSL_NO_EC)
25 #define OPENSSL_NO_KEYPARAMS
26 #endif
27
28 #ifndef OPENSSL_NO_KEYPARAMS
29
30 struct pubkey {
31 int bad;
32 const unsigned char *key_bin;
33 size_t key_bin_len;
34 };
35
36 #ifndef OPENSSL_NO_DH
37 static const unsigned char dhparam_bin[] = {
38 0x30, 0x82, 0x01, 0x08, 0x02, 0x82, 0x01, 0x01, 0x00, 0xc0, 0xd1, 0x2e, 0x14, 0x18, 0xbd, 0x03,
39 0xfd, 0x39, 0xe1, 0x99, 0xf4, 0x93, 0x06, 0x2d, 0x49, 0xc6, 0xb5, 0xb9, 0xf0, 0x91, 0xcb, 0x2f,
40 0x48, 0x54, 0x79, 0x7d, 0xc4, 0x65, 0x11, 0x55, 0xf7, 0x99, 0xde, 0x42, 0x83, 0x84, 0xc0, 0xf8,
41 0x88, 0x89, 0xa0, 0xff, 0xff, 0x7d, 0xe8, 0xef, 0x9e, 0xbc, 0xf7, 0x1d, 0x70, 0x6d, 0x3a, 0x33,
42 0x49, 0x28, 0xa1, 0xa3, 0xe1, 0x41, 0xc4, 0x8b, 0x91, 0xf9, 0xf2, 0xb6, 0xe2, 0x77, 0x79, 0x38,
43 0x7d, 0x21, 0xb3, 0xdf, 0x79, 0x9c, 0x5e, 0x65, 0x16, 0x00, 0x16, 0x82, 0xb2, 0x36, 0x46, 0x21,
44 0xac, 0xaf, 0x86, 0xc7, 0xe3, 0x10, 0x44, 0x48, 0xfb, 0xbd, 0xad, 0x4e, 0x11, 0x73, 0x4c, 0x25,
45 0xb0, 0x8c, 0x1c, 0x1e, 0x8e, 0x58, 0x50, 0x5e, 0x43, 0x89, 0xe4, 0xd9, 0x34, 0xf8, 0x3b, 0xcc,
46 0x36, 0x2c, 0x1b, 0xb3, 0xb2, 0x77, 0x0c, 0xa5, 0x96, 0xc1, 0x8a, 0x38, 0xd4, 0xe3, 0x9c, 0x2a,
47 0xde, 0x49, 0x46, 0xc7, 0xd4, 0xa2, 0x47, 0xc9, 0x0a, 0xbd, 0x84, 0xd4, 0x1c, 0xbc, 0xb6, 0x19,
48 0x04, 0x94, 0x64, 0xfa, 0x8a, 0x11, 0x9c, 0x5f, 0x4a, 0x4c, 0x0f, 0x58, 0x81, 0x02, 0xbf, 0xcf,
49 0x87, 0x27, 0x2b, 0xae, 0x8e, 0xe2, 0x61, 0x7a, 0xdb, 0xba, 0x23, 0x39, 0x25, 0x44, 0xdc, 0x22,
50 0x75, 0xc3, 0x28, 0xd9, 0x12, 0x33, 0x84, 0x32, 0xd4, 0x5d, 0xd9, 0x77, 0xf8, 0x04, 0x90, 0x38,
51 0x0a, 0xec, 0x84, 0x93, 0x43, 0xce, 0xe7, 0x07, 0x42, 0x7d, 0x2d, 0xe0, 0x21, 0x3b, 0x19, 0x22,
52 0xa7, 0x8f, 0x50, 0x31, 0xda, 0xd0, 0x0d, 0xd3, 0x0b, 0xdb, 0xad, 0xed, 0x94, 0x92, 0xff, 0x83,
53 0x06, 0x7f, 0x7f, 0xd7, 0x7b, 0x42, 0x5b, 0xba, 0x93, 0x7a, 0xeb, 0x43, 0x5f, 0xce, 0x59, 0x26,
54 0xe8, 0x76, 0xdc, 0xee, 0xe2, 0xbe, 0x36, 0x7a, 0x83, 0x02, 0x01, 0x02
55 };
56 static const unsigned char dhkey_1[] = {
57 0x7a, 0x49, 0xcb, 0xc3, 0x25, 0x67, 0x7a, 0x61,
58 0xd0, 0x60, 0x81, 0x0f, 0xf6, 0xbd, 0x38, 0x82,
59 0xe7, 0x38, 0x8c, 0xe9, 0xd1, 0x04, 0x33, 0xbf,
60 0x8a, 0x03, 0x63, 0xb3, 0x05, 0x04, 0xb5, 0x1f,
61 0xba, 0x9f, 0x1a, 0x5f, 0x31, 0x3e, 0x96, 0x79,
62 0x88, 0x7d, 0x3f, 0x59, 0x6d, 0x3b, 0xf3, 0x2f,
63 0xf2, 0xa6, 0x43, 0x48, 0x64, 0x5a, 0x6a, 0x32,
64 0x1f, 0x24, 0x37, 0x62, 0x54, 0x3a, 0x7d, 0xab,
65 0x26, 0x77, 0x7c, 0xec, 0x57, 0x3c, 0xa4, 0xbd,
66 0x96, 0x9d, 0xaa, 0x3b, 0x0e, 0x9a, 0x55, 0x7e,
67 0x1d, 0xb4, 0x47, 0x5b, 0xea, 0x20, 0x3c, 0x6d,
68 0xbe, 0xd6, 0x70, 0x7d, 0xa8, 0x9e, 0x84, 0xb4,
69 0x03, 0x52, 0xf2, 0x08, 0x4c, 0x98, 0xd3, 0x4f,
70 0x58, 0xb3, 0xdf, 0xb4, 0xe6, 0xdc, 0x2c, 0x43,
71 0x55, 0xd1, 0xce, 0x2a, 0xb3, 0xfc, 0xe0, 0x29,
72 0x97, 0xd8, 0xd8, 0x62, 0xc6, 0x87, 0x0a, 0x1b,
73 0xfd, 0x72, 0x74, 0xe0, 0xa9, 0xfb, 0xfa, 0x91,
74 0xf2, 0xc1, 0x09, 0x93, 0xea, 0x63, 0xf6, 0x9a,
75 0x4b, 0xdf, 0x4e, 0xdf, 0x6b, 0xf9, 0xeb, 0xf6,
76 0x66, 0x3c, 0xfd, 0x6f, 0x68, 0xcb, 0xdb, 0x6e,
77 0x40, 0x65, 0xf7, 0xf2, 0x46, 0xe5, 0x0d, 0x9a,
78 0xd9, 0x6f, 0xcf, 0x28, 0x22, 0x8f, 0xca, 0x0b,
79 0x30, 0xa0, 0x9e, 0xa5, 0x13, 0xba, 0x72, 0x7f,
80 0x85, 0x3d, 0x02, 0x9c, 0x97, 0x8e, 0x6f, 0xea,
81 0x6d, 0x35, 0x4e, 0xd1, 0x78, 0x7d, 0x73, 0x60,
82 0x92, 0xa9, 0x12, 0xf4, 0x2a, 0xac, 0x17, 0x97,
83 0xf3, 0x7b, 0x79, 0x08, 0x69, 0xd1, 0x9e, 0xb5,
84 0xf8, 0x2a, 0x0a, 0x2b, 0x00, 0x7b, 0x16, 0x8d,
85 0x41, 0x82, 0x3a, 0x72, 0x58, 0x57, 0x80, 0x65,
86 0xae, 0x17, 0xbc, 0x3a, 0x5b, 0x7e, 0x5c, 0x2d,
87 0xae, 0xb2, 0xc2, 0x26, 0x20, 0x9a, 0xaa, 0x57,
88 0x4b, 0x7d, 0x43, 0x41, 0x96, 0x3f, 0xf0, 0x0d
89 };
90 /* smaller but still valid key */
91 static const unsigned char dhkey_2[] = {
92 0x73, 0xb2, 0x22, 0x91, 0x27, 0xb9, 0x45, 0xb0,
93 0xfd, 0x17, 0x66, 0x79, 0x9b, 0x32, 0x71, 0x92,
94 0x97, 0x1d, 0x70, 0x02, 0x37, 0x70, 0x79, 0x63,
95 0xed, 0x11, 0x22, 0xe9, 0xe6, 0xf8, 0xeb, 0xd7,
96 0x90, 0x00, 0xe6, 0x5c, 0x47, 0x02, 0xfb, 0x13,
97 0xca, 0x29, 0x14, 0x1e, 0xf4, 0x61, 0x58, 0xf6,
98 0xaa, 0xbb, 0xcf, 0xa7, 0x82, 0x9a, 0x9e, 0x7c,
99 0x4a, 0x05, 0x42, 0xed, 0x55, 0xd8, 0x08, 0x37,
100 0x06, 0x49, 0x9b, 0xda, 0xb3, 0xb9, 0xc9, 0xc0,
101 0x56, 0x26, 0xda, 0x60, 0x1d, 0xbc, 0x06, 0x0b,
102 0xb0, 0x94, 0x4b, 0x4e, 0x95, 0xf9, 0xb4, 0x2f,
103 0x4e, 0xad, 0xf8, 0xab, 0x2d, 0x19, 0xa2, 0xe6,
104 0x6d, 0x11, 0xfd, 0x9b, 0x5a, 0x2a, 0xb0, 0x81,
105 0x42, 0x4d, 0x86, 0x76, 0xd5, 0x9e, 0xaf, 0xf9,
106 0x6f, 0x79, 0xab, 0x1d, 0xfe, 0xd8, 0xc8, 0xba,
107 0xb6, 0xce, 0x03, 0x61, 0x48, 0x53, 0xd8, 0x0b,
108 0x83, 0xf0, 0xb0, 0x46, 0xa0, 0xea, 0x46, 0x60,
109 0x7a, 0x39, 0x4e, 0x46, 0x6a, 0xbb, 0x07, 0x6c,
110 0x8c, 0x7d, 0xb7, 0x7d, 0x5b, 0xe5, 0x24, 0xa5,
111 0xab, 0x41, 0x8a, 0xc4, 0x63, 0xf9, 0xce, 0x20,
112 0x6f, 0x58, 0x4f, 0x0e, 0x42, 0x82, 0x9e, 0x17,
113 0x53, 0xa6, 0xd6, 0x42, 0x3e, 0x80, 0x66, 0x6f,
114 0x2a, 0x1c, 0x30, 0x08, 0x01, 0x99, 0x5a, 0x4f,
115 0x72, 0x16, 0xed, 0xb0, 0xd6, 0x8c, 0xf0, 0x7a,
116 0x33, 0x15, 0xc4, 0x95, 0x65, 0xba, 0x11, 0x37,
117 0xa0, 0xcc, 0xe7, 0x45, 0x65, 0x4f, 0x17, 0x0a,
118 0x2c, 0x62, 0xc0, 0x65, 0x3b, 0x65, 0x2a, 0x56,
119 0xf7, 0x29, 0x8a, 0x9b, 0x1b, 0xbb, 0x0c, 0x40,
120 0xcd, 0x66, 0x4b, 0x4f, 0x2f, 0xba, 0xdb, 0x59,
121 0x93, 0x6d, 0x34, 0xf3, 0x8d, 0xde, 0x68, 0x99,
122 0x78, 0xfc, 0xac, 0x95, 0xd9, 0xa3, 0x74, 0xe6,
123 0x24, 0x96, 0x98, 0x6f, 0x64, 0x71, 0x76
124 };
125 /* 1 is not a valid key */
126 static const unsigned char dhkey_3[] = {
127 0x01
128 };
129 #endif
130
131 #ifndef OPENSSL_NO_DSA
132 static const unsigned char dsaparam_bin[] = {
133 0x30, 0x82, 0x02, 0x28, 0x02, 0x82, 0x01, 0x01, 0x00, 0xf2, 0x85, 0x01, 0xa5, 0xb9, 0x56, 0x65,
134 0x19, 0xff, 0x9a, 0x7d, 0xf9, 0x90, 0xd6, 0xaa, 0x73, 0xac, 0xf7, 0x94, 0xfa, 0x8a, 0x64, 0x6d,
135 0xa0, 0x01, 0x42, 0xe5, 0x45, 0xfc, 0x53, 0x72, 0xb0, 0x7c, 0xe6, 0x3b, 0xfb, 0x09, 0x33, 0x41,
136 0x27, 0xbd, 0x00, 0xb5, 0x18, 0x87, 0x62, 0xa8, 0x2b, 0xfc, 0xd0, 0x52, 0x4a, 0x14, 0x2d, 0xaa,
137 0x36, 0xc6, 0xf3, 0xa9, 0xe3, 0x90, 0x1b, 0x74, 0xdf, 0x0a, 0x6d, 0x33, 0xba, 0xf4, 0x32, 0x6d,
138 0xba, 0x36, 0x68, 0x1d, 0x83, 0x36, 0x50, 0xc6, 0x62, 0xc0, 0x40, 0x67, 0x0e, 0xf6, 0x22, 0x00,
139 0x62, 0x1b, 0x76, 0x72, 0x62, 0x5f, 0xa0, 0xdf, 0x38, 0xb1, 0x1d, 0x26, 0x70, 0x9b, 0x84, 0x64,
140 0xbb, 0x16, 0x15, 0xc2, 0x66, 0xb9, 0x97, 0xd0, 0x07, 0xf1, 0x4b, 0x70, 0x02, 0x03, 0xf1, 0xd2,
141 0x03, 0xdb, 0x78, 0x8b, 0xb4, 0xda, 0x6f, 0x3c, 0xe2, 0x31, 0xa8, 0x1c, 0x99, 0xea, 0x9c, 0x75,
142 0x28, 0x96, 0x82, 0x16, 0x77, 0xac, 0x79, 0x32, 0x61, 0x87, 0xec, 0xb7, 0xb4, 0xc3, 0xea, 0x12,
143 0x62, 0x1f, 0x08, 0xb8, 0x16, 0xab, 0xcc, 0xef, 0x28, 0xdf, 0x06, 0x07, 0xbe, 0xb0, 0xdc, 0x78,
144 0x83, 0x8a, 0x70, 0x80, 0x34, 0xe6, 0x91, 0xe3, 0xd3, 0x92, 0xd9, 0xf4, 0x56, 0x53, 0x52, 0xb7,
145 0x35, 0xf6, 0x2a, 0xec, 0x4b, 0xcb, 0xa2, 0x3c, 0xc3, 0x0c, 0x94, 0xa7, 0x4e, 0x1c, 0x42, 0x9c,
146 0x72, 0x99, 0x60, 0x8c, 0xfe, 0xfb, 0x60, 0x57, 0x75, 0xf5, 0x23, 0x11, 0x12, 0xba, 0x97, 0xcd,
147 0xad, 0x5a, 0x0b, 0xa6, 0x1f, 0x6a, 0x48, 0x2e, 0x8d, 0xda, 0x95, 0xc6, 0x0e, 0x14, 0xde, 0xf7,
148 0x22, 0x55, 0xa8, 0x6b, 0x25, 0xdf, 0xa2, 0xab, 0x33, 0x65, 0x56, 0xfc, 0x78, 0x4f, 0x62, 0xdf,
149 0x48, 0xdd, 0xce, 0x8b, 0xe1, 0x76, 0xf4, 0xf6, 0x7f, 0x02, 0x1d, 0x00, 0xac, 0xb0, 0xb8, 0x92,
150 0x3b, 0x6b, 0x61, 0xcf, 0x36, 0x6d, 0xf2, 0x1e, 0x5d, 0xe0, 0x7b, 0xf5, 0x73, 0x48, 0xa3, 0x8b,
151 0x86, 0x9e, 0x88, 0xce, 0x40, 0xf8, 0x27, 0x6d, 0x02, 0x82, 0x01, 0x00, 0x77, 0x6b, 0x89, 0xd6,
152 0x8f, 0x3d, 0xce, 0x52, 0x30, 0x74, 0xb2, 0xa1, 0x13, 0x96, 0xd5, 0x92, 0xf2, 0xf1, 0x6b, 0x10,
153 0x31, 0x0b, 0xf3, 0x69, 0xaa, 0xbf, 0x4b, 0x6c, 0xcb, 0x3f, 0x6d, 0x58, 0x76, 0x44, 0x09, 0xf9,
154 0x28, 0xef, 0xa0, 0xe4, 0x55, 0x77, 0x57, 0xe0, 0xfb, 0xcc, 0x9a, 0x6a, 0x2c, 0x90, 0xec, 0x72,
155 0x24, 0x0b, 0x43, 0xc5, 0xbc, 0x31, 0xed, 0x1a, 0x46, 0x2c, 0x76, 0x42, 0x9e, 0xc0, 0x82, 0xfc,
156 0xff, 0xf9, 0x7e, 0xe2, 0x1f, 0x39, 0xf3, 0x3b, 0xdb, 0x27, 0x36, 0xe7, 0xf5, 0x3b, 0xc2, 0x23,
157 0xb6, 0xd0, 0xcf, 0x5b, 0x85, 0x2e, 0x1b, 0x00, 0x5b, 0x31, 0xaa, 0x72, 0x8f, 0x37, 0xee, 0x56,
158 0x71, 0xc4, 0xfd, 0x3c, 0x8d, 0xfa, 0x5b, 0xab, 0xb1, 0xa9, 0x52, 0x76, 0xa0, 0xe4, 0xe3, 0x78,
159 0x83, 0x64, 0x5d, 0xd7, 0x6c, 0xec, 0x9b, 0x40, 0x65, 0xe2, 0x0a, 0x11, 0x19, 0x60, 0xdd, 0xce,
160 0x29, 0x9f, 0xc6, 0x1d, 0x0a, 0xab, 0x8e, 0x59, 0x25, 0xc5, 0x0b, 0x9c, 0x02, 0x45, 0xba, 0x99,
161 0x74, 0x22, 0x1d, 0xc1, 0x57, 0xca, 0x50, 0x8c, 0x5e, 0xdf, 0xd8, 0x5d, 0x43, 0xae, 0x06, 0x28,
162 0x29, 0x82, 0xf6, 0x5a, 0xa9, 0x51, 0xa2, 0x04, 0x1d, 0xbf, 0x88, 0x15, 0x98, 0xce, 0x8a, 0xb4,
163 0x3b, 0xe5, 0x30, 0x29, 0xce, 0x0c, 0x9b, 0xf8, 0xdb, 0xbf, 0x06, 0x9f, 0xd0, 0x59, 0x18, 0xd4,
164 0x0b, 0x94, 0xbf, 0xe9, 0x67, 0x6b, 0x9e, 0xf0, 0x72, 0xc6, 0xbf, 0x79, 0x8f, 0x1e, 0xa3, 0x95,
165 0x24, 0xe3, 0xcb, 0x58, 0xb5, 0x67, 0xd3, 0xae, 0x79, 0xb0, 0x28, 0x9c, 0x9a, 0xd0, 0xa4, 0xe7,
166 0x22, 0x15, 0xc1, 0x8b, 0x04, 0xb9, 0x8a, 0xa8, 0xb7, 0x1b, 0x62, 0x44, 0xc6, 0xef, 0x4b, 0x74,
167 0xd0, 0xfd, 0xa9, 0xb4, 0x4e, 0xdd, 0x7d, 0x38, 0x60, 0xd1, 0x40, 0xcd
168 };
169 #endif
170
171 #ifndef OPENSSL_NO_EC
172 static const unsigned char ecparam_bin[] = {
173 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07
174 };
175 static const unsigned char eckey_1[] = {
176 0x04, 0xc8, 0x65, 0x45, 0x63, 0x73, 0xe5, 0x0a,
177 0x61, 0x1d, 0xcf, 0x60, 0x76, 0x2c, 0xe7, 0x36,
178 0x0b, 0x76, 0xc2, 0x92, 0xfc, 0xa4, 0x56, 0xee,
179 0xc2, 0x62, 0x05, 0x00, 0x80, 0xe4, 0x4f, 0x07,
180 0x3b, 0xf4, 0x59, 0xb8, 0xc3, 0xb3, 0x1f, 0x77,
181 0x36, 0x16, 0x4c, 0x72, 0x2a, 0xc0, 0x89, 0x89,
182 0xd6, 0x16, 0x14, 0xee, 0x2f, 0x5a, 0xde, 0x9e,
183 0x83, 0xc5, 0x78, 0xd0, 0x0b, 0x69, 0xb4, 0xb9,
184 0xf1
185 };
186 /* a modified key */
187 static const unsigned char eckey_2[] = {
188 0x04, 0xc8, 0x65, 0x45, 0x63, 0x73, 0xe5, 0x0a,
189 0x61, 0x1d, 0xcf, 0x60, 0x76, 0x2c, 0xe7, 0x36,
190 0x0b, 0x77, 0xc2, 0x92, 0xfc, 0xa4, 0x56, 0xee,
191 0xc2, 0x62, 0x05, 0x00, 0x80, 0xe4, 0x4f, 0x07,
192 0x3b, 0xf4, 0x59, 0xb8, 0xc3, 0xb3, 0x1f, 0x77,
193 0x36, 0x16, 0x4c, 0x72, 0x2a, 0xc0, 0x89, 0x89,
194 0xd6, 0x16, 0x14, 0xee, 0x2f, 0x5a, 0xde, 0x9e,
195 0x83, 0xc5, 0x78, 0xd0, 0x0b, 0x69, 0xb4, 0xb9,
196 0xf1
197 };
198 /* an added byte */
199 static const unsigned char eckey_3[] = {
200 0x04, 0xc8, 0x65, 0x45, 0x63, 0x73, 0xe5, 0x0a,
201 0x61, 0x1d, 0xcf, 0x60, 0x76, 0x2c, 0xe7, 0x36,
202 0x0b, 0x76, 0xc2, 0x92, 0xfc, 0xa4, 0x56, 0xee,
203 0xc2, 0x62, 0x05, 0x00, 0x80, 0xe4, 0x4f, 0x07,
204 0x3b, 0xf4, 0x59, 0xb8, 0xc3, 0xb3, 0x1f, 0x77,
205 0x36, 0x16, 0x4c, 0x72, 0x2a, 0xc0, 0x89, 0x89,
206 0xd6, 0x16, 0x14, 0xee, 0x2f, 0x5a, 0xde, 0x9e,
207 0x83, 0xc5, 0x78, 0xd0, 0x0b, 0x69, 0xb4, 0xb9,
208 0xf1, 0xaa
209 };
210 #endif
211
212 #define NUM_KEYS 10
213
214 static const struct {
215 int type;
216 const unsigned char *param_bin;
217 size_t param_bin_len;
218 struct pubkey keys[NUM_KEYS];
219 } pkey_params[] = {
220 #ifndef OPENSSL_NO_DH
221 { EVP_PKEY_DH, dhparam_bin, sizeof(dhparam_bin),
222 { { 0, dhkey_1, sizeof(dhkey_1) },
223 { 0, dhkey_2, sizeof(dhkey_2) },
224 { 1, dhkey_3, sizeof(dhkey_3) },
225 { 1, dhkey_1, 0 },
226 { 1, dhparam_bin, sizeof(dhparam_bin) } } },
227 #endif
228 #ifndef OPENSSL_NO_DSA
229 { EVP_PKEY_DSA, dsaparam_bin, sizeof(dsaparam_bin) },
230 #endif
231 #ifndef OPENSSL_NO_EC
232 { EVP_PKEY_EC, ecparam_bin, sizeof(ecparam_bin),
233 { { 0, eckey_1, sizeof(eckey_1) },
234 { 1, eckey_2, sizeof(eckey_2) },
235 { 1, eckey_3, sizeof(eckey_3) },
236 { 1, eckey_1, 0 },
237 { 1, eckey_1, sizeof(eckey_1) - 1 } } }
238 #endif
239 };
240
params_bio_test(int id)241 static int params_bio_test(int id)
242 {
243 int ret, out_len;
244 BIO *in = NULL, *out = NULL;
245 EVP_PKEY *in_key = NULL, *out_key = NULL;
246 unsigned char *out_bin;
247 int type = pkey_params[id].type;
248
249 ret = TEST_ptr(in = BIO_new_mem_buf(pkey_params[id].param_bin,
250 (int)pkey_params[id].param_bin_len))
251 /* Load in pkey params from binary */
252 && TEST_ptr(d2i_KeyParams_bio(type, &in_key, in))
253 && TEST_ptr(out = BIO_new(BIO_s_mem()))
254 /* Save pkey params to binary */
255 && TEST_int_gt(i2d_KeyParams_bio(out, in_key), 0)
256 /* test the output binary is the expected value */
257 && TEST_int_gt(out_len = BIO_get_mem_data(out, &out_bin), 0)
258 && TEST_mem_eq(pkey_params[id].param_bin,
259 (int)pkey_params[id].param_bin_len,
260 out_bin, out_len);
261
262 BIO_free(in);
263 BIO_free(out);
264 EVP_PKEY_free(in_key);
265 EVP_PKEY_free(out_key);
266 return ret;
267 }
268
set_enc_pubkey_test(int id)269 static int set_enc_pubkey_test(int id)
270 {
271 int ret, i;
272 BIO *in = NULL;
273 EVP_PKEY *in_key = NULL;
274 int type = pkey_params[id].type;
275 const struct pubkey *keys = pkey_params[id].keys;
276
277 if (keys[0].key_bin == NULL)
278 return TEST_skip("Not applicable test");
279
280 ret = TEST_ptr(in = BIO_new_mem_buf(pkey_params[id].param_bin,
281 (int)pkey_params[id].param_bin_len))
282 /* Load in pkey params from binary */
283 && TEST_ptr(d2i_KeyParams_bio(type, &in_key, in));
284
285 for (i = 0; ret && i < NUM_KEYS && keys[i].key_bin != NULL; i++) {
286 if (keys[i].bad) {
287 ERR_set_mark();
288 ret = ret
289 && TEST_int_le(EVP_PKEY_set1_encoded_public_key(in_key,
290 keys[i].key_bin,
291 keys[i].key_bin_len),
292 0);
293 ERR_pop_to_mark();
294 } else {
295 ret = ret
296 && TEST_int_gt(EVP_PKEY_set1_encoded_public_key(in_key,
297 keys[i].key_bin,
298 keys[i].key_bin_len),
299 0);
300 }
301 if (!ret)
302 TEST_info("Test key index #%d", i);
303 }
304
305 BIO_free(in);
306 EVP_PKEY_free(in_key);
307 return ret;
308 }
309 #endif
310
setup_tests(void)311 int setup_tests(void)
312 {
313 #ifdef OPENSSL_NO_KEYPARAMS
314 TEST_note("No DH/DSA/EC support");
315 #else
316 ADD_ALL_TESTS(params_bio_test, OSSL_NELEM(pkey_params));
317 ADD_ALL_TESTS(set_enc_pubkey_test, OSSL_NELEM(pkey_params));
318 #endif
319 return 1;
320 }
321