ssh-keyscan.c

   1 /*
   2  * Copyright 1995, 1996 by David Mazieres <dm@lcs.mit.edu>.
   3  *
   4  * Modification and redistribution in source and binary forms is
   5  * permitted provided that due credit is given to the author and the
   6  * OpenBSD project by leaving this copyright notice intact.
   7  */
   8
   9 #include "includes.h"
  10 RCSID("$OpenBSD: ssh-keyscan.c,v 1.24 2001/06/23 15:12:20 itojun Exp $");
  11
  12 #if defined(HAVE_SYS_QUEUE_H) && !defined(HAVE_BOGUS_SYS_QUEUE_H)
  13 #include <sys/queue.h>
  14 #else
  15 #include "openbsd-compat/fake-queue.h"
  16 #endif
  17 #include <errno.h>
  18
  19 #include <openssl/bn.h>
  20
  21 #include "xmalloc.h"
  22 #include "ssh.h"
  23 #include "ssh1.h"
  24 #include "key.h"
  25 #include "buffer.h"
  26 #include "bufaux.h"
  27 #include "log.h"
  28 #include "atomicio.h"
  29
  30 static int argno = 1;           /* Number of argument currently being parsed */
  31
  32 int family = AF_UNSPEC;         /* IPv4, IPv6 or both */
  33
  34 #define MAXMAXFD 256
  35
  36 /* The number of seconds after which to give up on a TCP connection */
  37 int timeout = 5;
  38
  39 int maxfd;
  40 #define MAXCON (maxfd - 10)
  41
  42 #ifdef HAVE___PROGNAME
  43 extern char *__progname;
  44 #else
  45 char *__progname;
  46 #endif
  47 fd_set *read_wait;
  48 size_t read_wait_size;
  49 int ncon;
  50
  51 /*
  52  * Keep a connection structure for each file descriptor.  The state
  53  * associated with file descriptor n is held in fdcon[n].
  54  */
  55 typedef struct Connection {
  56         u_char c_status;        /* State of connection on this file desc. */
  57 #define CS_UNUSED 0             /* File descriptor unused */
  58 #define CS_CON 1                /* Waiting to connect/read greeting */
  59 #define CS_SIZE 2               /* Waiting to read initial packet size */
  60 #define CS_KEYS 3               /* Waiting to read public key packet */
  61         int c_fd;               /* Quick lookup: c->c_fd == c - fdcon */
  62         int c_plen;             /* Packet length field for ssh packet */
  63         int c_len;              /* Total bytes which must be read. */
  64         int c_off;              /* Length of data read so far. */
  65         char *c_namebase;       /* Address to free for c_name and c_namelist */
  66         char *c_name;           /* Hostname of connection for errors */
  67         char *c_namelist;       /* Pointer to other possible addresses */
  68         char *c_output_name;    /* Hostname of connection for output */
  69         char *c_data;           /* Data read from this fd */
  70         struct timeval c_tv;    /* Time at which connection gets aborted */
  71         TAILQ_ENTRY(Connection) c_link; /* List of connections in timeout order. */
  72 } con;
  73
  74 TAILQ_HEAD(conlist, Connection) tq;     /* Timeout Queue */
  75 con *fdcon;
  76
  77 /*
  78  *  This is just a wrapper around fgets() to make it usable.
  79  */
  80
  81 /* Stress-test.  Increase this later. */
  82 #define LINEBUF_SIZE 16
  83
  84 typedef struct {
  85         char *buf;
  86         u_int size;
  87         int lineno;
  88         const char *filename;
  89         FILE *stream;
  90         void (*errfun) (const char *,...);
  91 } Linebuf;
  92
  93 static Linebuf *
  94 Linebuf_alloc(const char *filename, void (*errfun) (const char *,...))
  95 {
  96         Linebuf *lb;
  97
  98         if (!(lb = malloc(sizeof(*lb)))) {
  99                 if (errfun)
 100                         (*errfun) ("linebuf (%s): malloc failed\n", lb->filename);
 101                 return (NULL);
 102         }
 103         if (filename) {
 104                 lb->filename = filename;
 105                 if (!(lb->stream = fopen(filename, "r"))) {
 106                         xfree(lb);
 107                         if (errfun)
 108                                 (*errfun) ("%s: %s\n", filename, strerror(errno));
 109                         return (NULL);
 110                 }
 111         } else {
 112                 lb->filename = "(stdin)";
 113                 lb->stream = stdin;
 114         }
 115
 116         if (!(lb->buf = malloc(lb->size = LINEBUF_SIZE))) {
 117                 if (errfun)
 118                         (*errfun) ("linebuf (%s): malloc failed\n", lb->filename);
 119                 xfree(lb);
 120                 return (NULL);
 121         }
 122         lb->errfun = errfun;
 123         lb->lineno = 0;
 124         return (lb);
 125 }
 126
 127 static void
 128 Linebuf_free(Linebuf * lb)
 129 {
 130         fclose(lb->stream);
 131         xfree(lb->buf);
 132         xfree(lb);
 133 }
 134
 135 #if 0
 136 static void
 137 Linebuf_restart(Linebuf * lb)
 138 {
 139         clearerr(lb->stream);
 140         rewind(lb->stream);
 141         lb->lineno = 0;
 142 }
 143
 144 static int
 145 Linebuf_lineno(Linebuf * lb)
 146 {
 147         return (lb->lineno);
 148 }
 149 #endif
 150
 151 static char *
 152 Linebuf_getline(Linebuf * lb)
 153 {
 154         int n = 0;
 155
 156         lb->lineno++;
 157         for (;;) {
 158                 /* Read a line */
 159                 if (!fgets(&lb->buf[n], lb->size - n, lb->stream)) {
 160                         if (ferror(lb->stream) && lb->errfun)
 161                                 (*lb->errfun) ("%s: %s\n", lb->filename,
 162                                     strerror(errno));
 163                         return (NULL);
 164                 }
 165                 n = strlen(lb->buf);
 166
 167                 /* Return it or an error if it fits */
 168                 if (n > 0 && lb->buf[n - 1] == '\n') {
 169                         lb->buf[n - 1] = '\0';
 170                         return (lb->buf);
 171                 }
 172                 if (n != lb->size - 1) {
 173                         if (lb->errfun)
 174                                 (*lb->errfun) ("%s: skipping incomplete last line\n",
 175                                     lb->filename);
 176                         return (NULL);
 177                 }
 178                 /* Double the buffer if we need more space */
 179                 if (!(lb->buf = realloc(lb->buf, (lb->size *= 2)))) {
 180                         if (lb->errfun)
 181                                 (*lb->errfun) ("linebuf (%s): realloc failed\n",
 182                                     lb->filename);
 183                         return (NULL);
 184                 }
 185         }
 186 }
 187
 188 static int
 189 fdlim_get(int hard)
 190 {
 191 #if defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE)
 192         struct rlimit rlfd;
 193
 194         if (getrlimit(RLIMIT_NOFILE, &rlfd) < 0)
 195                 return (-1);
 196         if ((hard ? rlfd.rlim_max : rlfd.rlim_cur) == RLIM_INFINITY)
 197                 return 10000;
 198         else
 199                 return hard ? rlfd.rlim_max : rlfd.rlim_cur;
 200 #elif defined (HAVE_SYSCONF)
 201         return sysconf (_SC_OPEN_MAX);
 202 #else
 203         return 10000;
 204 #endif
 205 }
 206
 207 static int
 208 fdlim_set(int lim)
 209 {
 210 #if defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE)
 211         struct rlimit rlfd;
 212 #endif
 213         if (lim <= 0)
 214                 return (-1);
 215 #if defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE)
 216         if (getrlimit(RLIMIT_NOFILE, &rlfd) < 0)
 217                 return (-1);
 218         rlfd.rlim_cur = lim;
 219         if (setrlimit(RLIMIT_NOFILE, &rlfd) < 0)
 220                 return (-1);
 221 #elif defined (HAVE_SETDTABLESIZE)
 222         setdtablesize(lim);
 223 #endif
 224         return (0);
 225 }
 226
 227 /*
 228  * This is an strsep function that returns a null field for adjacent
 229  * separators.  This is the same as the 4.4BSD strsep, but different from the
 230  * one in the GNU libc.
 231  */
 232 static char *
 233 xstrsep(char **str, const char *delim)
 234 {
 235         char *s, *e;
 236
 237         if (!**str)
 238                 return (NULL);
 239
 240         s = *str;
 241         e = s + strcspn(s, delim);
 242
 243         if (*e != '\0')
 244                 *e++ = '\0';
 245         *str = e;
 246
 247         return (s);
 248 }
 249
 250 /*
 251  * Get the next non-null token (like GNU strsep).  Strsep() will return a
 252  * null token for two adjacent separators, so we may have to loop.
 253  */
 254 static char *
 255 strnnsep(char **stringp, char *delim)
 256 {
 257         char *tok;
 258
 259         do {
 260                 tok = xstrsep(stringp, delim);
 261         } while (tok && *tok == '\0');
 262         return (tok);
 263 }
 264
 265 static void
 266 keyprint(char *host, char *output_name, char *kd, int len)
 267 {
 268         static Key *rsa;
 269         static Buffer msg;
 270
 271         if (rsa == NULL) {
 272                 buffer_init(&msg);
 273                 rsa = key_new(KEY_RSA1);
 274         }
 275         buffer_append(&msg, kd, len);
 276         buffer_consume(&msg, 8 - (len & 7));    /* padding */
 277         if (buffer_get_char(&msg) != (int) SSH_SMSG_PUBLIC_KEY) {
 278                 error("%s: invalid packet type", host);
 279                 buffer_clear(&msg);
 280                 return;
 281         }
 282         buffer_consume(&msg, 8);                /* cookie */
 283
 284         /* server key */
 285         (void) buffer_get_int(&msg);
 286         buffer_get_bignum(&msg, rsa->rsa->e);
 287         buffer_get_bignum(&msg, rsa->rsa->n);
 288
 289         /* host key */
 290         (void) buffer_get_int(&msg);
 291         buffer_get_bignum(&msg, rsa->rsa->e);
 292         buffer_get_bignum(&msg, rsa->rsa->n);
 293         buffer_clear(&msg);
 294
 295         fprintf(stdout, "%s ", output_name ? output_name : host);
 296         key_write(rsa, stdout);
 297         fputs("\n", stdout);
 298 }
 299
 300 static int
 301 tcpconnect(char *host)
 302 {
 303         struct addrinfo hints, *ai, *aitop;
 304         char strport[NI_MAXSERV];
 305         int gaierr, s = -1;
 306
 307         snprintf(strport, sizeof strport, "%d", SSH_DEFAULT_PORT);
 308         memset(&hints, 0, sizeof(hints));
 309         hints.ai_family = family;
 310         hints.ai_socktype = SOCK_STREAM;
 311         if ((gaierr = getaddrinfo(host, strport, &hints, &aitop)) != 0)
 312                 fatal("getaddrinfo %s: %s", host, gai_strerror(gaierr));
 313         for (ai = aitop; ai; ai = ai->ai_next) {
 314                 s = socket(ai->ai_family, SOCK_STREAM, 0);
 315                 if (s < 0) {
 316                         error("socket: %s", strerror(errno));
 317                         continue;
 318                 }
 319                 if (fcntl(s, F_SETFL, O_NONBLOCK) < 0)
 320                         fatal("F_SETFL: %s", strerror(errno));
 321                 if (connect(s, ai->ai_addr, ai->ai_addrlen) < 0 &&
 322                     errno != EINPROGRESS)
 323                         error("connect (`%s'): %s", host, strerror(errno));
 324                 else
 325                         break;
 326                 close(s);
 327                 s = -1;
 328         }
 329         freeaddrinfo(aitop);
 330         return s;
 331 }
 332
 333 static int
 334 conalloc(char *iname, char *oname)
 335 {
 336         int s;
 337         char *namebase, *name, *namelist;
 338
 339         namebase = namelist = xstrdup(iname);
 340
 341         do {
 342                 name = xstrsep(&namelist, ",");
 343                 if (!name) {
 344                         xfree(namebase);
 345                         return (-1);
 346                 }
 347         } while ((s = tcpconnect(name)) < 0);
 348
 349         if (s >= maxfd)
 350                 fatal("conalloc: fdno %d too high", s);
 351         if (fdcon[s].c_status)
 352                 fatal("conalloc: attempt to reuse fdno %d", s);
 353
 354         fdcon[s].c_fd = s;
 355         fdcon[s].c_status = CS_CON;
 356         fdcon[s].c_namebase = namebase;
 357         fdcon[s].c_name = name;
 358         fdcon[s].c_namelist = namelist;
 359         fdcon[s].c_output_name = xstrdup(oname);
 360         fdcon[s].c_data = (char *) &fdcon[s].c_plen;
 361         fdcon[s].c_len = 4;
 362         fdcon[s].c_off = 0;
 363         gettimeofday(&fdcon[s].c_tv, NULL);
 364         fdcon[s].c_tv.tv_sec += timeout;
 365         TAILQ_INSERT_TAIL(&tq, &fdcon[s], c_link);
 366         FD_SET(s, read_wait);
 367         ncon++;
 368         return (s);
 369 }
 370
 371 static void
 372 confree(int s)
 373 {
 374         if (s >= maxfd || fdcon[s].c_status == CS_UNUSED)
 375                 fatal("confree: attempt to free bad fdno %d", s);
 376         close(s);
 377         xfree(fdcon[s].c_namebase);
 378         xfree(fdcon[s].c_output_name);
 379         if (fdcon[s].c_status == CS_KEYS)
 380                 xfree(fdcon[s].c_data);
 381         fdcon[s].c_status = CS_UNUSED;
 382         TAILQ_REMOVE(&tq, &fdcon[s], c_link);
 383         FD_CLR(s, read_wait);
 384         ncon--;
 385 }
 386
 387 static void
 388 contouch(int s)
 389 {
 390         TAILQ_REMOVE(&tq, &fdcon[s], c_link);
 391         gettimeofday(&fdcon[s].c_tv, NULL);
 392         fdcon[s].c_tv.tv_sec += timeout;
 393         TAILQ_INSERT_TAIL(&tq, &fdcon[s], c_link);
 394 }
 395
 396 static int
 397 conrecycle(int s)
 398 {
 399         int ret;
 400         con *c = &fdcon[s];
 401         char *iname, *oname;
 402
 403         iname = xstrdup(c->c_namelist);
 404         oname = xstrdup(c->c_output_name);
 405         confree(s);
 406         ret = conalloc(iname, oname);
 407         xfree(iname);
 408         xfree(oname);
 409         return (ret);
 410 }
 411
 412 static void
 413 congreet(int s)
 414 {
 415         char buf[80], *cp;
 416         size_t bufsiz;
 417         int n = 0;
 418         con *c = &fdcon[s];
 419
 420         bufsiz = sizeof(buf);
 421         cp = buf;
 422         while (bufsiz-- && (n = read(s, cp, 1)) == 1 && *cp != '\n' && *cp != '\r')
 423                 cp++;
 424         if (n < 0) {
 425                 if (errno != ECONNREFUSED)
 426                         error("read (%s): %s", c->c_name, strerror(errno));
 427                 conrecycle(s);
 428                 return;
 429         }
 430         if (*cp != '\n' && *cp != '\r') {
 431                 error("%s: bad greeting", c->c_name);
 432                 confree(s);
 433                 return;
 434         }
 435         *cp = '\0';
 436         fprintf(stderr, "# %s %s\n", c->c_name, buf);
 437         n = snprintf(buf, sizeof buf, "SSH-1.5-OpenSSH-keyscan\r\n");
 438         if (atomicio(write, s, buf, n) != n) {
 439                 error("write (%s): %s", c->c_name, strerror(errno));
 440                 confree(s);
 441                 return;
 442         }
 443         c->c_status = CS_SIZE;
 444         contouch(s);
 445 }
 446
 447 static void
 448 conread(int s)
 449 {
 450         int n;
 451         con *c = &fdcon[s];
 452
 453         if (c->c_status == CS_CON) {
 454                 congreet(s);
 455                 return;
 456         }
 457         n = read(s, c->c_data + c->c_off, c->c_len - c->c_off);
 458         if (n < 0) {
 459                 error("read (%s): %s", c->c_name, strerror(errno));
 460                 confree(s);
 461                 return;
 462         }
 463         c->c_off += n;
 464
 465         if (c->c_off == c->c_len)
 466                 switch (c->c_status) {
 467                 case CS_SIZE:
 468                         c->c_plen = htonl(c->c_plen);
 469                         c->c_len = c->c_plen + 8 - (c->c_plen & 7);
 470                         c->c_off = 0;
 471                         c->c_data = xmalloc(c->c_len);
 472                         c->c_status = CS_KEYS;
 473                         break;
 474                 case CS_KEYS:
 475                         keyprint(c->c_name, c->c_output_name, c->c_data, c->c_plen);
 476                         confree(s);
 477                         return;
 478                         break;
 479                 default:
 480                         fatal("conread: invalid status %d", c->c_status);
 481                         break;
 482                 }
 483
 484         contouch(s);
 485 }
 486
 487 static void
 488 conloop(void)
 489 {
 490         fd_set *r, *e;
 491         struct timeval seltime, now;
 492         int i;
 493         con *c;
 494
 495         gettimeofday(&now, NULL);
 496         c = tq.tqh_first;
 497
 498         if (c && (c->c_tv.tv_sec > now.tv_sec ||
 499             (c->c_tv.tv_sec == now.tv_sec && c->c_tv.tv_usec > now.tv_usec))) {
 500                 seltime = c->c_tv;
 501                 seltime.tv_sec -= now.tv_sec;
 502                 seltime.tv_usec -= now.tv_usec;
 503                 if (seltime.tv_usec < 0) {
 504                         seltime.tv_usec += 1000000;
 505                         seltime.tv_sec--;
 506                 }
 507         } else
 508                 seltime.tv_sec = seltime.tv_usec = 0;
 509
 510         r = xmalloc(read_wait_size);
 511         memcpy(r, read_wait, read_wait_size);
 512         e = xmalloc(read_wait_size);
 513         memcpy(e, read_wait, read_wait_size);
 514
 515         while (select(maxfd, r, NULL, e, &seltime) == -1 &&
 516             (errno == EAGAIN || errno == EINTR))
 517                 ;
 518
 519         for (i = 0; i < maxfd; i++) {
 520                 if (FD_ISSET(i, e)) {
 521                         error("%s: exception!", fdcon[i].c_name);
 522                         confree(i);
 523                 } else if (FD_ISSET(i, r))
 524                         conread(i);
 525         }
 526         xfree(r);
 527         xfree(e);
 528
 529         c = tq.tqh_first;
 530         while (c && (c->c_tv.tv_sec < now.tv_sec ||
 531             (c->c_tv.tv_sec == now.tv_sec && c->c_tv.tv_usec < now.tv_usec))) {
 532                 int s = c->c_fd;
 533
 534                 c = c->c_link.tqe_next;
 535                 conrecycle(s);
 536         }
 537 }
 538
 539 static char *
 540 nexthost(int argc, char **argv)
 541 {
 542         static Linebuf *lb;
 543
 544         for (;;) {
 545                 if (!lb) {
 546                         if (argno >= argc)
 547                                 return (NULL);
 548                         if (argv[argno][0] != '-')
 549                                 return (argv[argno++]);
 550                         if (!strcmp(argv[argno], "--")) {
 551                                 if (++argno >= argc)
 552                                         return (NULL);
 553                                 return (argv[argno++]);
 554                         } else if (!strncmp(argv[argno], "-f", 2)) {
 555                                 char *fname;
 556
 557                                 if (argv[argno][2])
 558                                         fname = &argv[argno++][2];
 559                                 else if (++argno >= argc) {
 560                                         error("missing filename for `-f'");
 561                                         return (NULL);
 562                                 } else
 563                                         fname = argv[argno++];
 564                                 if (!strcmp(fname, "-"))
 565                                         fname = NULL;
 566                                 lb = Linebuf_alloc(fname, error);
 567                         } else
 568                                 error("ignoring invalid/misplaced option `%s'",
 569                                     argv[argno++]);
 570                 } else {
 571                         char *line;
 572
 573                         line = Linebuf_getline(lb);
 574                         if (line)
 575                                 return (line);
 576                         Linebuf_free(lb);
 577                         lb = NULL;
 578                 }
 579         }
 580 }
 581
 582 static void
 583 usage(void)
 584 {
 585         fatal("usage: %s [-t timeout] { [--] host | -f file } ...", __progname);
 586         return;
 587 }
 588
 589 int
 590 main(int argc, char **argv)
 591 {
 592         char *host = NULL;
 593
 594         __progname = get_progname(argv[0]);
 595         TAILQ_INIT(&tq);
 596
 597         if (argc <= argno)
 598                 usage();
 599
 600         if (argv[1][0] == '-' && argv[1][1] == 't') {
 601                 argno++;
 602                 if (argv[1][2])
 603                         timeout = atoi(&argv[1][2]);
 604                 else {
 605                         if (argno >= argc)
 606                                 usage();
 607                         timeout = atoi(argv[argno++]);
 608                 }
 609                 if (timeout <= 0)
 610                         usage();
 611         }
 612         if (argc <= argno)
 613                 usage();
 614
 615         maxfd = fdlim_get(1);
 616         if (maxfd < 0)
 617                 fatal("%s: fdlim_get: bad value", __progname);
 618         if (maxfd > MAXMAXFD)
 619                 maxfd = MAXMAXFD;
 620         if (MAXCON <= 0)
 621                 fatal("%s: not enough file descriptors", __progname);
 622         if (maxfd > fdlim_get(0))
 623                 fdlim_set(maxfd);
 624         fdcon = xmalloc(maxfd * sizeof(con));
 625         memset(fdcon, 0, maxfd * sizeof(con));
 626
 627         read_wait_size = howmany(maxfd, NFDBITS) * sizeof(fd_mask);
 628         read_wait = xmalloc(read_wait_size);
 629         memset(read_wait, 0, read_wait_size);
 630
 631         do {
 632                 while (ncon < MAXCON) {
 633                         char *name;
 634
 635                         host = nexthost(argc, argv);
 636                         if (host == NULL)
 637                                 break;
 638                         name = strnnsep(&host, " \t\n");
 639                         conalloc(name, *host ? host : name);
 640                 }
 641                 conloop();
 642         } while (host);
 643         while (ncon > 0)
 644                 conloop();
 645
 646         return (0);
 647 }