1*1323ec57SEd Maste /* $OpenBSD: ssh-keyscan.c,v 1.145 2022/01/21 00:53:40 deraadt Exp $ */ 21e8db6e2SBrian Feldman /* 31e8db6e2SBrian Feldman * Copyright 1995, 1996 by David Mazieres <dm@lcs.mit.edu>. 41e8db6e2SBrian Feldman * 51e8db6e2SBrian Feldman * Modification and redistribution in source and binary forms is 61e8db6e2SBrian Feldman * permitted provided that due credit is given to the author and the 7ae1f160dSDag-Erling Smørgrav * OpenBSD project by leaving this copyright notice intact. 81e8db6e2SBrian Feldman */ 91e8db6e2SBrian Feldman 101e8db6e2SBrian Feldman #include "includes.h" 111e8db6e2SBrian Feldman 12bc5531deSDag-Erling Smørgrav #include <sys/types.h> 13f388f5efSDag-Erling Smørgrav #include "openbsd-compat/sys-queue.h" 14333ee039SDag-Erling Smørgrav #include <sys/resource.h> 15333ee039SDag-Erling Smørgrav #ifdef HAVE_SYS_TIME_H 16333ee039SDag-Erling Smørgrav # include <sys/time.h> 17333ee039SDag-Erling Smørgrav #endif 18333ee039SDag-Erling Smørgrav 19333ee039SDag-Erling Smørgrav #include <netinet/in.h> 20333ee039SDag-Erling Smørgrav #include <arpa/inet.h> 211e8db6e2SBrian Feldman 2219261079SEd Maste #ifdef WITH_OPENSSL 231e8db6e2SBrian Feldman #include <openssl/bn.h> 2419261079SEd Maste #endif 251e8db6e2SBrian Feldman 26333ee039SDag-Erling Smørgrav #include <netdb.h> 27333ee039SDag-Erling Smørgrav #include <errno.h> 28*1323ec57SEd Maste #ifdef HAVE_POLL_H 29*1323ec57SEd Maste #include <poll.h> 30*1323ec57SEd Maste #endif 31333ee039SDag-Erling Smørgrav #include <stdarg.h> 32333ee039SDag-Erling Smørgrav #include <stdio.h> 33333ee039SDag-Erling Smørgrav #include <stdlib.h> 34333ee039SDag-Erling Smørgrav #include <signal.h> 35333ee039SDag-Erling Smørgrav #include <string.h> 36333ee039SDag-Erling Smørgrav #include <unistd.h> 37333ee039SDag-Erling Smørgrav 381e8db6e2SBrian Feldman #include "xmalloc.h" 391e8db6e2SBrian Feldman #include "ssh.h" 40bc5531deSDag-Erling Smørgrav #include "sshbuf.h" 41bc5531deSDag-Erling Smørgrav #include "sshkey.h" 42333ee039SDag-Erling Smørgrav #include "cipher.h" 43ae1f160dSDag-Erling Smørgrav #include "kex.h" 44ae1f160dSDag-Erling Smørgrav #include "compat.h" 45ae1f160dSDag-Erling Smørgrav #include "myproposal.h" 46ae1f160dSDag-Erling Smørgrav #include "packet.h" 47ae1f160dSDag-Erling Smørgrav #include "dispatch.h" 481e8db6e2SBrian Feldman #include "log.h" 491e8db6e2SBrian Feldman #include "atomicio.h" 50ae1f160dSDag-Erling Smørgrav #include "misc.h" 51aa49c926SDag-Erling Smørgrav #include "hostfile.h" 52bc5531deSDag-Erling Smørgrav #include "ssherr.h" 53bc5531deSDag-Erling Smørgrav #include "ssh_api.h" 5447dd1d1bSDag-Erling Smørgrav #include "dns.h" 551e8db6e2SBrian Feldman 56989dd127SDag-Erling Smørgrav /* Flag indicating whether IPv4 or IPv6. This can be set on the command line. 57989dd127SDag-Erling Smørgrav Default value is AF_UNSPEC means both IPv4 and IPv6. */ 58989dd127SDag-Erling Smørgrav int IPv4or6 = AF_UNSPEC; 591e8db6e2SBrian Feldman 60ae1f160dSDag-Erling Smørgrav int ssh_port = SSH_DEFAULT_PORT; 61ae1f160dSDag-Erling Smørgrav 624f52dfbbSDag-Erling Smørgrav #define KT_DSA (1) 634f52dfbbSDag-Erling Smørgrav #define KT_RSA (1<<1) 644f52dfbbSDag-Erling Smørgrav #define KT_ECDSA (1<<2) 654f52dfbbSDag-Erling Smørgrav #define KT_ED25519 (1<<3) 6647dd1d1bSDag-Erling Smørgrav #define KT_XMSS (1<<4) 6719261079SEd Maste #define KT_ECDSA_SK (1<<5) 6819261079SEd Maste #define KT_ED25519_SK (1<<6) 694f52dfbbSDag-Erling Smørgrav 704f52dfbbSDag-Erling Smørgrav #define KT_MIN KT_DSA 7119261079SEd Maste #define KT_MAX KT_ED25519_SK 72ae1f160dSDag-Erling Smørgrav 73acc1a9efSDag-Erling Smørgrav int get_cert = 0; 7419261079SEd Maste int get_keytypes = KT_RSA|KT_ECDSA|KT_ED25519|KT_ECDSA_SK|KT_ED25519_SK; 751e8db6e2SBrian Feldman 76aa49c926SDag-Erling Smørgrav int hash_hosts = 0; /* Hash hostname on output */ 77aa49c926SDag-Erling Smørgrav 7847dd1d1bSDag-Erling Smørgrav int print_sshfp = 0; /* Print SSHFP records instead of known_hosts */ 7947dd1d1bSDag-Erling Smørgrav 8019261079SEd Maste int found_one = 0; /* Successfully found a key */ 8119261079SEd Maste 821e8db6e2SBrian Feldman #define MAXMAXFD 256 831e8db6e2SBrian Feldman 841e8db6e2SBrian Feldman /* The number of seconds after which to give up on a TCP connection */ 851e8db6e2SBrian Feldman int timeout = 5; 861e8db6e2SBrian Feldman 871e8db6e2SBrian Feldman int maxfd; 881e8db6e2SBrian Feldman #define MAXCON (maxfd - 10) 891e8db6e2SBrian Feldman 901e8db6e2SBrian Feldman extern char *__progname; 91*1323ec57SEd Maste struct pollfd *read_wait; 921e8db6e2SBrian Feldman int ncon; 93bc5531deSDag-Erling Smørgrav 941e8db6e2SBrian Feldman /* 951e8db6e2SBrian Feldman * Keep a connection structure for each file descriptor. The state 961e8db6e2SBrian Feldman * associated with file descriptor n is held in fdcon[n]. 971e8db6e2SBrian Feldman */ 981e8db6e2SBrian Feldman typedef struct Connection { 991e8db6e2SBrian Feldman u_char c_status; /* State of connection on this file desc. */ 1001e8db6e2SBrian Feldman #define CS_UNUSED 0 /* File descriptor unused */ 1011e8db6e2SBrian Feldman #define CS_CON 1 /* Waiting to connect/read greeting */ 1021e8db6e2SBrian Feldman #define CS_SIZE 2 /* Waiting to read initial packet size */ 1031e8db6e2SBrian Feldman #define CS_KEYS 3 /* Waiting to read public key packet */ 1041e8db6e2SBrian Feldman int c_fd; /* Quick lookup: c->c_fd == c - fdcon */ 1051e8db6e2SBrian Feldman int c_plen; /* Packet length field for ssh packet */ 1061e8db6e2SBrian Feldman int c_len; /* Total bytes which must be read. */ 1071e8db6e2SBrian Feldman int c_off; /* Length of data read so far. */ 1084f52dfbbSDag-Erling Smørgrav int c_keytype; /* Only one of KT_* */ 109557f75e5SDag-Erling Smørgrav sig_atomic_t c_done; /* SSH2 done */ 1101e8db6e2SBrian Feldman char *c_namebase; /* Address to free for c_name and c_namelist */ 1111e8db6e2SBrian Feldman char *c_name; /* Hostname of connection for errors */ 1121e8db6e2SBrian Feldman char *c_namelist; /* Pointer to other possible addresses */ 1131e8db6e2SBrian Feldman char *c_output_name; /* Hostname of connection for output */ 1141e8db6e2SBrian Feldman char *c_data; /* Data read from this fd */ 115bc5531deSDag-Erling Smørgrav struct ssh *c_ssh; /* SSH-connection */ 116*1323ec57SEd Maste struct timespec c_ts; /* Time at which connection gets aborted */ 1171e8db6e2SBrian Feldman TAILQ_ENTRY(Connection) c_link; /* List of connections in timeout order. */ 1181e8db6e2SBrian Feldman } con; 1191e8db6e2SBrian Feldman 1201e8db6e2SBrian Feldman TAILQ_HEAD(conlist, Connection) tq; /* Timeout Queue */ 1211e8db6e2SBrian Feldman con *fdcon; 1221e8db6e2SBrian Feldman 123bc5531deSDag-Erling Smørgrav static void keyprint(con *c, struct sshkey *key); 124bc5531deSDag-Erling Smørgrav 125ae1f160dSDag-Erling Smørgrav static int 1261e8db6e2SBrian Feldman fdlim_get(int hard) 1271e8db6e2SBrian Feldman { 128989dd127SDag-Erling Smørgrav #if defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE) 1291e8db6e2SBrian Feldman struct rlimit rlfd; 1301e8db6e2SBrian Feldman 13119261079SEd Maste if (getrlimit(RLIMIT_NOFILE, &rlfd) == -1) 1321e8db6e2SBrian Feldman return (-1); 1331e8db6e2SBrian Feldman if ((hard ? rlfd.rlim_max : rlfd.rlim_cur) == RLIM_INFINITY) 1341ec0d754SDag-Erling Smørgrav return SSH_SYSFDMAX; 1351e8db6e2SBrian Feldman else 1361e8db6e2SBrian Feldman return hard ? rlfd.rlim_max : rlfd.rlim_cur; 137989dd127SDag-Erling Smørgrav #else 1381ec0d754SDag-Erling Smørgrav return SSH_SYSFDMAX; 139989dd127SDag-Erling Smørgrav #endif 1401e8db6e2SBrian Feldman } 1411e8db6e2SBrian Feldman 142ae1f160dSDag-Erling Smørgrav static int 1431e8db6e2SBrian Feldman fdlim_set(int lim) 1441e8db6e2SBrian Feldman { 145989dd127SDag-Erling Smørgrav #if defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE) 1461e8db6e2SBrian Feldman struct rlimit rlfd; 147989dd127SDag-Erling Smørgrav #endif 148f388f5efSDag-Erling Smørgrav 1491e8db6e2SBrian Feldman if (lim <= 0) 1501e8db6e2SBrian Feldman return (-1); 151989dd127SDag-Erling Smørgrav #if defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE) 15219261079SEd Maste if (getrlimit(RLIMIT_NOFILE, &rlfd) == -1) 1531e8db6e2SBrian Feldman return (-1); 1541e8db6e2SBrian Feldman rlfd.rlim_cur = lim; 15519261079SEd Maste if (setrlimit(RLIMIT_NOFILE, &rlfd) == -1) 1561e8db6e2SBrian Feldman return (-1); 157989dd127SDag-Erling Smørgrav #elif defined (HAVE_SETDTABLESIZE) 158989dd127SDag-Erling Smørgrav setdtablesize(lim); 159989dd127SDag-Erling Smørgrav #endif 1601e8db6e2SBrian Feldman return (0); 1611e8db6e2SBrian Feldman } 1621e8db6e2SBrian Feldman 1631e8db6e2SBrian Feldman /* 1641e8db6e2SBrian Feldman * This is an strsep function that returns a null field for adjacent 1651e8db6e2SBrian Feldman * separators. This is the same as the 4.4BSD strsep, but different from the 1661e8db6e2SBrian Feldman * one in the GNU libc. 1671e8db6e2SBrian Feldman */ 168ae1f160dSDag-Erling Smørgrav static char * 1691e8db6e2SBrian Feldman xstrsep(char **str, const char *delim) 1701e8db6e2SBrian Feldman { 1711e8db6e2SBrian Feldman char *s, *e; 1721e8db6e2SBrian Feldman 1731e8db6e2SBrian Feldman if (!**str) 1741e8db6e2SBrian Feldman return (NULL); 1751e8db6e2SBrian Feldman 1761e8db6e2SBrian Feldman s = *str; 1771e8db6e2SBrian Feldman e = s + strcspn(s, delim); 1781e8db6e2SBrian Feldman 1791e8db6e2SBrian Feldman if (*e != '\0') 1801e8db6e2SBrian Feldman *e++ = '\0'; 1811e8db6e2SBrian Feldman *str = e; 1821e8db6e2SBrian Feldman 1831e8db6e2SBrian Feldman return (s); 1841e8db6e2SBrian Feldman } 1851e8db6e2SBrian Feldman 1861e8db6e2SBrian Feldman /* 1871e8db6e2SBrian Feldman * Get the next non-null token (like GNU strsep). Strsep() will return a 1881e8db6e2SBrian Feldman * null token for two adjacent separators, so we may have to loop. 1891e8db6e2SBrian Feldman */ 190ae1f160dSDag-Erling Smørgrav static char * 1911e8db6e2SBrian Feldman strnnsep(char **stringp, char *delim) 1921e8db6e2SBrian Feldman { 1931e8db6e2SBrian Feldman char *tok; 1941e8db6e2SBrian Feldman 1951e8db6e2SBrian Feldman do { 1961e8db6e2SBrian Feldman tok = xstrsep(stringp, delim); 1971e8db6e2SBrian Feldman } while (tok && *tok == '\0'); 1981e8db6e2SBrian Feldman return (tok); 1991e8db6e2SBrian Feldman } 2001e8db6e2SBrian Feldman 201ae1f160dSDag-Erling Smørgrav 202ae1f160dSDag-Erling Smørgrav static int 203bc5531deSDag-Erling Smørgrav key_print_wrapper(struct sshkey *hostkey, struct ssh *ssh) 204ae1f160dSDag-Erling Smørgrav { 205bc5531deSDag-Erling Smørgrav con *c; 206bc5531deSDag-Erling Smørgrav 207bc5531deSDag-Erling Smørgrav if ((c = ssh_get_app_data(ssh)) != NULL) 208bc5531deSDag-Erling Smørgrav keyprint(c, hostkey); 209bc5531deSDag-Erling Smørgrav /* always abort key exchange */ 210bc5531deSDag-Erling Smørgrav return -1; 211ae1f160dSDag-Erling Smørgrav } 212ae1f160dSDag-Erling Smørgrav 213ae1f160dSDag-Erling Smørgrav static int 214ae1f160dSDag-Erling Smørgrav ssh2_capable(int remote_major, int remote_minor) 215ae1f160dSDag-Erling Smørgrav { 216ae1f160dSDag-Erling Smørgrav switch (remote_major) { 217ae1f160dSDag-Erling Smørgrav case 1: 218ae1f160dSDag-Erling Smørgrav if (remote_minor == 99) 219ae1f160dSDag-Erling Smørgrav return 1; 220ae1f160dSDag-Erling Smørgrav break; 221ae1f160dSDag-Erling Smørgrav case 2: 222ae1f160dSDag-Erling Smørgrav return 1; 223ae1f160dSDag-Erling Smørgrav default: 224ae1f160dSDag-Erling Smørgrav break; 225ae1f160dSDag-Erling Smørgrav } 226ae1f160dSDag-Erling Smørgrav return 0; 227ae1f160dSDag-Erling Smørgrav } 228ae1f160dSDag-Erling Smørgrav 229bc5531deSDag-Erling Smørgrav static void 230ae1f160dSDag-Erling Smørgrav keygrab_ssh2(con *c) 231ae1f160dSDag-Erling Smørgrav { 232a0ee8cc6SDag-Erling Smørgrav char *myproposal[PROPOSAL_MAX] = { KEX_CLIENT }; 233bc5531deSDag-Erling Smørgrav int r; 234ae1f160dSDag-Erling Smørgrav 235acc1a9efSDag-Erling Smørgrav switch (c->c_keytype) { 236acc1a9efSDag-Erling Smørgrav case KT_DSA: 237acc1a9efSDag-Erling Smørgrav myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] = get_cert ? 238acc1a9efSDag-Erling Smørgrav "ssh-dss-cert-v01@openssh.com" : "ssh-dss"; 239acc1a9efSDag-Erling Smørgrav break; 240acc1a9efSDag-Erling Smørgrav case KT_RSA: 241acc1a9efSDag-Erling Smørgrav myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] = get_cert ? 24219261079SEd Maste "rsa-sha2-512-cert-v01@openssh.com," 24319261079SEd Maste "rsa-sha2-256-cert-v01@openssh.com," 24419261079SEd Maste "ssh-rsa-cert-v01@openssh.com" : 24519261079SEd Maste "rsa-sha2-512," 24619261079SEd Maste "rsa-sha2-256," 24719261079SEd Maste "ssh-rsa"; 248acc1a9efSDag-Erling Smørgrav break; 249acc1a9efSDag-Erling Smørgrav case KT_ED25519: 250acc1a9efSDag-Erling Smørgrav myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] = get_cert ? 251acc1a9efSDag-Erling Smørgrav "ssh-ed25519-cert-v01@openssh.com" : "ssh-ed25519"; 252acc1a9efSDag-Erling Smørgrav break; 25347dd1d1bSDag-Erling Smørgrav case KT_XMSS: 25447dd1d1bSDag-Erling Smørgrav myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] = get_cert ? 25547dd1d1bSDag-Erling Smørgrav "ssh-xmss-cert-v01@openssh.com" : "ssh-xmss@openssh.com"; 25647dd1d1bSDag-Erling Smørgrav break; 257acc1a9efSDag-Erling Smørgrav case KT_ECDSA: 258acc1a9efSDag-Erling Smørgrav myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] = get_cert ? 259acc1a9efSDag-Erling Smørgrav "ecdsa-sha2-nistp256-cert-v01@openssh.com," 260acc1a9efSDag-Erling Smørgrav "ecdsa-sha2-nistp384-cert-v01@openssh.com," 261acc1a9efSDag-Erling Smørgrav "ecdsa-sha2-nistp521-cert-v01@openssh.com" : 262acc1a9efSDag-Erling Smørgrav "ecdsa-sha2-nistp256," 263acc1a9efSDag-Erling Smørgrav "ecdsa-sha2-nistp384," 264acc1a9efSDag-Erling Smørgrav "ecdsa-sha2-nistp521"; 265acc1a9efSDag-Erling Smørgrav break; 26619261079SEd Maste case KT_ECDSA_SK: 26719261079SEd Maste myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] = get_cert ? 26819261079SEd Maste "sk-ecdsa-sha2-nistp256-cert-v01@openssh.com" : 26919261079SEd Maste "sk-ecdsa-sha2-nistp256@openssh.com"; 27019261079SEd Maste break; 27119261079SEd Maste case KT_ED25519_SK: 27219261079SEd Maste myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] = get_cert ? 27319261079SEd Maste "sk-ssh-ed25519-cert-v01@openssh.com" : 27419261079SEd Maste "sk-ssh-ed25519@openssh.com"; 27519261079SEd Maste break; 276acc1a9efSDag-Erling Smørgrav default: 277acc1a9efSDag-Erling Smørgrav fatal("unknown key type %d", c->c_keytype); 278acc1a9efSDag-Erling Smørgrav break; 279acc1a9efSDag-Erling Smørgrav } 280bc5531deSDag-Erling Smørgrav if ((r = kex_setup(c->c_ssh, myproposal)) != 0) { 281bc5531deSDag-Erling Smørgrav free(c->c_ssh); 282bc5531deSDag-Erling Smørgrav fprintf(stderr, "kex_setup: %s\n", ssh_err(r)); 283ae1f160dSDag-Erling Smørgrav exit(1); 284ae1f160dSDag-Erling Smørgrav } 285bc5531deSDag-Erling Smørgrav #ifdef WITH_OPENSSL 28619261079SEd Maste c->c_ssh->kex->kex[KEX_DH_GRP1_SHA1] = kex_gen_client; 28719261079SEd Maste c->c_ssh->kex->kex[KEX_DH_GRP14_SHA1] = kex_gen_client; 28819261079SEd Maste c->c_ssh->kex->kex[KEX_DH_GRP14_SHA256] = kex_gen_client; 28919261079SEd Maste c->c_ssh->kex->kex[KEX_DH_GRP16_SHA512] = kex_gen_client; 29019261079SEd Maste c->c_ssh->kex->kex[KEX_DH_GRP18_SHA512] = kex_gen_client; 291bc5531deSDag-Erling Smørgrav c->c_ssh->kex->kex[KEX_DH_GEX_SHA1] = kexgex_client; 292bc5531deSDag-Erling Smørgrav c->c_ssh->kex->kex[KEX_DH_GEX_SHA256] = kexgex_client; 293bc5531deSDag-Erling Smørgrav # ifdef OPENSSL_HAS_ECC 29419261079SEd Maste c->c_ssh->kex->kex[KEX_ECDH_SHA2] = kex_gen_client; 295bc5531deSDag-Erling Smørgrav # endif 296bc5531deSDag-Erling Smørgrav #endif 29719261079SEd Maste c->c_ssh->kex->kex[KEX_C25519_SHA256] = kex_gen_client; 29819261079SEd Maste c->c_ssh->kex->kex[KEX_KEM_SNTRUP761X25519_SHA512] = kex_gen_client; 299bc5531deSDag-Erling Smørgrav ssh_set_verify_host_key_callback(c->c_ssh, key_print_wrapper); 300bc5531deSDag-Erling Smørgrav /* 301bc5531deSDag-Erling Smørgrav * do the key-exchange until an error occurs or until 302bc5531deSDag-Erling Smørgrav * the key_print_wrapper() callback sets c_done. 303bc5531deSDag-Erling Smørgrav */ 3044f52dfbbSDag-Erling Smørgrav ssh_dispatch_run(c->c_ssh, DISPATCH_BLOCK, &c->c_done); 305ae1f160dSDag-Erling Smørgrav } 306ae1f160dSDag-Erling Smørgrav 307ae1f160dSDag-Erling Smørgrav static void 308d93a896eSDag-Erling Smørgrav keyprint_one(const char *host, struct sshkey *key) 309ae1f160dSDag-Erling Smørgrav { 310*1323ec57SEd Maste char *hostport = NULL, *hashed = NULL; 311*1323ec57SEd Maste const char *known_host; 312ae1f160dSDag-Erling Smørgrav 31319261079SEd Maste found_one = 1; 31419261079SEd Maste 31547dd1d1bSDag-Erling Smørgrav if (print_sshfp) { 31647dd1d1bSDag-Erling Smørgrav export_dns_rr(host, key, stdout, 0); 31747dd1d1bSDag-Erling Smørgrav return; 31847dd1d1bSDag-Erling Smørgrav } 31947dd1d1bSDag-Erling Smørgrav 320557f75e5SDag-Erling Smørgrav hostport = put_host_port(host, ssh_port); 321d93a896eSDag-Erling Smørgrav lowercase(hostport); 322*1323ec57SEd Maste if (hash_hosts && (hashed = host_hash(hostport, NULL, 0)) == NULL) 323d93a896eSDag-Erling Smørgrav fatal("host_hash failed"); 324d93a896eSDag-Erling Smørgrav known_host = hash_hosts ? hashed : hostport; 325acc1a9efSDag-Erling Smørgrav if (!get_cert) 326d93a896eSDag-Erling Smørgrav fprintf(stdout, "%s ", known_host); 327bc5531deSDag-Erling Smørgrav sshkey_write(key, stdout); 3281e8db6e2SBrian Feldman fputs("\n", stdout); 329*1323ec57SEd Maste free(hashed); 330557f75e5SDag-Erling Smørgrav free(hostport); 3311e8db6e2SBrian Feldman } 3321e8db6e2SBrian Feldman 333acc1a9efSDag-Erling Smørgrav static void 334acc1a9efSDag-Erling Smørgrav keyprint(con *c, struct sshkey *key) 335acc1a9efSDag-Erling Smørgrav { 336acc1a9efSDag-Erling Smørgrav char *hosts = c->c_output_name ? c->c_output_name : c->c_name; 337acc1a9efSDag-Erling Smørgrav char *host, *ohosts; 338acc1a9efSDag-Erling Smørgrav 339acc1a9efSDag-Erling Smørgrav if (key == NULL) 340acc1a9efSDag-Erling Smørgrav return; 341acc1a9efSDag-Erling Smørgrav if (get_cert || (!hash_hosts && ssh_port == SSH_DEFAULT_PORT)) { 342acc1a9efSDag-Erling Smørgrav keyprint_one(hosts, key); 343acc1a9efSDag-Erling Smørgrav return; 344acc1a9efSDag-Erling Smørgrav } 345acc1a9efSDag-Erling Smørgrav ohosts = hosts = xstrdup(hosts); 346acc1a9efSDag-Erling Smørgrav while ((host = strsep(&hosts, ",")) != NULL) 347acc1a9efSDag-Erling Smørgrav keyprint_one(host, key); 348acc1a9efSDag-Erling Smørgrav free(ohosts); 349acc1a9efSDag-Erling Smørgrav } 350acc1a9efSDag-Erling Smørgrav 351ae1f160dSDag-Erling Smørgrav static int 3521e8db6e2SBrian Feldman tcpconnect(char *host) 3531e8db6e2SBrian Feldman { 3541e8db6e2SBrian Feldman struct addrinfo hints, *ai, *aitop; 3551e8db6e2SBrian Feldman char strport[NI_MAXSERV]; 3561e8db6e2SBrian Feldman int gaierr, s = -1; 3571e8db6e2SBrian Feldman 358ae1f160dSDag-Erling Smørgrav snprintf(strport, sizeof strport, "%d", ssh_port); 3591e8db6e2SBrian Feldman memset(&hints, 0, sizeof(hints)); 360ae1f160dSDag-Erling Smørgrav hints.ai_family = IPv4or6; 3611e8db6e2SBrian Feldman hints.ai_socktype = SOCK_STREAM; 362bc5531deSDag-Erling Smørgrav if ((gaierr = getaddrinfo(host, strport, &hints, &aitop)) != 0) { 363bc5531deSDag-Erling Smørgrav error("getaddrinfo %s: %s", host, ssh_gai_strerror(gaierr)); 364bc5531deSDag-Erling Smørgrav return -1; 365bc5531deSDag-Erling Smørgrav } 3661e8db6e2SBrian Feldman for (ai = aitop; ai; ai = ai->ai_next) { 367cf2b5f3bSDag-Erling Smørgrav s = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol); 36819261079SEd Maste if (s == -1) { 3691e8db6e2SBrian Feldman error("socket: %s", strerror(errno)); 3701e8db6e2SBrian Feldman continue; 3711e8db6e2SBrian Feldman } 37221e764dfSDag-Erling Smørgrav if (set_nonblock(s) == -1) 37319261079SEd Maste fatal_f("set_nonblock(%d)", s); 37419261079SEd Maste if (connect(s, ai->ai_addr, ai->ai_addrlen) == -1 && 3751e8db6e2SBrian Feldman errno != EINPROGRESS) 3761e8db6e2SBrian Feldman error("connect (`%s'): %s", host, strerror(errno)); 3771e8db6e2SBrian Feldman else 3781e8db6e2SBrian Feldman break; 3791e8db6e2SBrian Feldman close(s); 3801e8db6e2SBrian Feldman s = -1; 3811e8db6e2SBrian Feldman } 3821e8db6e2SBrian Feldman freeaddrinfo(aitop); 3831e8db6e2SBrian Feldman return s; 3841e8db6e2SBrian Feldman } 3851e8db6e2SBrian Feldman 386ae1f160dSDag-Erling Smørgrav static int 387ae1f160dSDag-Erling Smørgrav conalloc(char *iname, char *oname, int keytype) 3881e8db6e2SBrian Feldman { 3891e8db6e2SBrian Feldman char *namebase, *name, *namelist; 390f388f5efSDag-Erling Smørgrav int s; 3911e8db6e2SBrian Feldman 3921e8db6e2SBrian Feldman namebase = namelist = xstrdup(iname); 3931e8db6e2SBrian Feldman 3941e8db6e2SBrian Feldman do { 3951e8db6e2SBrian Feldman name = xstrsep(&namelist, ","); 3961e8db6e2SBrian Feldman if (!name) { 397e4a9863fSDag-Erling Smørgrav free(namebase); 3981e8db6e2SBrian Feldman return (-1); 3991e8db6e2SBrian Feldman } 4001e8db6e2SBrian Feldman } while ((s = tcpconnect(name)) < 0); 4011e8db6e2SBrian Feldman 4021e8db6e2SBrian Feldman if (s >= maxfd) 4031e8db6e2SBrian Feldman fatal("conalloc: fdno %d too high", s); 4041e8db6e2SBrian Feldman if (fdcon[s].c_status) 4051e8db6e2SBrian Feldman fatal("conalloc: attempt to reuse fdno %d", s); 4061e8db6e2SBrian Feldman 40719261079SEd Maste debug3_f("oname %s kt %d", oname, keytype); 4081e8db6e2SBrian Feldman fdcon[s].c_fd = s; 4091e8db6e2SBrian Feldman fdcon[s].c_status = CS_CON; 4101e8db6e2SBrian Feldman fdcon[s].c_namebase = namebase; 4111e8db6e2SBrian Feldman fdcon[s].c_name = name; 4121e8db6e2SBrian Feldman fdcon[s].c_namelist = namelist; 4131e8db6e2SBrian Feldman fdcon[s].c_output_name = xstrdup(oname); 4141e8db6e2SBrian Feldman fdcon[s].c_data = (char *) &fdcon[s].c_plen; 4151e8db6e2SBrian Feldman fdcon[s].c_len = 4; 4161e8db6e2SBrian Feldman fdcon[s].c_off = 0; 417ae1f160dSDag-Erling Smørgrav fdcon[s].c_keytype = keytype; 418*1323ec57SEd Maste monotime_ts(&fdcon[s].c_ts); 419*1323ec57SEd Maste fdcon[s].c_ts.tv_sec += timeout; 4201e8db6e2SBrian Feldman TAILQ_INSERT_TAIL(&tq, &fdcon[s], c_link); 421*1323ec57SEd Maste read_wait[s].fd = s; 422*1323ec57SEd Maste read_wait[s].events = POLLIN; 4231e8db6e2SBrian Feldman ncon++; 4241e8db6e2SBrian Feldman return (s); 4251e8db6e2SBrian Feldman } 4261e8db6e2SBrian Feldman 427ae1f160dSDag-Erling Smørgrav static void 4281e8db6e2SBrian Feldman confree(int s) 4291e8db6e2SBrian Feldman { 4301e8db6e2SBrian Feldman if (s >= maxfd || fdcon[s].c_status == CS_UNUSED) 4311e8db6e2SBrian Feldman fatal("confree: attempt to free bad fdno %d", s); 432e4a9863fSDag-Erling Smørgrav free(fdcon[s].c_namebase); 433e4a9863fSDag-Erling Smørgrav free(fdcon[s].c_output_name); 4341e8db6e2SBrian Feldman if (fdcon[s].c_status == CS_KEYS) 435e4a9863fSDag-Erling Smørgrav free(fdcon[s].c_data); 4361e8db6e2SBrian Feldman fdcon[s].c_status = CS_UNUSED; 437ae1f160dSDag-Erling Smørgrav fdcon[s].c_keytype = 0; 438bc5531deSDag-Erling Smørgrav if (fdcon[s].c_ssh) { 439bc5531deSDag-Erling Smørgrav ssh_packet_close(fdcon[s].c_ssh); 440bc5531deSDag-Erling Smørgrav free(fdcon[s].c_ssh); 441bc5531deSDag-Erling Smørgrav fdcon[s].c_ssh = NULL; 4424f52dfbbSDag-Erling Smørgrav } else 4434f52dfbbSDag-Erling Smørgrav close(s); 4441e8db6e2SBrian Feldman TAILQ_REMOVE(&tq, &fdcon[s], c_link); 445*1323ec57SEd Maste read_wait[s].fd = -1; 446*1323ec57SEd Maste read_wait[s].events = 0; 4471e8db6e2SBrian Feldman ncon--; 4481e8db6e2SBrian Feldman } 4491e8db6e2SBrian Feldman 450ae1f160dSDag-Erling Smørgrav static void 4511e8db6e2SBrian Feldman contouch(int s) 4521e8db6e2SBrian Feldman { 4531e8db6e2SBrian Feldman TAILQ_REMOVE(&tq, &fdcon[s], c_link); 454*1323ec57SEd Maste monotime_ts(&fdcon[s].c_ts); 455*1323ec57SEd Maste fdcon[s].c_ts.tv_sec += timeout; 4561e8db6e2SBrian Feldman TAILQ_INSERT_TAIL(&tq, &fdcon[s], c_link); 4571e8db6e2SBrian Feldman } 4581e8db6e2SBrian Feldman 459ae1f160dSDag-Erling Smørgrav static int 4601e8db6e2SBrian Feldman conrecycle(int s) 4611e8db6e2SBrian Feldman { 4621e8db6e2SBrian Feldman con *c = &fdcon[s]; 463f388f5efSDag-Erling Smørgrav int ret; 4641e8db6e2SBrian Feldman 465ae1f160dSDag-Erling Smørgrav ret = conalloc(c->c_namelist, c->c_output_name, c->c_keytype); 4661e8db6e2SBrian Feldman confree(s); 4671e8db6e2SBrian Feldman return (ret); 4681e8db6e2SBrian Feldman } 4691e8db6e2SBrian Feldman 470ae1f160dSDag-Erling Smørgrav static void 4711e8db6e2SBrian Feldman congreet(int s) 4721e8db6e2SBrian Feldman { 473d4ecd108SDag-Erling Smørgrav int n = 0, remote_major = 0, remote_minor = 0; 474ae1f160dSDag-Erling Smørgrav char buf[256], *cp; 475ae1f160dSDag-Erling Smørgrav char remote_version[sizeof buf]; 4761e8db6e2SBrian Feldman size_t bufsiz; 4771e8db6e2SBrian Feldman con *c = &fdcon[s]; 4781e8db6e2SBrian Feldman 4794f52dfbbSDag-Erling Smørgrav /* send client banner */ 4804f52dfbbSDag-Erling Smørgrav n = snprintf(buf, sizeof buf, "SSH-%d.%d-OpenSSH-keyscan\r\n", 4814f52dfbbSDag-Erling Smørgrav PROTOCOL_MAJOR_2, PROTOCOL_MINOR_2); 4824f52dfbbSDag-Erling Smørgrav if (n < 0 || (size_t)n >= sizeof(buf)) { 4834f52dfbbSDag-Erling Smørgrav error("snprintf: buffer too small"); 4844f52dfbbSDag-Erling Smørgrav confree(s); 4854f52dfbbSDag-Erling Smørgrav return; 4864f52dfbbSDag-Erling Smørgrav } 4874f52dfbbSDag-Erling Smørgrav if (atomicio(vwrite, s, buf, n) != (size_t)n) { 4884f52dfbbSDag-Erling Smørgrav error("write (%s): %s", c->c_name, strerror(errno)); 4894f52dfbbSDag-Erling Smørgrav confree(s); 4904f52dfbbSDag-Erling Smørgrav return; 4914f52dfbbSDag-Erling Smørgrav } 4924f52dfbbSDag-Erling Smørgrav 493b74df5b2SDag-Erling Smørgrav for (;;) { 494b74df5b2SDag-Erling Smørgrav memset(buf, '\0', sizeof(buf)); 4951e8db6e2SBrian Feldman bufsiz = sizeof(buf); 4961e8db6e2SBrian Feldman cp = buf; 497b74df5b2SDag-Erling Smørgrav while (bufsiz-- && 498b74df5b2SDag-Erling Smørgrav (n = atomicio(read, s, cp, 1)) == 1 && *cp != '\n') { 499ae1f160dSDag-Erling Smørgrav if (*cp == '\r') 500ae1f160dSDag-Erling Smørgrav *cp = '\n'; 5011e8db6e2SBrian Feldman cp++; 502ae1f160dSDag-Erling Smørgrav } 503b74df5b2SDag-Erling Smørgrav if (n != 1 || strncmp(buf, "SSH-", 4) == 0) 504b74df5b2SDag-Erling Smørgrav break; 505b74df5b2SDag-Erling Smørgrav } 506ae1f160dSDag-Erling Smørgrav if (n == 0) { 507d4ecd108SDag-Erling Smørgrav switch (errno) { 508d4ecd108SDag-Erling Smørgrav case EPIPE: 509ae1f160dSDag-Erling Smørgrav error("%s: Connection closed by remote host", c->c_name); 510d4ecd108SDag-Erling Smørgrav break; 511d4ecd108SDag-Erling Smørgrav case ECONNREFUSED: 512d4ecd108SDag-Erling Smørgrav break; 513d4ecd108SDag-Erling Smørgrav default: 514d4ecd108SDag-Erling Smørgrav error("read (%s): %s", c->c_name, strerror(errno)); 515d4ecd108SDag-Erling Smørgrav break; 516d4ecd108SDag-Erling Smørgrav } 517ae1f160dSDag-Erling Smørgrav conrecycle(s); 518ae1f160dSDag-Erling Smørgrav return; 519ae1f160dSDag-Erling Smørgrav } 5201e8db6e2SBrian Feldman if (*cp != '\n' && *cp != '\r') { 5211e8db6e2SBrian Feldman error("%s: bad greeting", c->c_name); 5221e8db6e2SBrian Feldman confree(s); 5231e8db6e2SBrian Feldman return; 5241e8db6e2SBrian Feldman } 5251e8db6e2SBrian Feldman *cp = '\0'; 526bc5531deSDag-Erling Smørgrav if ((c->c_ssh = ssh_packet_set_connection(NULL, s, s)) == NULL) 527bc5531deSDag-Erling Smørgrav fatal("ssh_packet_set_connection failed"); 528bc5531deSDag-Erling Smørgrav ssh_packet_set_timeout(c->c_ssh, timeout, 1); 529bc5531deSDag-Erling Smørgrav ssh_set_app_data(c->c_ssh, c); /* back link */ 53019261079SEd Maste c->c_ssh->compat = 0; 531ae1f160dSDag-Erling Smørgrav if (sscanf(buf, "SSH-%d.%d-%[^\n]\n", 532ae1f160dSDag-Erling Smørgrav &remote_major, &remote_minor, remote_version) == 3) 53319261079SEd Maste compat_banner(c->c_ssh, remote_version); 534ae1f160dSDag-Erling Smørgrav if (!ssh2_capable(remote_major, remote_minor)) { 535ae1f160dSDag-Erling Smørgrav debug("%s doesn't support ssh2", c->c_name); 536ae1f160dSDag-Erling Smørgrav confree(s); 537ae1f160dSDag-Erling Smørgrav return; 538ae1f160dSDag-Erling Smørgrav } 53947dd1d1bSDag-Erling Smørgrav fprintf(stderr, "%c %s:%d %s\n", print_sshfp ? ';' : '#', 54047dd1d1bSDag-Erling Smørgrav c->c_name, ssh_port, chop(buf)); 541bc5531deSDag-Erling Smørgrav keygrab_ssh2(c); 542ae1f160dSDag-Erling Smørgrav confree(s); 5431e8db6e2SBrian Feldman } 5441e8db6e2SBrian Feldman 545ae1f160dSDag-Erling Smørgrav static void 5461e8db6e2SBrian Feldman conread(int s) 5471e8db6e2SBrian Feldman { 5481e8db6e2SBrian Feldman con *c = &fdcon[s]; 549d4ecd108SDag-Erling Smørgrav size_t n; 5501e8db6e2SBrian Feldman 5511e8db6e2SBrian Feldman if (c->c_status == CS_CON) { 5521e8db6e2SBrian Feldman congreet(s); 5531e8db6e2SBrian Feldman return; 5541e8db6e2SBrian Feldman } 55521e764dfSDag-Erling Smørgrav n = atomicio(read, s, c->c_data + c->c_off, c->c_len - c->c_off); 556d4ecd108SDag-Erling Smørgrav if (n == 0) { 5571e8db6e2SBrian Feldman error("read (%s): %s", c->c_name, strerror(errno)); 5581e8db6e2SBrian Feldman confree(s); 5591e8db6e2SBrian Feldman return; 5601e8db6e2SBrian Feldman } 5611e8db6e2SBrian Feldman c->c_off += n; 5621e8db6e2SBrian Feldman 5631e8db6e2SBrian Feldman if (c->c_off == c->c_len) 5641e8db6e2SBrian Feldman switch (c->c_status) { 5651e8db6e2SBrian Feldman case CS_SIZE: 5661e8db6e2SBrian Feldman c->c_plen = htonl(c->c_plen); 5671e8db6e2SBrian Feldman c->c_len = c->c_plen + 8 - (c->c_plen & 7); 5681e8db6e2SBrian Feldman c->c_off = 0; 5691e8db6e2SBrian Feldman c->c_data = xmalloc(c->c_len); 5701e8db6e2SBrian Feldman c->c_status = CS_KEYS; 5711e8db6e2SBrian Feldman break; 5721e8db6e2SBrian Feldman default: 5731e8db6e2SBrian Feldman fatal("conread: invalid status %d", c->c_status); 5741e8db6e2SBrian Feldman break; 5751e8db6e2SBrian Feldman } 5761e8db6e2SBrian Feldman 5771e8db6e2SBrian Feldman contouch(s); 5781e8db6e2SBrian Feldman } 5791e8db6e2SBrian Feldman 580ae1f160dSDag-Erling Smørgrav static void 5811e8db6e2SBrian Feldman conloop(void) 5821e8db6e2SBrian Feldman { 583*1323ec57SEd Maste struct timespec seltime, now; 5841e8db6e2SBrian Feldman con *c; 585f388f5efSDag-Erling Smørgrav int i; 5861e8db6e2SBrian Feldman 587*1323ec57SEd Maste monotime_ts(&now); 588545d5ecaSDag-Erling Smørgrav c = TAILQ_FIRST(&tq); 5891e8db6e2SBrian Feldman 590*1323ec57SEd Maste if (c && timespeccmp(&c->c_ts, &now, >)) 591*1323ec57SEd Maste timespecsub(&c->c_ts, &now, &seltime); 59219261079SEd Maste else 593*1323ec57SEd Maste timespecclear(&seltime); 5941e8db6e2SBrian Feldman 595*1323ec57SEd Maste while (ppoll(read_wait, maxfd, &seltime, NULL) == -1) { 596*1323ec57SEd Maste if (errno == EAGAIN || errno == EINTR || errno == EWOULDBLOCK) 597*1323ec57SEd Maste continue; 598*1323ec57SEd Maste error("poll error"); 599*1323ec57SEd Maste } 6001e8db6e2SBrian Feldman 6011e8db6e2SBrian Feldman for (i = 0; i < maxfd; i++) { 602*1323ec57SEd Maste if (read_wait[i].revents & (POLLHUP|POLLERR|POLLNVAL)) 6031e8db6e2SBrian Feldman confree(i); 604*1323ec57SEd Maste else if (read_wait[i].revents & (POLLIN|POLLHUP)) 6051e8db6e2SBrian Feldman conread(i); 6061e8db6e2SBrian Feldman } 6071e8db6e2SBrian Feldman 608545d5ecaSDag-Erling Smørgrav c = TAILQ_FIRST(&tq); 609*1323ec57SEd Maste while (c && timespeccmp(&c->c_ts, &now, <)) { 6101e8db6e2SBrian Feldman int s = c->c_fd; 6111e8db6e2SBrian Feldman 612545d5ecaSDag-Erling Smørgrav c = TAILQ_NEXT(c, c_link); 6131e8db6e2SBrian Feldman conrecycle(s); 6141e8db6e2SBrian Feldman } 6151e8db6e2SBrian Feldman } 6161e8db6e2SBrian Feldman 617ae1f160dSDag-Erling Smørgrav static void 618ae1f160dSDag-Erling Smørgrav do_host(char *host) 6191e8db6e2SBrian Feldman { 620ae1f160dSDag-Erling Smørgrav char *name = strnnsep(&host, " \t\n"); 621ae1f160dSDag-Erling Smørgrav int j; 6221e8db6e2SBrian Feldman 623ae1f160dSDag-Erling Smørgrav if (name == NULL) 624ae1f160dSDag-Erling Smørgrav return; 6254f52dfbbSDag-Erling Smørgrav for (j = KT_MIN; j <= KT_MAX; j *= 2) { 626ae1f160dSDag-Erling Smørgrav if (get_keytypes & j) { 627ae1f160dSDag-Erling Smørgrav while (ncon >= MAXCON) 628ae1f160dSDag-Erling Smørgrav conloop(); 629ae1f160dSDag-Erling Smørgrav conalloc(name, *host ? host : name, j); 6301e8db6e2SBrian Feldman } 6311e8db6e2SBrian Feldman } 6321e8db6e2SBrian Feldman } 6331e8db6e2SBrian Feldman 6341e8db6e2SBrian Feldman void 63519261079SEd Maste sshfatal(const char *file, const char *func, int line, int showfunc, 63619261079SEd Maste LogLevel level, const char *suffix, const char *fmt, ...) 637ae1f160dSDag-Erling Smørgrav { 638ae1f160dSDag-Erling Smørgrav va_list args; 639f388f5efSDag-Erling Smørgrav 640ae1f160dSDag-Erling Smørgrav va_start(args, fmt); 64119261079SEd Maste sshlogv(file, func, line, showfunc, level, suffix, fmt, args); 642ae1f160dSDag-Erling Smørgrav va_end(args); 64319261079SEd Maste cleanup_exit(255); 644ae1f160dSDag-Erling Smørgrav } 645ae1f160dSDag-Erling Smørgrav 646ae1f160dSDag-Erling Smørgrav static void 6471e8db6e2SBrian Feldman usage(void) 6481e8db6e2SBrian Feldman { 649cce7d346SDag-Erling Smørgrav fprintf(stderr, 65047dd1d1bSDag-Erling Smørgrav "usage: %s [-46cDHv] [-f file] [-p port] [-T timeout] [-t type]\n" 65147dd1d1bSDag-Erling Smørgrav "\t\t [host | addrlist namelist]\n", 652ae1f160dSDag-Erling Smørgrav __progname); 653ae1f160dSDag-Erling Smørgrav exit(1); 6541e8db6e2SBrian Feldman } 6551e8db6e2SBrian Feldman 6561e8db6e2SBrian Feldman int 6571e8db6e2SBrian Feldman main(int argc, char **argv) 6581e8db6e2SBrian Feldman { 659ae1f160dSDag-Erling Smørgrav int debug_flag = 0, log_level = SYSLOG_LEVEL_INFO; 660e2f6069cSDag-Erling Smørgrav int opt, fopt_count = 0, j; 661190cef3dSDag-Erling Smørgrav char *tname, *cp, *line = NULL; 662190cef3dSDag-Erling Smørgrav size_t linesize = 0; 663e2f6069cSDag-Erling Smørgrav FILE *fp; 664ae1f160dSDag-Erling Smørgrav 665ae1f160dSDag-Erling Smørgrav extern int optind; 666ae1f160dSDag-Erling Smørgrav extern char *optarg; 6671e8db6e2SBrian Feldman 668cf2b5f3bSDag-Erling Smørgrav __progname = ssh_get_progname(argv[0]); 669989dd127SDag-Erling Smørgrav seed_rng(); 6701e8db6e2SBrian Feldman TAILQ_INIT(&tq); 6711e8db6e2SBrian Feldman 672b74df5b2SDag-Erling Smørgrav /* Ensure that fds 0, 1 and 2 are open or directed to /dev/null */ 673b74df5b2SDag-Erling Smørgrav sanitise_stdfd(); 674b74df5b2SDag-Erling Smørgrav 675ae1f160dSDag-Erling Smørgrav if (argc <= 1) 6761e8db6e2SBrian Feldman usage(); 6771e8db6e2SBrian Feldman 67847dd1d1bSDag-Erling Smørgrav while ((opt = getopt(argc, argv, "cDHv46p:T:t:f:")) != -1) { 679ae1f160dSDag-Erling Smørgrav switch (opt) { 680aa49c926SDag-Erling Smørgrav case 'H': 681aa49c926SDag-Erling Smørgrav hash_hosts = 1; 682aa49c926SDag-Erling Smørgrav break; 683acc1a9efSDag-Erling Smørgrav case 'c': 684acc1a9efSDag-Erling Smørgrav get_cert = 1; 685acc1a9efSDag-Erling Smørgrav break; 68647dd1d1bSDag-Erling Smørgrav case 'D': 68747dd1d1bSDag-Erling Smørgrav print_sshfp = 1; 68847dd1d1bSDag-Erling Smørgrav break; 689ae1f160dSDag-Erling Smørgrav case 'p': 690ae1f160dSDag-Erling Smørgrav ssh_port = a2port(optarg); 691cce7d346SDag-Erling Smørgrav if (ssh_port <= 0) { 692ae1f160dSDag-Erling Smørgrav fprintf(stderr, "Bad port '%s'\n", optarg); 693ae1f160dSDag-Erling Smørgrav exit(1); 6941e8db6e2SBrian Feldman } 695ae1f160dSDag-Erling Smørgrav break; 696ae1f160dSDag-Erling Smørgrav case 'T': 697f388f5efSDag-Erling Smørgrav timeout = convtime(optarg); 698f388f5efSDag-Erling Smørgrav if (timeout == -1 || timeout == 0) { 699f388f5efSDag-Erling Smørgrav fprintf(stderr, "Bad timeout '%s'\n", optarg); 7001e8db6e2SBrian Feldman usage(); 701f388f5efSDag-Erling Smørgrav } 702ae1f160dSDag-Erling Smørgrav break; 703ae1f160dSDag-Erling Smørgrav case 'v': 704ae1f160dSDag-Erling Smørgrav if (!debug_flag) { 705ae1f160dSDag-Erling Smørgrav debug_flag = 1; 706ae1f160dSDag-Erling Smørgrav log_level = SYSLOG_LEVEL_DEBUG1; 7071e8db6e2SBrian Feldman } 708ae1f160dSDag-Erling Smørgrav else if (log_level < SYSLOG_LEVEL_DEBUG3) 709ae1f160dSDag-Erling Smørgrav log_level++; 710ae1f160dSDag-Erling Smørgrav else 711ae1f160dSDag-Erling Smørgrav fatal("Too high debugging level."); 712ae1f160dSDag-Erling Smørgrav break; 713ae1f160dSDag-Erling Smørgrav case 'f': 714ae1f160dSDag-Erling Smørgrav if (strcmp(optarg, "-") == 0) 715ae1f160dSDag-Erling Smørgrav optarg = NULL; 716ae1f160dSDag-Erling Smørgrav argv[fopt_count++] = optarg; 717ae1f160dSDag-Erling Smørgrav break; 718ae1f160dSDag-Erling Smørgrav case 't': 719ae1f160dSDag-Erling Smørgrav get_keytypes = 0; 720ae1f160dSDag-Erling Smørgrav tname = strtok(optarg, ","); 721ae1f160dSDag-Erling Smørgrav while (tname) { 722bc5531deSDag-Erling Smørgrav int type = sshkey_type_from_name(tname); 723d93a896eSDag-Erling Smørgrav 724ae1f160dSDag-Erling Smørgrav switch (type) { 725ae1f160dSDag-Erling Smørgrav case KEY_DSA: 726ae1f160dSDag-Erling Smørgrav get_keytypes |= KT_DSA; 727ae1f160dSDag-Erling Smørgrav break; 7284a421b63SDag-Erling Smørgrav case KEY_ECDSA: 7294a421b63SDag-Erling Smørgrav get_keytypes |= KT_ECDSA; 7304a421b63SDag-Erling Smørgrav break; 731ae1f160dSDag-Erling Smørgrav case KEY_RSA: 732ae1f160dSDag-Erling Smørgrav get_keytypes |= KT_RSA; 733ae1f160dSDag-Erling Smørgrav break; 734f7167e0eSDag-Erling Smørgrav case KEY_ED25519: 735f7167e0eSDag-Erling Smørgrav get_keytypes |= KT_ED25519; 736f7167e0eSDag-Erling Smørgrav break; 73747dd1d1bSDag-Erling Smørgrav case KEY_XMSS: 73847dd1d1bSDag-Erling Smørgrav get_keytypes |= KT_XMSS; 73947dd1d1bSDag-Erling Smørgrav break; 74019261079SEd Maste case KEY_ED25519_SK: 74119261079SEd Maste get_keytypes |= KT_ED25519_SK; 74219261079SEd Maste break; 74319261079SEd Maste case KEY_ECDSA_SK: 74419261079SEd Maste get_keytypes |= KT_ECDSA_SK; 74519261079SEd Maste break; 746ae1f160dSDag-Erling Smørgrav case KEY_UNSPEC: 747d93a896eSDag-Erling Smørgrav default: 748d93a896eSDag-Erling Smørgrav fatal("Unknown key type \"%s\"", tname); 749ae1f160dSDag-Erling Smørgrav } 750ae1f160dSDag-Erling Smørgrav tname = strtok(NULL, ","); 751ae1f160dSDag-Erling Smørgrav } 752ae1f160dSDag-Erling Smørgrav break; 753ae1f160dSDag-Erling Smørgrav case '4': 754ae1f160dSDag-Erling Smørgrav IPv4or6 = AF_INET; 755ae1f160dSDag-Erling Smørgrav break; 756ae1f160dSDag-Erling Smørgrav case '6': 757ae1f160dSDag-Erling Smørgrav IPv4or6 = AF_INET6; 758ae1f160dSDag-Erling Smørgrav break; 759ae1f160dSDag-Erling Smørgrav case '?': 760ae1f160dSDag-Erling Smørgrav default: 7611e8db6e2SBrian Feldman usage(); 762ae1f160dSDag-Erling Smørgrav } 763ae1f160dSDag-Erling Smørgrav } 764ae1f160dSDag-Erling Smørgrav if (optind == argc && !fopt_count) 765ae1f160dSDag-Erling Smørgrav usage(); 766ae1f160dSDag-Erling Smørgrav 767ae1f160dSDag-Erling Smørgrav log_init("ssh-keyscan", log_level, SYSLOG_FACILITY_USER, 1); 7681e8db6e2SBrian Feldman 7691e8db6e2SBrian Feldman maxfd = fdlim_get(1); 7701e8db6e2SBrian Feldman if (maxfd < 0) 7711e8db6e2SBrian Feldman fatal("%s: fdlim_get: bad value", __progname); 7721e8db6e2SBrian Feldman if (maxfd > MAXMAXFD) 7731e8db6e2SBrian Feldman maxfd = MAXMAXFD; 7741e8db6e2SBrian Feldman if (MAXCON <= 0) 7751e8db6e2SBrian Feldman fatal("%s: not enough file descriptors", __progname); 7761e8db6e2SBrian Feldman if (maxfd > fdlim_get(0)) 7771e8db6e2SBrian Feldman fdlim_set(maxfd); 778333ee039SDag-Erling Smørgrav fdcon = xcalloc(maxfd, sizeof(con)); 779*1323ec57SEd Maste read_wait = xcalloc(maxfd, sizeof(struct pollfd)); 780*1323ec57SEd Maste for (j = 0; j < maxfd; j++) 781*1323ec57SEd Maste read_wait[j].fd = -1; 7821e8db6e2SBrian Feldman 783ae1f160dSDag-Erling Smørgrav for (j = 0; j < fopt_count; j++) { 784e2f6069cSDag-Erling Smørgrav if (argv[j] == NULL) 785e2f6069cSDag-Erling Smørgrav fp = stdin; 786e2f6069cSDag-Erling Smørgrav else if ((fp = fopen(argv[j], "r")) == NULL) 78719261079SEd Maste fatal("%s: %s: %s", __progname, argv[j], strerror(errno)); 788e2f6069cSDag-Erling Smørgrav 789190cef3dSDag-Erling Smørgrav while (getline(&line, &linesize, fp) != -1) { 790e2f6069cSDag-Erling Smørgrav /* Chomp off trailing whitespace and comments */ 791e2f6069cSDag-Erling Smørgrav if ((cp = strchr(line, '#')) == NULL) 792e2f6069cSDag-Erling Smørgrav cp = line + strlen(line) - 1; 793e2f6069cSDag-Erling Smørgrav while (cp >= line) { 794e2f6069cSDag-Erling Smørgrav if (*cp == ' ' || *cp == '\t' || 795e2f6069cSDag-Erling Smørgrav *cp == '\n' || *cp == '#') 796e2f6069cSDag-Erling Smørgrav *cp-- = '\0'; 797e2f6069cSDag-Erling Smørgrav else 798e2f6069cSDag-Erling Smørgrav break; 7991e8db6e2SBrian Feldman } 800e2f6069cSDag-Erling Smørgrav 801e2f6069cSDag-Erling Smørgrav /* Skip empty lines */ 802e2f6069cSDag-Erling Smørgrav if (*line == '\0') 803e2f6069cSDag-Erling Smørgrav continue; 804e2f6069cSDag-Erling Smørgrav 805e2f6069cSDag-Erling Smørgrav do_host(line); 806e2f6069cSDag-Erling Smørgrav } 807e2f6069cSDag-Erling Smørgrav 808e2f6069cSDag-Erling Smørgrav if (ferror(fp)) 80919261079SEd Maste fatal("%s: %s: %s", __progname, argv[j], strerror(errno)); 810e2f6069cSDag-Erling Smørgrav 811e2f6069cSDag-Erling Smørgrav fclose(fp); 812ae1f160dSDag-Erling Smørgrav } 813190cef3dSDag-Erling Smørgrav free(line); 814ae1f160dSDag-Erling Smørgrav 815ae1f160dSDag-Erling Smørgrav while (optind < argc) 816ae1f160dSDag-Erling Smørgrav do_host(argv[optind++]); 817ae1f160dSDag-Erling Smørgrav 8181e8db6e2SBrian Feldman while (ncon > 0) 8191e8db6e2SBrian Feldman conloop(); 8201e8db6e2SBrian Feldman 82119261079SEd Maste return found_one ? 0 : 1; 8221e8db6e2SBrian Feldman } 823