crypto/openssh/regress/misc/kexfuzz/kexfuzz.c

   1 /*      $OpenBSD: kexfuzz.c,v 1.4 2017/04/30 23:34:55 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
  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
 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
 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
 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
 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
 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
 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)
 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 }