1 /* $OpenBSD: kexfuzz.c,v 1.3 2016/10/11 21:49:54 djm Exp $ */
2 /*
3 * Fuzz harness for KEX code
4 *
5 * Placed in the public domain
6 */
7
8 #include "includes.h"
9
10 #include <sys/types.h>
11 #include <sys/param.h>
12 #include <stdio.h>
13 #ifdef HAVE_STDINT_H
14 # include <stdint.h>
15 #endif
16 #include <stdlib.h>
17 #include <string.h>
18 #include <unistd.h>
19 #include <fcntl.h>
20 #ifdef HAVE_ERR_H
21 # include <err.h>
22 #endif
23
24 #include "ssherr.h"
25 #include "ssh_api.h"
26 #include "sshbuf.h"
27 #include "packet.h"
28 #include "myproposal.h"
29 #include "authfile.h"
30 #include "log.h"
31
32 struct ssh *active_state = NULL; /* XXX - needed for linking */
33
34 void kex_tests(void);
35 static int do_debug = 0;
36
37 enum direction { S2C, C2S };
38
39 struct hook_ctx {
40 struct ssh *client, *server, *server2;
41 int *c2s, *s2c;
42 int trigger_direction, packet_index;
43 const char *dump_path;
44 struct sshbuf *replace_data;
45 };
46
47 static int
packet_hook(struct ssh * ssh,struct sshbuf * packet,u_char * typep,void * _ctx)48 packet_hook(struct ssh *ssh, struct sshbuf *packet, u_char *typep, void *_ctx)
49 {
50 struct hook_ctx *ctx = (struct hook_ctx *)_ctx;
51 int mydirection = ssh == ctx->client ? S2C : C2S;
52 int *packet_count = mydirection == S2C ? ctx->s2c : ctx->c2s;
53 FILE *dumpfile;
54 int r;
55
56 if (do_debug) {
57 printf("%s packet %d type %u:\n",
58 mydirection == S2C ? "s2c" : "c2s",
59 *packet_count, *typep);
60 sshbuf_dump(packet, stdout);
61 }
62 if (mydirection == ctx->trigger_direction &&
63 ctx->packet_index == *packet_count) {
64 if (ctx->replace_data != NULL) {
65 sshbuf_reset(packet);
66 /* Type is first byte of packet */
67 if ((r = sshbuf_get_u8(ctx->replace_data,
68 typep)) != 0 ||
69 (r = sshbuf_putb(packet, ctx->replace_data)) != 0)
70 return r;
71 if (do_debug) {
72 printf("***** replaced packet type %u\n",
73 *typep);
74 sshbuf_dump(packet, stdout);
75 }
76 } else if (ctx->dump_path != NULL) {
77 if ((dumpfile = fopen(ctx->dump_path, "w+")) == NULL)
78 err(1, "fopen %s", ctx->dump_path);
79 /* Write { type, packet } */
80 if (fwrite(typep, 1, 1, dumpfile) != 1)
81 err(1, "fwrite type %s", ctx->dump_path);
82 if (sshbuf_len(packet) != 0 &&
83 fwrite(sshbuf_ptr(packet), sshbuf_len(packet),
84 1, dumpfile) != 1)
85 err(1, "fwrite body %s", ctx->dump_path);
86 if (do_debug) {
87 printf("***** dumped packet type %u len %zu\n",
88 *typep, sshbuf_len(packet));
89 }
90 fclose(dumpfile);
91 /* No point in continuing */
92 exit(0);
93 }
94 }
95 (*packet_count)++;
96 return 0;
97 }
98
99 static int
do_send_and_receive(struct ssh * from,struct ssh * to)100 do_send_and_receive(struct ssh *from, struct ssh *to)
101 {
102 u_char type;
103 size_t len;
104 const u_char *buf;
105 int r;
106
107 for (;;) {
108 if ((r = ssh_packet_next(from, &type)) != 0) {
109 fprintf(stderr, "ssh_packet_next: %s\n", ssh_err(r));
110 return r;
111 }
112
113 if (type != 0)
114 return 0;
115 buf = ssh_output_ptr(from, &len);
116 if (len == 0)
117 return 0;
118 if ((r = ssh_input_append(to, buf, len)) != 0) {
119 debug("ssh_input_append: %s", ssh_err(r));
120 return r;
121 }
122 if ((r = ssh_output_consume(from, len)) != 0) {
123 debug("ssh_output_consume: %s", ssh_err(r));
124 return r;
125 }
126 }
127 }
128
129 /* Minimal test_helper.c scaffholding to make this standalone */
130 const char *in_test = NULL;
131 #define TEST_START(a) \
132 do { \
133 in_test = (a); \
134 if (do_debug) \
135 fprintf(stderr, "test %s starting\n", in_test); \
136 } while (0)
137 #define TEST_DONE() \
138 do { \
139 if (do_debug) \
140 fprintf(stderr, "test %s done\n", \
141 in_test ? in_test : "???"); \
142 in_test = NULL; \
143 } while(0)
144 #define ASSERT_INT_EQ(a, b) \
145 do { \
146 if ((int)(a) != (int)(b)) { \
147 fprintf(stderr, "%s %s:%d " \
148 "%s (%d) != expected %s (%d)\n", \
149 in_test ? in_test : "(none)", \
150 __func__, __LINE__, #a, (int)(a), #b, (int)(b)); \
151 exit(2); \
152 } \
153 } while (0)
154 #define ASSERT_INT_GE(a, b) \
155 do { \
156 if ((int)(a) < (int)(b)) { \
157 fprintf(stderr, "%s %s:%d " \
158 "%s (%d) < expected %s (%d)\n", \
159 in_test ? in_test : "(none)", \
160 __func__, __LINE__, #a, (int)(a), #b, (int)(b)); \
161 exit(2); \
162 } \
163 } while (0)
164 #define ASSERT_PTR_NE(a, b) \
165 do { \
166 if ((a) == (b)) { \
167 fprintf(stderr, "%s %s:%d " \
168 "%s (%p) != expected %s (%p)\n", \
169 in_test ? in_test : "(none)", \
170 __func__, __LINE__, #a, (a), #b, (b)); \
171 exit(2); \
172 } \
173 } while (0)
174
175
176 static void
run_kex(struct ssh * client,struct ssh * server)177 run_kex(struct ssh *client, struct ssh *server)
178 {
179 int r = 0;
180
181 while (!server->kex->done || !client->kex->done) {
182 if ((r = do_send_and_receive(server, client)) != 0) {
183 debug("do_send_and_receive S2C: %s", ssh_err(r));
184 break;
185 }
186 if ((r = do_send_and_receive(client, server)) != 0) {
187 debug("do_send_and_receive C2S: %s", ssh_err(r));
188 break;
189 }
190 }
191 if (do_debug)
192 printf("done: %s\n", ssh_err(r));
193 ASSERT_INT_EQ(r, 0);
194 ASSERT_INT_EQ(server->kex->done, 1);
195 ASSERT_INT_EQ(client->kex->done, 1);
196 }
197
198 static void
do_kex_with_key(const char * kex,struct sshkey * prvkey,int * c2s,int * s2c,int direction,int packet_index,const char * dump_path,struct sshbuf * replace_data)199 do_kex_with_key(const char *kex, struct sshkey *prvkey, int *c2s, int *s2c,
200 int direction, int packet_index,
201 const char *dump_path, struct sshbuf *replace_data)
202 {
203 struct ssh *client = NULL, *server = NULL, *server2 = NULL;
204 struct sshkey *pubkey = NULL;
205 struct sshbuf *state;
206 struct kex_params kex_params;
207 char *myproposal[PROPOSAL_MAX] = { KEX_CLIENT };
208 char *keyname = NULL;
209 struct hook_ctx hook_ctx;
210
211 TEST_START("sshkey_from_private");
212 ASSERT_INT_EQ(sshkey_from_private(prvkey, &pubkey), 0);
213 TEST_DONE();
214
215 TEST_START("ssh_init");
216 memcpy(kex_params.proposal, myproposal, sizeof(myproposal));
217 if (kex != NULL)
218 kex_params.proposal[PROPOSAL_KEX_ALGS] = strdup(kex);
219 keyname = strdup(sshkey_ssh_name(prvkey));
220 ASSERT_PTR_NE(keyname, NULL);
221 kex_params.proposal[PROPOSAL_SERVER_HOST_KEY_ALGS] = keyname;
222 ASSERT_INT_EQ(ssh_init(&client, 0, &kex_params), 0);
223 ASSERT_INT_EQ(ssh_init(&server, 1, &kex_params), 0);
224 ASSERT_INT_EQ(ssh_init(&server2, 1, NULL), 0);
225 ASSERT_PTR_NE(client, NULL);
226 ASSERT_PTR_NE(server, NULL);
227 ASSERT_PTR_NE(server2, NULL);
228 TEST_DONE();
229
230 hook_ctx.c2s = c2s;
231 hook_ctx.s2c = s2c;
232 hook_ctx.trigger_direction = direction;
233 hook_ctx.packet_index = packet_index;
234 hook_ctx.dump_path = dump_path;
235 hook_ctx.replace_data = replace_data;
236 hook_ctx.client = client;
237 hook_ctx.server = server;
238 hook_ctx.server2 = server2;
239 ssh_packet_set_input_hook(client, packet_hook, &hook_ctx);
240 ssh_packet_set_input_hook(server, packet_hook, &hook_ctx);
241 ssh_packet_set_input_hook(server2, packet_hook, &hook_ctx);
242
243 TEST_START("ssh_add_hostkey");
244 ASSERT_INT_EQ(ssh_add_hostkey(server, prvkey), 0);
245 ASSERT_INT_EQ(ssh_add_hostkey(client, pubkey), 0);
246 TEST_DONE();
247
248 TEST_START("kex");
249 run_kex(client, server);
250 TEST_DONE();
251
252 TEST_START("rekeying client");
253 ASSERT_INT_EQ(kex_send_kexinit(client), 0);
254 run_kex(client, server);
255 TEST_DONE();
256
257 TEST_START("rekeying server");
258 ASSERT_INT_EQ(kex_send_kexinit(server), 0);
259 run_kex(client, server);
260 TEST_DONE();
261
262 TEST_START("ssh_packet_get_state");
263 state = sshbuf_new();
264 ASSERT_PTR_NE(state, NULL);
265 ASSERT_INT_EQ(ssh_packet_get_state(server, state), 0);
266 ASSERT_INT_GE(sshbuf_len(state), 1);
267 TEST_DONE();
268
269 TEST_START("ssh_packet_set_state");
270 ASSERT_INT_EQ(ssh_add_hostkey(server2, prvkey), 0);
271 kex_free(server2->kex); /* XXX or should ssh_packet_set_state()? */
272 ASSERT_INT_EQ(ssh_packet_set_state(server2, state), 0);
273 ASSERT_INT_EQ(sshbuf_len(state), 0);
274 sshbuf_free(state);
275 ASSERT_PTR_NE(server2->kex, NULL);
276 /* XXX we need to set the callbacks */
277 #ifdef WITH_OPENSSL
278 server2->kex->kex[KEX_DH_GRP1_SHA1] = kexdh_server;
279 server2->kex->kex[KEX_DH_GRP14_SHA1] = kexdh_server;
280 server2->kex->kex[KEX_DH_GRP14_SHA256] = kexdh_server;
281 server2->kex->kex[KEX_DH_GRP16_SHA512] = kexdh_server;
282 server2->kex->kex[KEX_DH_GRP18_SHA512] = kexdh_server;
283 server2->kex->kex[KEX_DH_GEX_SHA1] = kexgex_server;
284 server2->kex->kex[KEX_DH_GEX_SHA256] = kexgex_server;
285 # ifdef OPENSSL_HAS_ECC
286 server2->kex->kex[KEX_ECDH_SHA2] = kexecdh_server;
287 # endif
288 #endif
289 server2->kex->kex[KEX_C25519_SHA256] = kexc25519_server;
290 server2->kex->load_host_public_key = server->kex->load_host_public_key;
291 server2->kex->load_host_private_key = server->kex->load_host_private_key;
292 server2->kex->sign = server->kex->sign;
293 TEST_DONE();
294
295 TEST_START("rekeying server2");
296 ASSERT_INT_EQ(kex_send_kexinit(server2), 0);
297 run_kex(client, server2);
298 ASSERT_INT_EQ(kex_send_kexinit(client), 0);
299 run_kex(client, server2);
300 TEST_DONE();
301
302 TEST_START("cleanup");
303 sshkey_free(pubkey);
304 ssh_free(client);
305 ssh_free(server);
306 ssh_free(server2);
307 free(keyname);
308 TEST_DONE();
309 }
310
311 static void
usage(void)312 usage(void)
313 {
314 fprintf(stderr,
315 "Usage: kexfuzz [-hcdrv] [-D direction] [-f data_file]\n"
316 " [-K kex_alg] [-k private_key] [-i packet_index]\n"
317 "\n"
318 "Options:\n"
319 " -h Display this help\n"
320 " -c Count packets sent during KEX\n"
321 " -d Dump mode: record KEX packet to data file\n"
322 " -r Replace mode: replace packet with data file\n"
323 " -v Turn on verbose logging\n"
324 " -D S2C|C2S Packet direction for replacement or dump\n"
325 " -f data_file Path to data file for replacement or dump\n"
326 " -K kex_alg Name of KEX algorithm to test (see below)\n"
327 " -k private_key Path to private key file\n"
328 " -i packet_index Index of packet to replace or dump (from 0)\n"
329 "\n"
330 "Available KEX algorithms: %s\n", kex_alg_list(' '));
331 }
332
333 static void
badusage(const char * bad)334 badusage(const char *bad)
335 {
336 fprintf(stderr, "Invalid options\n");
337 fprintf(stderr, "%s\n", bad);
338 usage();
339 exit(1);
340 }
341
342 int
main(int argc,char ** argv)343 main(int argc, char **argv)
344 {
345 int ch, fd, r;
346 int count_flag = 0, dump_flag = 0, replace_flag = 0;
347 int packet_index = -1, direction = -1;
348 int s2c = 0, c2s = 0; /* packet counts */
349 const char *kex = NULL, *kpath = NULL, *data_path = NULL;
350 struct sshkey *key = NULL;
351 struct sshbuf *replace_data = NULL;
352
353 setvbuf(stdout, NULL, _IONBF, 0);
354 while ((ch = getopt(argc, argv, "hcdrvD:f:K:k:i:")) != -1) {
355 switch (ch) {
356 case 'h':
357 usage();
358 return 0;
359 case 'c':
360 count_flag = 1;
361 break;
362 case 'd':
363 dump_flag = 1;
364 break;
365 case 'r':
366 replace_flag = 1;
367 break;
368 case 'v':
369 do_debug = 1;
370 break;
371
372 case 'D':
373 if (strcasecmp(optarg, "s2c") == 0)
374 direction = S2C;
375 else if (strcasecmp(optarg, "c2s") == 0)
376 direction = C2S;
377 else
378 badusage("Invalid direction (-D)");
379 break;
380 case 'f':
381 data_path = optarg;
382 break;
383 case 'K':
384 kex = optarg;
385 break;
386 case 'k':
387 kpath = optarg;
388 break;
389 case 'i':
390 packet_index = atoi(optarg);
391 if (packet_index < 0)
392 badusage("Invalid packet index");
393 break;
394 default:
395 badusage("unsupported flag");
396 }
397 }
398 argc -= optind;
399 argv += optind;
400
401 log_init(argv[0], do_debug ? SYSLOG_LEVEL_DEBUG3 : SYSLOG_LEVEL_INFO,
402 SYSLOG_FACILITY_USER, 1);
403
404 /* Must select a single mode */
405 if ((count_flag + dump_flag + replace_flag) != 1)
406 badusage("Must select one mode: -c, -d or -r");
407 /* KEX type is mandatory */
408 if (kex == NULL || !kex_names_valid(kex) || strchr(kex, ',') != NULL)
409 badusage("Missing or invalid kex type (-K flag)");
410 /* Valid key is mandatory */
411 if (kpath == NULL)
412 badusage("Missing private key (-k flag)");
413 if ((fd = open(kpath, O_RDONLY)) == -1)
414 err(1, "open %s", kpath);
415 if ((r = sshkey_load_private_type_fd(fd, KEY_UNSPEC, NULL,
416 &key, NULL)) != 0)
417 errx(1, "Unable to load key %s: %s", kpath, ssh_err(r));
418 close(fd);
419 /* XXX check that it is a private key */
420 /* XXX support certificates */
421 if (key == NULL || key->type == KEY_UNSPEC || key->type == KEY_RSA1)
422 badusage("Invalid key file (-k flag)");
423
424 /* Replace (fuzz) mode */
425 if (replace_flag) {
426 if (packet_index == -1 || direction == -1 || data_path == NULL)
427 badusage("Replace (-r) mode must specify direction "
428 "(-D) packet index (-i) and data path (-f)");
429 if ((fd = open(data_path, O_RDONLY)) == -1)
430 err(1, "open %s", data_path);
431 replace_data = sshbuf_new();
432 if ((r = sshkey_load_file(fd, replace_data)) != 0)
433 errx(1, "read %s: %s", data_path, ssh_err(r));
434 close(fd);
435 }
436
437 /* Dump mode */
438 if (dump_flag) {
439 if (packet_index == -1 || direction == -1 || data_path == NULL)
440 badusage("Dump (-d) mode must specify direction "
441 "(-D), packet index (-i) and data path (-f)");
442 }
443
444 /* Count mode needs no further flags */
445
446 do_kex_with_key(kex, key, &c2s, &s2c,
447 direction, packet_index,
448 dump_flag ? data_path : NULL,
449 replace_flag ? replace_data : NULL);
450 sshkey_free(key);
451 sshbuf_free(replace_data);
452
453 if (count_flag) {
454 printf("S2C: %d\n", s2c);
455 printf("C2S: %d\n", c2s);
456 }
457
458 return 0;
459 }
460