Debian Codegraph @

regress/unittests/kex/test_kex.c

raw
1 /* $OpenBSD: test_kex.c,v 1.12 2025/08/21 05:55:30 djm Exp $ */
2 /*
3 * Regress test KEX
4 *
5 * Placed in the public domain
6 */
7
8 #include "includes.h"
9
10 #include <sys/types.h>
11 #include <sys/time.h>
12 #include <stdio.h>
13 #include <stdint.h>
14 #include <stdlib.h>
15 #include <string.h>
16
17 #include "../test_helper/test_helper.h"
18
19 #include "ssherr.h"
20 #include "ssh_api.h"
21 #include "sshbuf.h"
22 #include "packet.h"
23 #include "myproposal.h"
24 #include "log.h"
25
26 void kex_tests(void);
27 static int do_debug = 0;
28
29 static int
30 do_send_and_receive(struct ssh *from, struct ssh *to)
31 {
32 u_char type;
33 size_t len;
34 const u_char *buf;
35 int r;
36
37 for (;;) {
38 if ((r = ssh_packet_next(from, &type)) != 0) {
39 fprintf(stderr, "ssh_packet_next: %s\n", ssh_err(r));
40 return r;
41 }
42 if (type != 0)
43 return 0;
44 buf = ssh_output_ptr(from, &len);
45 if (do_debug)
46 printf("%zu", len);
47 if (len == 0)
48 return 0;
49 if ((r = ssh_output_consume(from, len)) != 0 ||
50 (r = ssh_input_append(to, buf, len)) != 0)
51 return r;
52 }
53 }
54
55 static void
56 run_kex(struct ssh *client, struct ssh *server)
57 {
58 int r = 0;
59
60 while (!server->kex->done || !client->kex->done) {
61 if (do_debug)
62 printf(" S:");
63 if ((r = do_send_and_receive(server, client)))
64 break;
65 if (do_debug)
66 printf(" C:");
67 if ((r = do_send_and_receive(client, server)))
68 break;
69 }
70 if (do_debug)
71 printf("done: %s\n", ssh_err(r));
72 ASSERT_INT_EQ(r, 0);
73 ASSERT_INT_EQ(server->kex->done, 1);
74 ASSERT_INT_EQ(client->kex->done, 1);
75 }
76
77 static void
78 do_kex_with_key(char *kex, char *cipher, char *mac,
79 struct sshkey *key, int keytype, int bits)
80 {
81 struct ssh *client = NULL, *server = NULL, *server2 = NULL;
82 struct sshkey *private, *public;
83 struct sshbuf *state;
84 struct kex_params kex_params;
85 char *myproposal[PROPOSAL_MAX] = { KEX_CLIENT };
86 char *keyname = NULL;
87
88 if (key != NULL) {
89 private = key;
90 keytype = key->type;
91 } else {
92 TEST_START("sshkey_generate");
93 ASSERT_INT_EQ(sshkey_generate(keytype, bits, &private), 0);
94 TEST_DONE();
95 }
96
97 TEST_START("sshkey_from_private");
98 ASSERT_INT_EQ(sshkey_from_private(private, &public), 0);
99 TEST_DONE();
100
101 TEST_START("ssh_init");
102 memcpy(kex_params.proposal, myproposal, sizeof(myproposal));
103 if (kex != NULL)
104 kex_params.proposal[PROPOSAL_KEX_ALGS] = kex;
105 if (cipher != NULL) {
106 kex_params.proposal[PROPOSAL_ENC_ALGS_CTOS] = cipher;
107 kex_params.proposal[PROPOSAL_ENC_ALGS_STOC] = cipher;
108 }
109 if (mac != NULL) {
110 kex_params.proposal[PROPOSAL_MAC_ALGS_CTOS] = mac;
111 kex_params.proposal[PROPOSAL_MAC_ALGS_STOC] = mac;
112 }
113 keyname = strdup(sshkey_ssh_name(private));
114 ASSERT_PTR_NE(keyname, NULL);
115 kex_params.proposal[PROPOSAL_SERVER_HOST_KEY_ALGS] = keyname;
116 ASSERT_INT_EQ(ssh_init(&client, 0, &kex_params), 0);
117 ASSERT_INT_EQ(ssh_init(&server, 1, &kex_params), 0);
118 ASSERT_PTR_NE(client, NULL);
119 ASSERT_PTR_NE(server, NULL);
120 TEST_DONE();
121
122 TEST_START("ssh_add_hostkey");
123 ASSERT_INT_EQ(ssh_add_hostkey(server, private), 0);
124 ASSERT_INT_EQ(ssh_add_hostkey(client, public), 0);
125 TEST_DONE();
126
127 TEST_START("kex");
128 run_kex(client, server);
129 TEST_DONE();
130
131 TEST_START("rekeying client");
132 ASSERT_INT_EQ(kex_send_kexinit(client), 0);
133 run_kex(client, server);
134 TEST_DONE();
135
136 TEST_START("rekeying server");
137 ASSERT_INT_EQ(kex_send_kexinit(server), 0);
138 run_kex(client, server);
139 TEST_DONE();
140
141 TEST_START("ssh_packet_get_state");
142 state = sshbuf_new();
143 ASSERT_PTR_NE(state, NULL);
144 ASSERT_INT_EQ(ssh_packet_get_state(server, state), 0);
145 ASSERT_INT_GE(sshbuf_len(state), 1);
146 TEST_DONE();
147
148 TEST_START("ssh_packet_set_state");
149 server2 = NULL;
150 ASSERT_INT_EQ(ssh_init(&server2, 1, NULL), 0);
151 ASSERT_PTR_NE(server2, NULL);
152 ASSERT_INT_EQ(ssh_add_hostkey(server2, private), 0);
153 ASSERT_INT_EQ(ssh_packet_set_state(server2, state), 0);
154 ASSERT_INT_EQ(sshbuf_len(state), 0);
155 sshbuf_free(state);
156 ASSERT_PTR_NE(server2->kex, NULL);
157 /* XXX we need to set the callbacks */
158 #ifdef WITH_OPENSSL
159 server2->kex->kex[KEX_DH_GRP1_SHA1] = kex_gen_server;
160 server2->kex->kex[KEX_DH_GRP14_SHA1] = kex_gen_server;
161 server2->kex->kex[KEX_DH_GEX_SHA1] = kexgex_server;
162 server2->kex->kex[KEX_DH_GEX_SHA256] = kexgex_server;
163 server2->kex->kex[KEX_DH_GRP14_SHA256] = kex_gen_server;
164 server2->kex->kex[KEX_DH_GRP16_SHA512] = kex_gen_server;
165 server2->kex->kex[KEX_DH_GRP18_SHA512] = kex_gen_server;
166 #ifdef OPENSSL_HAS_ECC
167 server2->kex->kex[KEX_ECDH_SHA2] = kex_gen_server;
168 #endif /* OPENSSL_HAS_ECC */
169 #endif /* WITH_OPENSSL */
170 server2->kex->kex[KEX_C25519_SHA256] = kex_gen_server;
171 server2->kex->kex[KEX_KEM_SNTRUP761X25519_SHA512] = kex_gen_server;
172 server2->kex->kex[KEX_KEM_MLKEM768X25519_SHA256] = kex_gen_server;
173 server2->kex->load_host_public_key = server->kex->load_host_public_key;
174 server2->kex->load_host_private_key = server->kex->load_host_private_key;
175 server2->kex->sign = server->kex->sign;
176 TEST_DONE();
177
178 TEST_START("rekeying server2");
179 ASSERT_INT_EQ(kex_send_kexinit(server2), 0);
180 run_kex(client, server2);
181 ASSERT_INT_EQ(kex_send_kexinit(client), 0);
182 run_kex(client, server2);
183 TEST_DONE();
184
185 TEST_START("cleanup");
186 if (key == NULL)
187 sshkey_free(private);
188 sshkey_free(public);
189 ssh_free(client);
190 ssh_free(server);
191 ssh_free(server2);
192 free(keyname);
193 TEST_DONE();
194 }
195
196 static void
197 do_kex(char *kex)
198 {
199 struct sshkey *key = NULL;
200 char name[256];
201
202 if (test_is_benchmark()) {
203 snprintf(name, sizeof(name), "generate %s", kex);
204 TEST_START(name);
205 ASSERT_INT_EQ(sshkey_generate(KEY_ED25519, 0, &key), 0);
206 TEST_DONE();
207 snprintf(name, sizeof(name), "KEX %s", kex);
208 BENCH_START(name);
209 /*
210 * NB. use a cipher/MAC here that requires minimal bits from
211 * the KEX to avoid DH-GEX taking forever.
212 */
213 do_kex_with_key(kex, "aes128-ctr", "hmac-sha2-256", key,
214 KEY_ED25519, 256);
215 BENCH_FINISH("kex");
216 sshkey_free(key);
217 return;
218 }
219
220 #ifdef WITH_OPENSSL
221 do_kex_with_key(kex, NULL, NULL, NULL, KEY_RSA, 2048);
222 # ifdef OPENSSL_HAS_ECC
223 do_kex_with_key(kex, NULL, NULL, NULL, KEY_ECDSA, 256);
224 # endif /* OPENSSL_HAS_ECC */
225 #endif /* WITH_OPENSSL */
226 do_kex_with_key(kex, NULL, NULL, NULL, KEY_ED25519, 256);
227 }
228
229 void
230 kex_tests(void)
231 {
232 do_kex("curve25519-sha256");
233 #ifdef WITH_OPENSSL
234 #ifdef OPENSSL_HAS_ECC
235 do_kex("ecdh-sha2-nistp256");
236 do_kex("ecdh-sha2-nistp384");
237 do_kex("ecdh-sha2-nistp521");
238 #endif /* OPENSSL_HAS_ECC */
239 do_kex("diffie-hellman-group-exchange-sha256");
240 do_kex("diffie-hellman-group-exchange-sha1");
241 do_kex("diffie-hellman-group14-sha1");
242 do_kex("diffie-hellman-group1-sha1");
243 if (test_is_benchmark()) {
244 do_kex("diffie-hellman-group14-sha256");
245 do_kex("diffie-hellman-group16-sha512");
246 do_kex("diffie-hellman-group18-sha512");
247 }
248 # ifdef USE_MLKEM768X25519
249 do_kex("mlkem768x25519-sha256");
250 # endif /* USE_MLKEM768X25519 */
251 # ifdef USE_SNTRUP761X25519
252 do_kex("sntrup761x25519-sha512");
253 # endif /* USE_SNTRUP761X25519 */
254 #endif /* WITH_OPENSSL */
255 }