1*ee116499SAntonio Huete Jimenez /* $OpenBSD: ssh-keyscan.c,v 1.146 2022/08/19 04:02:46 dtucker Exp $ */
218de8d7fSPeter Avalos /*
318de8d7fSPeter Avalos * Copyright 1995, 1996 by David Mazieres <dm@lcs.mit.edu>.
418de8d7fSPeter Avalos *
518de8d7fSPeter Avalos * Modification and redistribution in source and binary forms is
618de8d7fSPeter Avalos * permitted provided that due credit is given to the author and the
718de8d7fSPeter Avalos * OpenBSD project by leaving this copyright notice intact.
818de8d7fSPeter Avalos */
918de8d7fSPeter Avalos
1018de8d7fSPeter Avalos #include "includes.h"
1118de8d7fSPeter Avalos
12e9778795SPeter Avalos #include <sys/types.h>
1318de8d7fSPeter Avalos #include "openbsd-compat/sys-queue.h"
1418de8d7fSPeter Avalos #include <sys/resource.h>
1518de8d7fSPeter Avalos #ifdef HAVE_SYS_TIME_H
1618de8d7fSPeter Avalos # include <sys/time.h>
1718de8d7fSPeter Avalos #endif
1818de8d7fSPeter Avalos
1918de8d7fSPeter Avalos #include <netinet/in.h>
2018de8d7fSPeter Avalos #include <arpa/inet.h>
2118de8d7fSPeter Avalos
220cbfa66cSDaniel Fojt #ifdef WITH_OPENSSL
2318de8d7fSPeter Avalos #include <openssl/bn.h>
240cbfa66cSDaniel Fojt #endif
2518de8d7fSPeter Avalos
2618de8d7fSPeter Avalos #include <netdb.h>
2718de8d7fSPeter Avalos #include <errno.h>
28*ee116499SAntonio Huete Jimenez #ifdef HAVE_POLL_H
29*ee116499SAntonio Huete Jimenez #include <poll.h>
30*ee116499SAntonio Huete Jimenez #endif
3118de8d7fSPeter Avalos #include <stdarg.h>
3218de8d7fSPeter Avalos #include <stdio.h>
3318de8d7fSPeter Avalos #include <stdlib.h>
3418de8d7fSPeter Avalos #include <signal.h>
3518de8d7fSPeter Avalos #include <string.h>
3618de8d7fSPeter Avalos #include <unistd.h>
3718de8d7fSPeter Avalos
3818de8d7fSPeter Avalos #include "xmalloc.h"
3918de8d7fSPeter Avalos #include "ssh.h"
40e9778795SPeter Avalos #include "sshbuf.h"
41e9778795SPeter Avalos #include "sshkey.h"
4218de8d7fSPeter Avalos #include "cipher.h"
4318de8d7fSPeter Avalos #include "kex.h"
4418de8d7fSPeter Avalos #include "compat.h"
4518de8d7fSPeter Avalos #include "myproposal.h"
4618de8d7fSPeter Avalos #include "packet.h"
4718de8d7fSPeter Avalos #include "dispatch.h"
4818de8d7fSPeter Avalos #include "log.h"
4918de8d7fSPeter Avalos #include "atomicio.h"
5018de8d7fSPeter Avalos #include "misc.h"
5118de8d7fSPeter Avalos #include "hostfile.h"
52e9778795SPeter Avalos #include "ssherr.h"
53e9778795SPeter Avalos #include "ssh_api.h"
54664f4763Szrj #include "dns.h"
5518de8d7fSPeter Avalos
5618de8d7fSPeter Avalos /* Flag indicating whether IPv4 or IPv6. This can be set on the command line.
5718de8d7fSPeter Avalos Default value is AF_UNSPEC means both IPv4 and IPv6. */
5818de8d7fSPeter Avalos int IPv4or6 = AF_UNSPEC;
5918de8d7fSPeter Avalos
6018de8d7fSPeter Avalos int ssh_port = SSH_DEFAULT_PORT;
6118de8d7fSPeter Avalos
62ce74bacaSMatthew Dillon #define KT_DSA (1)
63ce74bacaSMatthew Dillon #define KT_RSA (1<<1)
64ce74bacaSMatthew Dillon #define KT_ECDSA (1<<2)
65ce74bacaSMatthew Dillon #define KT_ED25519 (1<<3)
66664f4763Szrj #define KT_XMSS (1<<4)
670cbfa66cSDaniel Fojt #define KT_ECDSA_SK (1<<5)
680cbfa66cSDaniel Fojt #define KT_ED25519_SK (1<<6)
69ce74bacaSMatthew Dillon
70ce74bacaSMatthew Dillon #define KT_MIN KT_DSA
710cbfa66cSDaniel Fojt #define KT_MAX KT_ED25519_SK
7218de8d7fSPeter Avalos
73e9778795SPeter Avalos int get_cert = 0;
740cbfa66cSDaniel Fojt int get_keytypes = KT_RSA|KT_ECDSA|KT_ED25519|KT_ECDSA_SK|KT_ED25519_SK;
7518de8d7fSPeter Avalos
7618de8d7fSPeter Avalos int hash_hosts = 0; /* Hash hostname on output */
7718de8d7fSPeter Avalos
78664f4763Szrj int print_sshfp = 0; /* Print SSHFP records instead of known_hosts */
79664f4763Szrj
80664f4763Szrj int found_one = 0; /* Successfully found a key */
81664f4763Szrj
8218de8d7fSPeter Avalos #define MAXMAXFD 256
8318de8d7fSPeter Avalos
8418de8d7fSPeter Avalos /* The number of seconds after which to give up on a TCP connection */
8518de8d7fSPeter Avalos int timeout = 5;
8618de8d7fSPeter Avalos
8718de8d7fSPeter Avalos int maxfd;
8818de8d7fSPeter Avalos #define MAXCON (maxfd - 10)
8918de8d7fSPeter Avalos
9018de8d7fSPeter Avalos extern char *__progname;
91*ee116499SAntonio Huete Jimenez struct pollfd *read_wait;
9218de8d7fSPeter Avalos int ncon;
93e9778795SPeter Avalos
9418de8d7fSPeter Avalos /*
9518de8d7fSPeter Avalos * Keep a connection structure for each file descriptor. The state
9618de8d7fSPeter Avalos * associated with file descriptor n is held in fdcon[n].
9718de8d7fSPeter Avalos */
9818de8d7fSPeter Avalos typedef struct Connection {
9918de8d7fSPeter Avalos u_char c_status; /* State of connection on this file desc. */
10018de8d7fSPeter Avalos #define CS_UNUSED 0 /* File descriptor unused */
10118de8d7fSPeter Avalos #define CS_CON 1 /* Waiting to connect/read greeting */
10218de8d7fSPeter Avalos #define CS_SIZE 2 /* Waiting to read initial packet size */
10318de8d7fSPeter Avalos #define CS_KEYS 3 /* Waiting to read public key packet */
10418de8d7fSPeter Avalos int c_fd; /* Quick lookup: c->c_fd == c - fdcon */
10518de8d7fSPeter Avalos int c_plen; /* Packet length field for ssh packet */
10618de8d7fSPeter Avalos int c_len; /* Total bytes which must be read. */
10718de8d7fSPeter Avalos int c_off; /* Length of data read so far. */
108ce74bacaSMatthew Dillon int c_keytype; /* Only one of KT_* */
109e9778795SPeter Avalos sig_atomic_t c_done; /* SSH2 done */
11018de8d7fSPeter Avalos char *c_namebase; /* Address to free for c_name and c_namelist */
11118de8d7fSPeter Avalos char *c_name; /* Hostname of connection for errors */
11218de8d7fSPeter Avalos char *c_namelist; /* Pointer to other possible addresses */
11318de8d7fSPeter Avalos char *c_output_name; /* Hostname of connection for output */
11418de8d7fSPeter Avalos char *c_data; /* Data read from this fd */
115e9778795SPeter Avalos struct ssh *c_ssh; /* SSH-connection */
116*ee116499SAntonio Huete Jimenez struct timespec c_ts; /* Time at which connection gets aborted */
11718de8d7fSPeter Avalos TAILQ_ENTRY(Connection) c_link; /* List of connections in timeout order. */
11818de8d7fSPeter Avalos } con;
11918de8d7fSPeter Avalos
12018de8d7fSPeter Avalos TAILQ_HEAD(conlist, Connection) tq; /* Timeout Queue */
12118de8d7fSPeter Avalos con *fdcon;
12218de8d7fSPeter Avalos
123e9778795SPeter Avalos static void keyprint(con *c, struct sshkey *key);
124e9778795SPeter Avalos
12518de8d7fSPeter Avalos static int
fdlim_get(int hard)12618de8d7fSPeter Avalos fdlim_get(int hard)
12718de8d7fSPeter Avalos {
12818de8d7fSPeter Avalos #if defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE)
12918de8d7fSPeter Avalos struct rlimit rlfd;
13018de8d7fSPeter Avalos
1310cbfa66cSDaniel Fojt if (getrlimit(RLIMIT_NOFILE, &rlfd) == -1)
13218de8d7fSPeter Avalos return (-1);
13318de8d7fSPeter Avalos if ((hard ? rlfd.rlim_max : rlfd.rlim_cur) == RLIM_INFINITY)
13418de8d7fSPeter Avalos return SSH_SYSFDMAX;
13518de8d7fSPeter Avalos else
13618de8d7fSPeter Avalos return hard ? rlfd.rlim_max : rlfd.rlim_cur;
13718de8d7fSPeter Avalos #else
13818de8d7fSPeter Avalos return SSH_SYSFDMAX;
13918de8d7fSPeter Avalos #endif
14018de8d7fSPeter Avalos }
14118de8d7fSPeter Avalos
14218de8d7fSPeter Avalos static int
fdlim_set(int lim)14318de8d7fSPeter Avalos fdlim_set(int lim)
14418de8d7fSPeter Avalos {
14518de8d7fSPeter Avalos #if defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE)
14618de8d7fSPeter Avalos struct rlimit rlfd;
14718de8d7fSPeter Avalos #endif
14818de8d7fSPeter Avalos
14918de8d7fSPeter Avalos if (lim <= 0)
15018de8d7fSPeter Avalos return (-1);
15118de8d7fSPeter Avalos #if defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE)
1520cbfa66cSDaniel Fojt if (getrlimit(RLIMIT_NOFILE, &rlfd) == -1)
15318de8d7fSPeter Avalos return (-1);
15418de8d7fSPeter Avalos rlfd.rlim_cur = lim;
1550cbfa66cSDaniel Fojt if (setrlimit(RLIMIT_NOFILE, &rlfd) == -1)
15618de8d7fSPeter Avalos return (-1);
15718de8d7fSPeter Avalos #elif defined (HAVE_SETDTABLESIZE)
15818de8d7fSPeter Avalos setdtablesize(lim);
15918de8d7fSPeter Avalos #endif
16018de8d7fSPeter Avalos return (0);
16118de8d7fSPeter Avalos }
16218de8d7fSPeter Avalos
16318de8d7fSPeter Avalos /*
16418de8d7fSPeter Avalos * This is an strsep function that returns a null field for adjacent
16518de8d7fSPeter Avalos * separators. This is the same as the 4.4BSD strsep, but different from the
16618de8d7fSPeter Avalos * one in the GNU libc.
16718de8d7fSPeter Avalos */
16818de8d7fSPeter Avalos static char *
xstrsep(char ** str,const char * delim)16918de8d7fSPeter Avalos xstrsep(char **str, const char *delim)
17018de8d7fSPeter Avalos {
17118de8d7fSPeter Avalos char *s, *e;
17218de8d7fSPeter Avalos
17318de8d7fSPeter Avalos if (!**str)
17418de8d7fSPeter Avalos return (NULL);
17518de8d7fSPeter Avalos
17618de8d7fSPeter Avalos s = *str;
17718de8d7fSPeter Avalos e = s + strcspn(s, delim);
17818de8d7fSPeter Avalos
17918de8d7fSPeter Avalos if (*e != '\0')
18018de8d7fSPeter Avalos *e++ = '\0';
18118de8d7fSPeter Avalos *str = e;
18218de8d7fSPeter Avalos
18318de8d7fSPeter Avalos return (s);
18418de8d7fSPeter Avalos }
18518de8d7fSPeter Avalos
18618de8d7fSPeter Avalos /*
18718de8d7fSPeter Avalos * Get the next non-null token (like GNU strsep). Strsep() will return a
18818de8d7fSPeter Avalos * null token for two adjacent separators, so we may have to loop.
18918de8d7fSPeter Avalos */
19018de8d7fSPeter Avalos static char *
strnnsep(char ** stringp,char * delim)19118de8d7fSPeter Avalos strnnsep(char **stringp, char *delim)
19218de8d7fSPeter Avalos {
19318de8d7fSPeter Avalos char *tok;
19418de8d7fSPeter Avalos
19518de8d7fSPeter Avalos do {
19618de8d7fSPeter Avalos tok = xstrsep(stringp, delim);
19718de8d7fSPeter Avalos } while (tok && *tok == '\0');
19818de8d7fSPeter Avalos return (tok);
19918de8d7fSPeter Avalos }
20018de8d7fSPeter Avalos
20118de8d7fSPeter Avalos
20218de8d7fSPeter Avalos static int
key_print_wrapper(struct sshkey * hostkey,struct ssh * ssh)203e9778795SPeter Avalos key_print_wrapper(struct sshkey *hostkey, struct ssh *ssh)
20418de8d7fSPeter Avalos {
205e9778795SPeter Avalos con *c;
206e9778795SPeter Avalos
207e9778795SPeter Avalos if ((c = ssh_get_app_data(ssh)) != NULL)
208e9778795SPeter Avalos keyprint(c, hostkey);
209e9778795SPeter Avalos /* always abort key exchange */
210e9778795SPeter Avalos return -1;
21118de8d7fSPeter Avalos }
21218de8d7fSPeter Avalos
21318de8d7fSPeter Avalos static int
ssh2_capable(int remote_major,int remote_minor)21418de8d7fSPeter Avalos ssh2_capable(int remote_major, int remote_minor)
21518de8d7fSPeter Avalos {
21618de8d7fSPeter Avalos switch (remote_major) {
21718de8d7fSPeter Avalos case 1:
21818de8d7fSPeter Avalos if (remote_minor == 99)
21918de8d7fSPeter Avalos return 1;
22018de8d7fSPeter Avalos break;
22118de8d7fSPeter Avalos case 2:
22218de8d7fSPeter Avalos return 1;
22318de8d7fSPeter Avalos default:
22418de8d7fSPeter Avalos break;
22518de8d7fSPeter Avalos }
22618de8d7fSPeter Avalos return 0;
22718de8d7fSPeter Avalos }
22818de8d7fSPeter Avalos
229e9778795SPeter Avalos static void
keygrab_ssh2(con * c)23018de8d7fSPeter Avalos keygrab_ssh2(con *c)
23118de8d7fSPeter Avalos {
23236e94dc5SPeter Avalos char *myproposal[PROPOSAL_MAX] = { KEX_CLIENT };
233e9778795SPeter Avalos int r;
23418de8d7fSPeter Avalos
235e9778795SPeter Avalos switch (c->c_keytype) {
236e9778795SPeter Avalos case KT_DSA:
237e9778795SPeter Avalos myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] = get_cert ?
238e9778795SPeter Avalos "ssh-dss-cert-v01@openssh.com" : "ssh-dss";
239e9778795SPeter Avalos break;
240e9778795SPeter Avalos case KT_RSA:
241e9778795SPeter Avalos myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] = get_cert ?
2420cbfa66cSDaniel Fojt "rsa-sha2-512-cert-v01@openssh.com,"
2430cbfa66cSDaniel Fojt "rsa-sha2-256-cert-v01@openssh.com,"
2440cbfa66cSDaniel Fojt "ssh-rsa-cert-v01@openssh.com" :
2450cbfa66cSDaniel Fojt "rsa-sha2-512,"
2460cbfa66cSDaniel Fojt "rsa-sha2-256,"
2470cbfa66cSDaniel Fojt "ssh-rsa";
248e9778795SPeter Avalos break;
249e9778795SPeter Avalos case KT_ED25519:
250e9778795SPeter Avalos myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] = get_cert ?
251e9778795SPeter Avalos "ssh-ed25519-cert-v01@openssh.com" : "ssh-ed25519";
252e9778795SPeter Avalos break;
253664f4763Szrj case KT_XMSS:
254664f4763Szrj myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] = get_cert ?
255664f4763Szrj "ssh-xmss-cert-v01@openssh.com" : "ssh-xmss@openssh.com";
256664f4763Szrj break;
257e9778795SPeter Avalos case KT_ECDSA:
258e9778795SPeter Avalos myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] = get_cert ?
259e9778795SPeter Avalos "ecdsa-sha2-nistp256-cert-v01@openssh.com,"
260e9778795SPeter Avalos "ecdsa-sha2-nistp384-cert-v01@openssh.com,"
261e9778795SPeter Avalos "ecdsa-sha2-nistp521-cert-v01@openssh.com" :
262e9778795SPeter Avalos "ecdsa-sha2-nistp256,"
263e9778795SPeter Avalos "ecdsa-sha2-nistp384,"
264e9778795SPeter Avalos "ecdsa-sha2-nistp521";
265e9778795SPeter Avalos break;
2660cbfa66cSDaniel Fojt case KT_ECDSA_SK:
2670cbfa66cSDaniel Fojt myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] = get_cert ?
2680cbfa66cSDaniel Fojt "sk-ecdsa-sha2-nistp256-cert-v01@openssh.com" :
2690cbfa66cSDaniel Fojt "sk-ecdsa-sha2-nistp256@openssh.com";
2700cbfa66cSDaniel Fojt break;
2710cbfa66cSDaniel Fojt case KT_ED25519_SK:
2720cbfa66cSDaniel Fojt myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] = get_cert ?
2730cbfa66cSDaniel Fojt "sk-ssh-ed25519-cert-v01@openssh.com" :
2740cbfa66cSDaniel Fojt "sk-ssh-ed25519@openssh.com";
2750cbfa66cSDaniel Fojt break;
276e9778795SPeter Avalos default:
277e9778795SPeter Avalos fatal("unknown key type %d", c->c_keytype);
278e9778795SPeter Avalos break;
279e9778795SPeter Avalos }
280e9778795SPeter Avalos if ((r = kex_setup(c->c_ssh, myproposal)) != 0) {
281e9778795SPeter Avalos free(c->c_ssh);
282e9778795SPeter Avalos fprintf(stderr, "kex_setup: %s\n", ssh_err(r));
28318de8d7fSPeter Avalos exit(1);
28418de8d7fSPeter Avalos }
285e9778795SPeter Avalos #ifdef WITH_OPENSSL
286664f4763Szrj c->c_ssh->kex->kex[KEX_DH_GRP1_SHA1] = kex_gen_client;
287664f4763Szrj c->c_ssh->kex->kex[KEX_DH_GRP14_SHA1] = kex_gen_client;
288664f4763Szrj c->c_ssh->kex->kex[KEX_DH_GRP14_SHA256] = kex_gen_client;
289664f4763Szrj c->c_ssh->kex->kex[KEX_DH_GRP16_SHA512] = kex_gen_client;
290664f4763Szrj c->c_ssh->kex->kex[KEX_DH_GRP18_SHA512] = kex_gen_client;
291e9778795SPeter Avalos c->c_ssh->kex->kex[KEX_DH_GEX_SHA1] = kexgex_client;
292e9778795SPeter Avalos c->c_ssh->kex->kex[KEX_DH_GEX_SHA256] = kexgex_client;
293e9778795SPeter Avalos # ifdef OPENSSL_HAS_ECC
294664f4763Szrj c->c_ssh->kex->kex[KEX_ECDH_SHA2] = kex_gen_client;
295e9778795SPeter Avalos # endif
296e9778795SPeter Avalos #endif
297664f4763Szrj c->c_ssh->kex->kex[KEX_C25519_SHA256] = kex_gen_client;
29850a69bb5SSascha Wildner c->c_ssh->kex->kex[KEX_KEM_SNTRUP761X25519_SHA512] = kex_gen_client;
299e9778795SPeter Avalos ssh_set_verify_host_key_callback(c->c_ssh, key_print_wrapper);
300e9778795SPeter Avalos /*
301e9778795SPeter Avalos * do the key-exchange until an error occurs or until
302e9778795SPeter Avalos * the key_print_wrapper() callback sets c_done.
303e9778795SPeter Avalos */
304ce74bacaSMatthew Dillon ssh_dispatch_run(c->c_ssh, DISPATCH_BLOCK, &c->c_done);
30518de8d7fSPeter Avalos }
30618de8d7fSPeter Avalos
30718de8d7fSPeter Avalos static void
keyprint_one(const char * host,struct sshkey * key)308ce74bacaSMatthew Dillon keyprint_one(const char *host, struct sshkey *key)
30918de8d7fSPeter Avalos {
310*ee116499SAntonio Huete Jimenez char *hostport = NULL, *hashed = NULL;
311*ee116499SAntonio Huete Jimenez const char *known_host;
31218de8d7fSPeter Avalos
313664f4763Szrj found_one = 1;
314664f4763Szrj
315664f4763Szrj if (print_sshfp) {
316664f4763Szrj export_dns_rr(host, key, stdout, 0);
317664f4763Szrj return;
318664f4763Szrj }
319664f4763Szrj
320e9778795SPeter Avalos hostport = put_host_port(host, ssh_port);
321ce74bacaSMatthew Dillon lowercase(hostport);
322*ee116499SAntonio Huete Jimenez if (hash_hosts && (hashed = host_hash(hostport, NULL, 0)) == NULL)
323ce74bacaSMatthew Dillon fatal("host_hash failed");
324ce74bacaSMatthew Dillon known_host = hash_hosts ? hashed : hostport;
325e9778795SPeter Avalos if (!get_cert)
326ce74bacaSMatthew Dillon fprintf(stdout, "%s ", known_host);
327e9778795SPeter Avalos sshkey_write(key, stdout);
32818de8d7fSPeter Avalos fputs("\n", stdout);
329*ee116499SAntonio Huete Jimenez free(hashed);
330e9778795SPeter Avalos free(hostport);
331e9778795SPeter Avalos }
332e9778795SPeter Avalos
333e9778795SPeter Avalos static void
keyprint(con * c,struct sshkey * key)334e9778795SPeter Avalos keyprint(con *c, struct sshkey *key)
335e9778795SPeter Avalos {
336e9778795SPeter Avalos char *hosts = c->c_output_name ? c->c_output_name : c->c_name;
337e9778795SPeter Avalos char *host, *ohosts;
338e9778795SPeter Avalos
339e9778795SPeter Avalos if (key == NULL)
340e9778795SPeter Avalos return;
341e9778795SPeter Avalos if (get_cert || (!hash_hosts && ssh_port == SSH_DEFAULT_PORT)) {
342e9778795SPeter Avalos keyprint_one(hosts, key);
343e9778795SPeter Avalos return;
344e9778795SPeter Avalos }
345e9778795SPeter Avalos ohosts = hosts = xstrdup(hosts);
346e9778795SPeter Avalos while ((host = strsep(&hosts, ",")) != NULL)
347e9778795SPeter Avalos keyprint_one(host, key);
348e9778795SPeter Avalos free(ohosts);
34918de8d7fSPeter Avalos }
35018de8d7fSPeter Avalos
35118de8d7fSPeter Avalos static int
tcpconnect(char * host)35218de8d7fSPeter Avalos tcpconnect(char *host)
35318de8d7fSPeter Avalos {
35418de8d7fSPeter Avalos struct addrinfo hints, *ai, *aitop;
35518de8d7fSPeter Avalos char strport[NI_MAXSERV];
35618de8d7fSPeter Avalos int gaierr, s = -1;
35718de8d7fSPeter Avalos
35818de8d7fSPeter Avalos snprintf(strport, sizeof strport, "%d", ssh_port);
35918de8d7fSPeter Avalos memset(&hints, 0, sizeof(hints));
36018de8d7fSPeter Avalos hints.ai_family = IPv4or6;
36118de8d7fSPeter Avalos hints.ai_socktype = SOCK_STREAM;
362e9778795SPeter Avalos if ((gaierr = getaddrinfo(host, strport, &hints, &aitop)) != 0) {
363e9778795SPeter Avalos error("getaddrinfo %s: %s", host, ssh_gai_strerror(gaierr));
364e9778795SPeter Avalos return -1;
365e9778795SPeter Avalos }
36618de8d7fSPeter Avalos for (ai = aitop; ai; ai = ai->ai_next) {
36718de8d7fSPeter Avalos s = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
3680cbfa66cSDaniel Fojt if (s == -1) {
36918de8d7fSPeter Avalos error("socket: %s", strerror(errno));
37018de8d7fSPeter Avalos continue;
37118de8d7fSPeter Avalos }
37218de8d7fSPeter Avalos if (set_nonblock(s) == -1)
37350a69bb5SSascha Wildner fatal_f("set_nonblock(%d)", s);
3740cbfa66cSDaniel Fojt if (connect(s, ai->ai_addr, ai->ai_addrlen) == -1 &&
37518de8d7fSPeter Avalos errno != EINPROGRESS)
37618de8d7fSPeter Avalos error("connect (`%s'): %s", host, strerror(errno));
37718de8d7fSPeter Avalos else
37818de8d7fSPeter Avalos break;
37918de8d7fSPeter Avalos close(s);
38018de8d7fSPeter Avalos s = -1;
38118de8d7fSPeter Avalos }
38218de8d7fSPeter Avalos freeaddrinfo(aitop);
38318de8d7fSPeter Avalos return s;
38418de8d7fSPeter Avalos }
38518de8d7fSPeter Avalos
38618de8d7fSPeter Avalos static int
conalloc(char * iname,char * oname,int keytype)38718de8d7fSPeter Avalos conalloc(char *iname, char *oname, int keytype)
38818de8d7fSPeter Avalos {
38918de8d7fSPeter Avalos char *namebase, *name, *namelist;
39018de8d7fSPeter Avalos int s;
39118de8d7fSPeter Avalos
39218de8d7fSPeter Avalos namebase = namelist = xstrdup(iname);
39318de8d7fSPeter Avalos
39418de8d7fSPeter Avalos do {
39518de8d7fSPeter Avalos name = xstrsep(&namelist, ",");
39618de8d7fSPeter Avalos if (!name) {
39736e94dc5SPeter Avalos free(namebase);
39818de8d7fSPeter Avalos return (-1);
39918de8d7fSPeter Avalos }
40018de8d7fSPeter Avalos } while ((s = tcpconnect(name)) < 0);
40118de8d7fSPeter Avalos
40218de8d7fSPeter Avalos if (s >= maxfd)
40318de8d7fSPeter Avalos fatal("conalloc: fdno %d too high", s);
40418de8d7fSPeter Avalos if (fdcon[s].c_status)
40518de8d7fSPeter Avalos fatal("conalloc: attempt to reuse fdno %d", s);
40618de8d7fSPeter Avalos
40750a69bb5SSascha Wildner debug3_f("oname %s kt %d", oname, keytype);
40818de8d7fSPeter Avalos fdcon[s].c_fd = s;
40918de8d7fSPeter Avalos fdcon[s].c_status = CS_CON;
41018de8d7fSPeter Avalos fdcon[s].c_namebase = namebase;
41118de8d7fSPeter Avalos fdcon[s].c_name = name;
41218de8d7fSPeter Avalos fdcon[s].c_namelist = namelist;
41318de8d7fSPeter Avalos fdcon[s].c_output_name = xstrdup(oname);
41418de8d7fSPeter Avalos fdcon[s].c_data = (char *) &fdcon[s].c_plen;
41518de8d7fSPeter Avalos fdcon[s].c_len = 4;
41618de8d7fSPeter Avalos fdcon[s].c_off = 0;
41718de8d7fSPeter Avalos fdcon[s].c_keytype = keytype;
418*ee116499SAntonio Huete Jimenez monotime_ts(&fdcon[s].c_ts);
419*ee116499SAntonio Huete Jimenez fdcon[s].c_ts.tv_sec += timeout;
42018de8d7fSPeter Avalos TAILQ_INSERT_TAIL(&tq, &fdcon[s], c_link);
421*ee116499SAntonio Huete Jimenez read_wait[s].fd = s;
422*ee116499SAntonio Huete Jimenez read_wait[s].events = POLLIN;
42318de8d7fSPeter Avalos ncon++;
42418de8d7fSPeter Avalos return (s);
42518de8d7fSPeter Avalos }
42618de8d7fSPeter Avalos
42718de8d7fSPeter Avalos static void
confree(int s)42818de8d7fSPeter Avalos confree(int s)
42918de8d7fSPeter Avalos {
43018de8d7fSPeter Avalos if (s >= maxfd || fdcon[s].c_status == CS_UNUSED)
43118de8d7fSPeter Avalos fatal("confree: attempt to free bad fdno %d", s);
43236e94dc5SPeter Avalos free(fdcon[s].c_namebase);
43336e94dc5SPeter Avalos free(fdcon[s].c_output_name);
43418de8d7fSPeter Avalos if (fdcon[s].c_status == CS_KEYS)
43536e94dc5SPeter Avalos free(fdcon[s].c_data);
43618de8d7fSPeter Avalos fdcon[s].c_status = CS_UNUSED;
43718de8d7fSPeter Avalos fdcon[s].c_keytype = 0;
438e9778795SPeter Avalos if (fdcon[s].c_ssh) {
439e9778795SPeter Avalos ssh_packet_close(fdcon[s].c_ssh);
440e9778795SPeter Avalos free(fdcon[s].c_ssh);
441e9778795SPeter Avalos fdcon[s].c_ssh = NULL;
442ce74bacaSMatthew Dillon } else
443ce74bacaSMatthew Dillon close(s);
44418de8d7fSPeter Avalos TAILQ_REMOVE(&tq, &fdcon[s], c_link);
445*ee116499SAntonio Huete Jimenez read_wait[s].fd = -1;
446*ee116499SAntonio Huete Jimenez read_wait[s].events = 0;
44718de8d7fSPeter Avalos ncon--;
44818de8d7fSPeter Avalos }
44918de8d7fSPeter Avalos
45018de8d7fSPeter Avalos static void
contouch(int s)45118de8d7fSPeter Avalos contouch(int s)
45218de8d7fSPeter Avalos {
45318de8d7fSPeter Avalos TAILQ_REMOVE(&tq, &fdcon[s], c_link);
454*ee116499SAntonio Huete Jimenez monotime_ts(&fdcon[s].c_ts);
455*ee116499SAntonio Huete Jimenez fdcon[s].c_ts.tv_sec += timeout;
45618de8d7fSPeter Avalos TAILQ_INSERT_TAIL(&tq, &fdcon[s], c_link);
45718de8d7fSPeter Avalos }
45818de8d7fSPeter Avalos
45918de8d7fSPeter Avalos static int
conrecycle(int s)46018de8d7fSPeter Avalos conrecycle(int s)
46118de8d7fSPeter Avalos {
46218de8d7fSPeter Avalos con *c = &fdcon[s];
46318de8d7fSPeter Avalos int ret;
46418de8d7fSPeter Avalos
46518de8d7fSPeter Avalos ret = conalloc(c->c_namelist, c->c_output_name, c->c_keytype);
46618de8d7fSPeter Avalos confree(s);
46718de8d7fSPeter Avalos return (ret);
46818de8d7fSPeter Avalos }
46918de8d7fSPeter Avalos
47018de8d7fSPeter Avalos static void
congreet(int s)47118de8d7fSPeter Avalos congreet(int s)
47218de8d7fSPeter Avalos {
47318de8d7fSPeter Avalos int n = 0, remote_major = 0, remote_minor = 0;
47418de8d7fSPeter Avalos char buf[256], *cp;
47518de8d7fSPeter Avalos char remote_version[sizeof buf];
47618de8d7fSPeter Avalos size_t bufsiz;
47718de8d7fSPeter Avalos con *c = &fdcon[s];
47818de8d7fSPeter Avalos
479ce74bacaSMatthew Dillon /* send client banner */
480ce74bacaSMatthew Dillon n = snprintf(buf, sizeof buf, "SSH-%d.%d-OpenSSH-keyscan\r\n",
481ce74bacaSMatthew Dillon PROTOCOL_MAJOR_2, PROTOCOL_MINOR_2);
482ce74bacaSMatthew Dillon if (n < 0 || (size_t)n >= sizeof(buf)) {
483ce74bacaSMatthew Dillon error("snprintf: buffer too small");
484ce74bacaSMatthew Dillon confree(s);
485ce74bacaSMatthew Dillon return;
486ce74bacaSMatthew Dillon }
487ce74bacaSMatthew Dillon if (atomicio(vwrite, s, buf, n) != (size_t)n) {
488ce74bacaSMatthew Dillon error("write (%s): %s", c->c_name, strerror(errno));
489ce74bacaSMatthew Dillon confree(s);
490ce74bacaSMatthew Dillon return;
491ce74bacaSMatthew Dillon }
492ce74bacaSMatthew Dillon
493*ee116499SAntonio Huete Jimenez /*
494*ee116499SAntonio Huete Jimenez * Read the server banner as per RFC4253 section 4.2. The "SSH-"
495*ee116499SAntonio Huete Jimenez * protocol identification string may be preceeded by an arbitarily
496*ee116499SAntonio Huete Jimenez * large banner which we must read and ignore. Loop while reading
497*ee116499SAntonio Huete Jimenez * newline-terminated lines until we have one starting with "SSH-".
498*ee116499SAntonio Huete Jimenez * The ID string cannot be longer than 255 characters although the
499*ee116499SAntonio Huete Jimenez * preceeding banner lines may (in which case they'll be discarded
500*ee116499SAntonio Huete Jimenez * in multiple iterations of the outer loop).
501*ee116499SAntonio Huete Jimenez */
50218de8d7fSPeter Avalos for (;;) {
50318de8d7fSPeter Avalos memset(buf, '\0', sizeof(buf));
50418de8d7fSPeter Avalos bufsiz = sizeof(buf);
50518de8d7fSPeter Avalos cp = buf;
50618de8d7fSPeter Avalos while (bufsiz-- &&
50718de8d7fSPeter Avalos (n = atomicio(read, s, cp, 1)) == 1 && *cp != '\n') {
50818de8d7fSPeter Avalos if (*cp == '\r')
50918de8d7fSPeter Avalos *cp = '\n';
51018de8d7fSPeter Avalos cp++;
51118de8d7fSPeter Avalos }
51218de8d7fSPeter Avalos if (n != 1 || strncmp(buf, "SSH-", 4) == 0)
51318de8d7fSPeter Avalos break;
51418de8d7fSPeter Avalos }
51518de8d7fSPeter Avalos if (n == 0) {
51618de8d7fSPeter Avalos switch (errno) {
51718de8d7fSPeter Avalos case EPIPE:
51818de8d7fSPeter Avalos error("%s: Connection closed by remote host", c->c_name);
51918de8d7fSPeter Avalos break;
52018de8d7fSPeter Avalos case ECONNREFUSED:
52118de8d7fSPeter Avalos break;
52218de8d7fSPeter Avalos default:
52318de8d7fSPeter Avalos error("read (%s): %s", c->c_name, strerror(errno));
52418de8d7fSPeter Avalos break;
52518de8d7fSPeter Avalos }
52618de8d7fSPeter Avalos conrecycle(s);
52718de8d7fSPeter Avalos return;
52818de8d7fSPeter Avalos }
529*ee116499SAntonio Huete Jimenez if (cp >= buf + sizeof(buf)) {
530*ee116499SAntonio Huete Jimenez error("%s: greeting exceeds allowable length", c->c_name);
531*ee116499SAntonio Huete Jimenez confree(s);
532*ee116499SAntonio Huete Jimenez return;
533*ee116499SAntonio Huete Jimenez }
53418de8d7fSPeter Avalos if (*cp != '\n' && *cp != '\r') {
53518de8d7fSPeter Avalos error("%s: bad greeting", c->c_name);
53618de8d7fSPeter Avalos confree(s);
53718de8d7fSPeter Avalos return;
53818de8d7fSPeter Avalos }
53918de8d7fSPeter Avalos *cp = '\0';
540e9778795SPeter Avalos if ((c->c_ssh = ssh_packet_set_connection(NULL, s, s)) == NULL)
541e9778795SPeter Avalos fatal("ssh_packet_set_connection failed");
542e9778795SPeter Avalos ssh_packet_set_timeout(c->c_ssh, timeout, 1);
543e9778795SPeter Avalos ssh_set_app_data(c->c_ssh, c); /* back link */
54450a69bb5SSascha Wildner c->c_ssh->compat = 0;
54518de8d7fSPeter Avalos if (sscanf(buf, "SSH-%d.%d-%[^\n]\n",
54618de8d7fSPeter Avalos &remote_major, &remote_minor, remote_version) == 3)
54750a69bb5SSascha Wildner compat_banner(c->c_ssh, remote_version);
54818de8d7fSPeter Avalos if (!ssh2_capable(remote_major, remote_minor)) {
54918de8d7fSPeter Avalos debug("%s doesn't support ssh2", c->c_name);
55018de8d7fSPeter Avalos confree(s);
55118de8d7fSPeter Avalos return;
55218de8d7fSPeter Avalos }
553664f4763Szrj fprintf(stderr, "%c %s:%d %s\n", print_sshfp ? ';' : '#',
554664f4763Szrj c->c_name, ssh_port, chop(buf));
555e9778795SPeter Avalos keygrab_ssh2(c);
55618de8d7fSPeter Avalos confree(s);
55718de8d7fSPeter Avalos }
55818de8d7fSPeter Avalos
55918de8d7fSPeter Avalos static void
conread(int s)56018de8d7fSPeter Avalos conread(int s)
56118de8d7fSPeter Avalos {
56218de8d7fSPeter Avalos con *c = &fdcon[s];
56318de8d7fSPeter Avalos size_t n;
56418de8d7fSPeter Avalos
56518de8d7fSPeter Avalos if (c->c_status == CS_CON) {
56618de8d7fSPeter Avalos congreet(s);
56718de8d7fSPeter Avalos return;
56818de8d7fSPeter Avalos }
56918de8d7fSPeter Avalos n = atomicio(read, s, c->c_data + c->c_off, c->c_len - c->c_off);
57018de8d7fSPeter Avalos if (n == 0) {
57118de8d7fSPeter Avalos error("read (%s): %s", c->c_name, strerror(errno));
57218de8d7fSPeter Avalos confree(s);
57318de8d7fSPeter Avalos return;
57418de8d7fSPeter Avalos }
57518de8d7fSPeter Avalos c->c_off += n;
57618de8d7fSPeter Avalos
57718de8d7fSPeter Avalos if (c->c_off == c->c_len)
57818de8d7fSPeter Avalos switch (c->c_status) {
57918de8d7fSPeter Avalos case CS_SIZE:
58018de8d7fSPeter Avalos c->c_plen = htonl(c->c_plen);
58118de8d7fSPeter Avalos c->c_len = c->c_plen + 8 - (c->c_plen & 7);
58218de8d7fSPeter Avalos c->c_off = 0;
58318de8d7fSPeter Avalos c->c_data = xmalloc(c->c_len);
58418de8d7fSPeter Avalos c->c_status = CS_KEYS;
58518de8d7fSPeter Avalos break;
58618de8d7fSPeter Avalos default:
58718de8d7fSPeter Avalos fatal("conread: invalid status %d", c->c_status);
58818de8d7fSPeter Avalos break;
58918de8d7fSPeter Avalos }
59018de8d7fSPeter Avalos
59118de8d7fSPeter Avalos contouch(s);
59218de8d7fSPeter Avalos }
59318de8d7fSPeter Avalos
59418de8d7fSPeter Avalos static void
conloop(void)59518de8d7fSPeter Avalos conloop(void)
59618de8d7fSPeter Avalos {
597*ee116499SAntonio Huete Jimenez struct timespec seltime, now;
59818de8d7fSPeter Avalos con *c;
59918de8d7fSPeter Avalos int i;
60018de8d7fSPeter Avalos
601*ee116499SAntonio Huete Jimenez monotime_ts(&now);
60218de8d7fSPeter Avalos c = TAILQ_FIRST(&tq);
60318de8d7fSPeter Avalos
604*ee116499SAntonio Huete Jimenez if (c && timespeccmp(&c->c_ts, &now, >))
605*ee116499SAntonio Huete Jimenez timespecsub(&c->c_ts, &now, &seltime);
60650a69bb5SSascha Wildner else
607*ee116499SAntonio Huete Jimenez timespecclear(&seltime);
60818de8d7fSPeter Avalos
609*ee116499SAntonio Huete Jimenez while (ppoll(read_wait, maxfd, &seltime, NULL) == -1) {
610*ee116499SAntonio Huete Jimenez if (errno == EAGAIN || errno == EINTR || errno == EWOULDBLOCK)
611*ee116499SAntonio Huete Jimenez continue;
612*ee116499SAntonio Huete Jimenez error("poll error");
613*ee116499SAntonio Huete Jimenez }
61418de8d7fSPeter Avalos
61518de8d7fSPeter Avalos for (i = 0; i < maxfd; i++) {
616*ee116499SAntonio Huete Jimenez if (read_wait[i].revents & (POLLHUP|POLLERR|POLLNVAL))
61718de8d7fSPeter Avalos confree(i);
618*ee116499SAntonio Huete Jimenez else if (read_wait[i].revents & (POLLIN|POLLHUP))
61918de8d7fSPeter Avalos conread(i);
62018de8d7fSPeter Avalos }
62118de8d7fSPeter Avalos
62218de8d7fSPeter Avalos c = TAILQ_FIRST(&tq);
623*ee116499SAntonio Huete Jimenez while (c && timespeccmp(&c->c_ts, &now, <)) {
62418de8d7fSPeter Avalos int s = c->c_fd;
62518de8d7fSPeter Avalos
62618de8d7fSPeter Avalos c = TAILQ_NEXT(c, c_link);
62718de8d7fSPeter Avalos conrecycle(s);
62818de8d7fSPeter Avalos }
62918de8d7fSPeter Avalos }
63018de8d7fSPeter Avalos
63118de8d7fSPeter Avalos static void
do_host(char * host)63218de8d7fSPeter Avalos do_host(char *host)
63318de8d7fSPeter Avalos {
63418de8d7fSPeter Avalos char *name = strnnsep(&host, " \t\n");
63518de8d7fSPeter Avalos int j;
63618de8d7fSPeter Avalos
63718de8d7fSPeter Avalos if (name == NULL)
63818de8d7fSPeter Avalos return;
639ce74bacaSMatthew Dillon for (j = KT_MIN; j <= KT_MAX; j *= 2) {
64018de8d7fSPeter Avalos if (get_keytypes & j) {
64118de8d7fSPeter Avalos while (ncon >= MAXCON)
64218de8d7fSPeter Avalos conloop();
64318de8d7fSPeter Avalos conalloc(name, *host ? host : name, j);
64418de8d7fSPeter Avalos }
64518de8d7fSPeter Avalos }
64618de8d7fSPeter Avalos }
64718de8d7fSPeter Avalos
64818de8d7fSPeter Avalos void
sshfatal(const char * file,const char * func,int line,int showfunc,LogLevel level,const char * suffix,const char * fmt,...)64950a69bb5SSascha Wildner sshfatal(const char *file, const char *func, int line, int showfunc,
65050a69bb5SSascha Wildner LogLevel level, const char *suffix, const char *fmt, ...)
65118de8d7fSPeter Avalos {
65218de8d7fSPeter Avalos va_list args;
65318de8d7fSPeter Avalos
65418de8d7fSPeter Avalos va_start(args, fmt);
65550a69bb5SSascha Wildner sshlogv(file, func, line, showfunc, level, suffix, fmt, args);
65618de8d7fSPeter Avalos va_end(args);
65750a69bb5SSascha Wildner cleanup_exit(255);
65818de8d7fSPeter Avalos }
65918de8d7fSPeter Avalos
66018de8d7fSPeter Avalos static void
usage(void)66118de8d7fSPeter Avalos usage(void)
66218de8d7fSPeter Avalos {
663cb5eb4f1SPeter Avalos fprintf(stderr,
664664f4763Szrj "usage: %s [-46cDHv] [-f file] [-p port] [-T timeout] [-t type]\n"
665664f4763Szrj "\t\t [host | addrlist namelist]\n",
66618de8d7fSPeter Avalos __progname);
66718de8d7fSPeter Avalos exit(1);
66818de8d7fSPeter Avalos }
66918de8d7fSPeter Avalos
67018de8d7fSPeter Avalos int
main(int argc,char ** argv)67118de8d7fSPeter Avalos main(int argc, char **argv)
67218de8d7fSPeter Avalos {
67318de8d7fSPeter Avalos int debug_flag = 0, log_level = SYSLOG_LEVEL_INFO;
674856ea928SPeter Avalos int opt, fopt_count = 0, j;
675664f4763Szrj char *tname, *cp, *line = NULL;
676664f4763Szrj size_t linesize = 0;
677856ea928SPeter Avalos FILE *fp;
67818de8d7fSPeter Avalos
67918de8d7fSPeter Avalos extern int optind;
68018de8d7fSPeter Avalos extern char *optarg;
68118de8d7fSPeter Avalos
68218de8d7fSPeter Avalos __progname = ssh_get_progname(argv[0]);
68318de8d7fSPeter Avalos seed_rng();
68418de8d7fSPeter Avalos TAILQ_INIT(&tq);
68518de8d7fSPeter Avalos
68618de8d7fSPeter Avalos /* Ensure that fds 0, 1 and 2 are open or directed to /dev/null */
68718de8d7fSPeter Avalos sanitise_stdfd();
68818de8d7fSPeter Avalos
68918de8d7fSPeter Avalos if (argc <= 1)
69018de8d7fSPeter Avalos usage();
69118de8d7fSPeter Avalos
692664f4763Szrj while ((opt = getopt(argc, argv, "cDHv46p:T:t:f:")) != -1) {
69318de8d7fSPeter Avalos switch (opt) {
69418de8d7fSPeter Avalos case 'H':
69518de8d7fSPeter Avalos hash_hosts = 1;
69618de8d7fSPeter Avalos break;
697e9778795SPeter Avalos case 'c':
698e9778795SPeter Avalos get_cert = 1;
699e9778795SPeter Avalos break;
700664f4763Szrj case 'D':
701664f4763Szrj print_sshfp = 1;
702664f4763Szrj break;
70318de8d7fSPeter Avalos case 'p':
70418de8d7fSPeter Avalos ssh_port = a2port(optarg);
705cb5eb4f1SPeter Avalos if (ssh_port <= 0) {
70618de8d7fSPeter Avalos fprintf(stderr, "Bad port '%s'\n", optarg);
70718de8d7fSPeter Avalos exit(1);
70818de8d7fSPeter Avalos }
70918de8d7fSPeter Avalos break;
71018de8d7fSPeter Avalos case 'T':
71118de8d7fSPeter Avalos timeout = convtime(optarg);
71218de8d7fSPeter Avalos if (timeout == -1 || timeout == 0) {
71318de8d7fSPeter Avalos fprintf(stderr, "Bad timeout '%s'\n", optarg);
71418de8d7fSPeter Avalos usage();
71518de8d7fSPeter Avalos }
71618de8d7fSPeter Avalos break;
71718de8d7fSPeter Avalos case 'v':
71818de8d7fSPeter Avalos if (!debug_flag) {
71918de8d7fSPeter Avalos debug_flag = 1;
72018de8d7fSPeter Avalos log_level = SYSLOG_LEVEL_DEBUG1;
72118de8d7fSPeter Avalos }
72218de8d7fSPeter Avalos else if (log_level < SYSLOG_LEVEL_DEBUG3)
72318de8d7fSPeter Avalos log_level++;
72418de8d7fSPeter Avalos else
72518de8d7fSPeter Avalos fatal("Too high debugging level.");
72618de8d7fSPeter Avalos break;
72718de8d7fSPeter Avalos case 'f':
72818de8d7fSPeter Avalos if (strcmp(optarg, "-") == 0)
72918de8d7fSPeter Avalos optarg = NULL;
73018de8d7fSPeter Avalos argv[fopt_count++] = optarg;
73118de8d7fSPeter Avalos break;
73218de8d7fSPeter Avalos case 't':
73318de8d7fSPeter Avalos get_keytypes = 0;
73418de8d7fSPeter Avalos tname = strtok(optarg, ",");
73518de8d7fSPeter Avalos while (tname) {
736e9778795SPeter Avalos int type = sshkey_type_from_name(tname);
737ce74bacaSMatthew Dillon
73818de8d7fSPeter Avalos switch (type) {
73918de8d7fSPeter Avalos case KEY_DSA:
74018de8d7fSPeter Avalos get_keytypes |= KT_DSA;
74118de8d7fSPeter Avalos break;
7429f304aafSPeter Avalos case KEY_ECDSA:
7439f304aafSPeter Avalos get_keytypes |= KT_ECDSA;
7449f304aafSPeter Avalos break;
74518de8d7fSPeter Avalos case KEY_RSA:
74618de8d7fSPeter Avalos get_keytypes |= KT_RSA;
74718de8d7fSPeter Avalos break;
74836e94dc5SPeter Avalos case KEY_ED25519:
74936e94dc5SPeter Avalos get_keytypes |= KT_ED25519;
75036e94dc5SPeter Avalos break;
751664f4763Szrj case KEY_XMSS:
752664f4763Szrj get_keytypes |= KT_XMSS;
753664f4763Szrj break;
7540cbfa66cSDaniel Fojt case KEY_ED25519_SK:
7550cbfa66cSDaniel Fojt get_keytypes |= KT_ED25519_SK;
7560cbfa66cSDaniel Fojt break;
7570cbfa66cSDaniel Fojt case KEY_ECDSA_SK:
7580cbfa66cSDaniel Fojt get_keytypes |= KT_ECDSA_SK;
7590cbfa66cSDaniel Fojt break;
76018de8d7fSPeter Avalos case KEY_UNSPEC:
761ce74bacaSMatthew Dillon default:
762ce74bacaSMatthew Dillon fatal("Unknown key type \"%s\"", tname);
76318de8d7fSPeter Avalos }
76418de8d7fSPeter Avalos tname = strtok(NULL, ",");
76518de8d7fSPeter Avalos }
76618de8d7fSPeter Avalos break;
76718de8d7fSPeter Avalos case '4':
76818de8d7fSPeter Avalos IPv4or6 = AF_INET;
76918de8d7fSPeter Avalos break;
77018de8d7fSPeter Avalos case '6':
77118de8d7fSPeter Avalos IPv4or6 = AF_INET6;
77218de8d7fSPeter Avalos break;
77318de8d7fSPeter Avalos case '?':
77418de8d7fSPeter Avalos default:
77518de8d7fSPeter Avalos usage();
77618de8d7fSPeter Avalos }
77718de8d7fSPeter Avalos }
77818de8d7fSPeter Avalos if (optind == argc && !fopt_count)
77918de8d7fSPeter Avalos usage();
78018de8d7fSPeter Avalos
78118de8d7fSPeter Avalos log_init("ssh-keyscan", log_level, SYSLOG_FACILITY_USER, 1);
78218de8d7fSPeter Avalos
78318de8d7fSPeter Avalos maxfd = fdlim_get(1);
78418de8d7fSPeter Avalos if (maxfd < 0)
78518de8d7fSPeter Avalos fatal("%s: fdlim_get: bad value", __progname);
78618de8d7fSPeter Avalos if (maxfd > MAXMAXFD)
78718de8d7fSPeter Avalos maxfd = MAXMAXFD;
78818de8d7fSPeter Avalos if (MAXCON <= 0)
78918de8d7fSPeter Avalos fatal("%s: not enough file descriptors", __progname);
79018de8d7fSPeter Avalos if (maxfd > fdlim_get(0))
79118de8d7fSPeter Avalos fdlim_set(maxfd);
79218de8d7fSPeter Avalos fdcon = xcalloc(maxfd, sizeof(con));
793*ee116499SAntonio Huete Jimenez read_wait = xcalloc(maxfd, sizeof(struct pollfd));
794*ee116499SAntonio Huete Jimenez for (j = 0; j < maxfd; j++)
795*ee116499SAntonio Huete Jimenez read_wait[j].fd = -1;
79618de8d7fSPeter Avalos
79718de8d7fSPeter Avalos for (j = 0; j < fopt_count; j++) {
798856ea928SPeter Avalos if (argv[j] == NULL)
799856ea928SPeter Avalos fp = stdin;
800856ea928SPeter Avalos else if ((fp = fopen(argv[j], "r")) == NULL)
80150a69bb5SSascha Wildner fatal("%s: %s: %s", __progname, argv[j], strerror(errno));
802856ea928SPeter Avalos
803664f4763Szrj while (getline(&line, &linesize, fp) != -1) {
804856ea928SPeter Avalos /* Chomp off trailing whitespace and comments */
805856ea928SPeter Avalos if ((cp = strchr(line, '#')) == NULL)
806856ea928SPeter Avalos cp = line + strlen(line) - 1;
807856ea928SPeter Avalos while (cp >= line) {
808856ea928SPeter Avalos if (*cp == ' ' || *cp == '\t' ||
809856ea928SPeter Avalos *cp == '\n' || *cp == '#')
810856ea928SPeter Avalos *cp-- = '\0';
811856ea928SPeter Avalos else
812856ea928SPeter Avalos break;
81318de8d7fSPeter Avalos }
814856ea928SPeter Avalos
815856ea928SPeter Avalos /* Skip empty lines */
816856ea928SPeter Avalos if (*line == '\0')
817856ea928SPeter Avalos continue;
818856ea928SPeter Avalos
819856ea928SPeter Avalos do_host(line);
820856ea928SPeter Avalos }
821856ea928SPeter Avalos
822856ea928SPeter Avalos if (ferror(fp))
82350a69bb5SSascha Wildner fatal("%s: %s: %s", __progname, argv[j], strerror(errno));
824856ea928SPeter Avalos
825856ea928SPeter Avalos fclose(fp);
82618de8d7fSPeter Avalos }
827664f4763Szrj free(line);
82818de8d7fSPeter Avalos
82918de8d7fSPeter Avalos while (optind < argc)
83018de8d7fSPeter Avalos do_host(argv[optind++]);
83118de8d7fSPeter Avalos
83218de8d7fSPeter Avalos while (ncon > 0)
83318de8d7fSPeter Avalos conloop();
83418de8d7fSPeter Avalos
835664f4763Szrj return found_one ? 0 : 1;
83618de8d7fSPeter Avalos }
837