diff --git a/crypto/openssh/ssh.c b/crypto/openssh/ssh.c index c85905665c28..7acb51398c2f 100644 --- a/crypto/openssh/ssh.c +++ b/crypto/openssh/ssh.c @@ -1,1021 +1,1037 @@ /* * Author: Tatu Ylonen * Copyright (c) 1995 Tatu Ylonen , Espoo, Finland * All rights reserved * Ssh client program. This program can be used to log into a remote machine. * The software supports strong authentication, encryption, and forwarding * of X11, TCP/IP, and authentication connections. * * As far as I am concerned, the code I have written for this software * can be used freely for any purpose. Any derived versions of this * software must be clearly marked as such, and if the derived work is * incompatible with the protocol description in the RFC file, it must be * called by a name other than "ssh" or "Secure Shell". * * Copyright (c) 1999 Niels Provos. All rights reserved. * * Modified to work with SSL by Niels Provos * in Canada (German citizen). * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "includes.h" RCSID("$OpenBSD: ssh.c,v 1.69 2000/10/27 07:32:19 markus Exp $"); RCSID("$FreeBSD$"); #include #include #include #include "xmalloc.h" #include "ssh.h" #include "packet.h" #include "buffer.h" #include "readconf.h" #include "uidswap.h" #include "ssh2.h" #include "compat.h" #include "channels.h" #include "key.h" #include "authfd.h" #include "authfile.h" extern char *__progname; /* Flag indicating whether IPv4 or IPv6. This can be set on the command line. Default value is AF_UNSPEC means both IPv4 and IPv6. */ int IPv4or6 = AF_UNSPEC; /* Flag indicating whether debug mode is on. This can be set on the command line. */ int debug_flag = 0; /* Flag indicating whether a tty should be allocated */ int tty_flag = 0; /* don't exec a shell */ int no_shell_flag = 0; int no_tty_flag = 0; /* * Flag indicating that nothing should be read from stdin. This can be set * on the command line. */ int stdin_null_flag = 0; /* * Flag indicating that ssh should fork after authentication. This is useful * so that the pasphrase can be entered manually, and then ssh goes to the * background. */ int fork_after_authentication_flag = 0; /* * General data structure for command line options and options configurable * in configuration files. See readconf.h. */ Options options; /* * Name of the host we are connecting to. This is the name given on the * command line, or the HostName specified for the user-supplied name in a * configuration file. */ char *host; /* socket address the host resolves to */ struct sockaddr_storage hostaddr; /* * Flag to indicate that we have received a window change signal which has * not yet been processed. This will cause a message indicating the new * window size to be sent to the server a little later. This is volatile * because this is updated in a signal handler. */ volatile int received_window_change_signal = 0; /* Value of argv[0] (set in the main program). */ char *av0; /* Flag indicating whether we have a valid host private key loaded. */ int host_private_key_loaded = 0; /* Host private key. */ RSA *host_private_key = NULL; /* Original real UID. */ uid_t original_real_uid; /* command to be executed */ Buffer command; /* Prints a help message to the user. This function never returns. */ void usage() { fprintf(stderr, "Usage: %s [options] host [command]\n", av0); fprintf(stderr, "Options:\n"); fprintf(stderr, " -l user Log in using this user name.\n"); fprintf(stderr, " -n Redirect input from /dev/null.\n"); fprintf(stderr, " -A Enable authentication agent forwarding.\n"); fprintf(stderr, " -a Disable authentication agent forwarding.\n"); #ifdef AFS fprintf(stderr, " -k Disable Kerberos ticket and AFS token forwarding.\n"); #endif /* AFS */ fprintf(stderr, " -X Enable X11 connection forwarding.\n"); fprintf(stderr, " -x Disable X11 connection forwarding.\n"); fprintf(stderr, " -i file Identity for RSA authentication (default: ~/.ssh/identity).\n"); fprintf(stderr, " -t Tty; allocate a tty even if command is given.\n"); fprintf(stderr, " -T Do not allocate a tty.\n"); fprintf(stderr, " -v Verbose; display verbose debugging messages.\n"); fprintf(stderr, " Multiple -v increases verbosity.\n"); fprintf(stderr, " -V Display version number only.\n"); fprintf(stderr, " -P Don't allocate a privileged port.\n"); fprintf(stderr, " -q Quiet; don't display any warning messages.\n"); fprintf(stderr, " -f Fork into background after authentication.\n"); fprintf(stderr, " -e char Set escape character; ``none'' = disable (default: ~).\n"); fprintf(stderr, " -c cipher Select encryption algorithm: " "``3des'', " "``blowfish''\n"); fprintf(stderr, " -p port Connect to this port. Server must be on the same port.\n"); fprintf(stderr, " -L listen-port:host:port Forward local port to remote address\n"); fprintf(stderr, " -R listen-port:host:port Forward remote port to local address\n"); fprintf(stderr, " These cause %s to listen for connections on a port, and\n", av0); fprintf(stderr, " forward them to the other side by connecting to host:port.\n"); fprintf(stderr, " -C Enable compression.\n"); fprintf(stderr, " -N Do not execute a shell or command.\n"); fprintf(stderr, " -g Allow remote hosts to connect to forwarded ports.\n"); fprintf(stderr, " -4 Use IPv4 only.\n"); fprintf(stderr, " -6 Use IPv6 only.\n"); fprintf(stderr, " -2 Force protocol version 2.\n"); fprintf(stderr, " -o 'option' Process the option as if it was read from a configuration file.\n"); exit(1); } /* * Connects to the given host using rsh (or prints an error message and exits * if rsh is not available). This function never returns. */ void rsh_connect(char *host, char *user, Buffer * command) { char *args[10]; int i; log("Using rsh. WARNING: Connection will not be encrypted."); /* Build argument list for rsh. */ i = 0; #ifndef _PATH_RSH #define _PATH_RSH "/usr/bin/rsh" #endif args[i++] = _PATH_RSH; /* host may have to come after user on some systems */ args[i++] = host; if (user) { args[i++] = "-l"; args[i++] = user; } if (buffer_len(command) > 0) { buffer_append(command, "\0", 1); args[i++] = buffer_ptr(command); } args[i++] = NULL; if (debug_flag) { for (i = 0; args[i]; i++) { if (i != 0) fprintf(stderr, " "); fprintf(stderr, "%s", args[i]); } fprintf(stderr, "\n"); } execv(_PATH_RSH, args); perror(_PATH_RSH); exit(1); } int ssh_session(void); int ssh_session2(void); /* * Main program for the ssh client. */ int main(int ac, char **av) { int i, opt, optind, exit_status, ok; u_short fwd_port, fwd_host_port; char *optarg, *cp, buf[256]; struct stat st; struct passwd *pw, pwcopy; int dummy; uid_t original_effective_uid; /* * Save the original real uid. It will be needed later (uid-swapping * may clobber the real uid). */ original_real_uid = getuid(); original_effective_uid = geteuid(); /* If we are installed setuid root be careful to not drop core. */ if (original_real_uid != original_effective_uid) { struct rlimit rlim; rlim.rlim_cur = rlim.rlim_max = 0; if (setrlimit(RLIMIT_CORE, &rlim) < 0) fatal("setrlimit failed: %.100s", strerror(errno)); } /* * Use uid-swapping to give up root privileges for the duration of * option processing. We will re-instantiate the rights when we are * ready to create the privileged port, and will permanently drop * them when the port has been created (actually, when the connection * has been made, as we may need to create the port several times). */ temporarily_use_uid(original_real_uid); /* * Set our umask to something reasonable, as some files are created * with the default umask. This will make them world-readable but * writable only by the owner, which is ok for all files for which we * don't set the modes explicitly. */ umask(022); /* Save our own name. */ av0 = av[0]; /* Initialize option structure to indicate that no values have been set. */ initialize_options(&options); /* Parse command-line arguments. */ host = NULL; /* If program name is not one of the standard names, use it as host name. */ if (strchr(av0, '/')) cp = strrchr(av0, '/') + 1; else cp = av0; if (strcmp(cp, "rsh") && strcmp(cp, "ssh") && strcmp(cp, "rlogin") && strcmp(cp, "slogin") && strcmp(cp, "remsh")) host = cp; for (optind = 1; optind < ac; optind++) { if (av[optind][0] != '-') { if (host) break; if ((cp = strchr(av[optind], '@'))) { if(cp == av[optind]) usage(); options.user = av[optind]; *cp = '\0'; host = ++cp; } else host = av[optind]; continue; } opt = av[optind][1]; if (!opt) usage(); if (strchr("eilcpLRo", opt)) { /* options with arguments */ optarg = av[optind] + 2; if (strcmp(optarg, "") == 0) { if (optind >= ac - 1) usage(); optarg = av[++optind]; } } else { if (av[optind][2]) usage(); optarg = NULL; } switch (opt) { case '2': options.protocol = SSH_PROTO_2; break; case '4': IPv4or6 = AF_INET; break; case '6': IPv4or6 = AF_INET6; break; case 'n': stdin_null_flag = 1; break; case 'f': fork_after_authentication_flag = 1; stdin_null_flag = 1; break; case 'x': options.forward_x11 = 0; break; case 'X': options.forward_x11 = 1; break; case 'g': options.gateway_ports = 1; break; case 'P': options.use_privileged_port = 0; break; case 'a': options.forward_agent = 0; break; case 'A': options.forward_agent = 1; break; #ifdef AFS case 'k': options.krb4_tgt_passing = 0; options.krb5_tgt_passing = 0; options.afs_token_passing = 0; break; #endif case 'i': if (stat(optarg, &st) < 0) { fprintf(stderr, "Warning: Identity file %s does not exist.\n", optarg); break; } if (options.num_identity_files >= SSH_MAX_IDENTITY_FILES) fatal("Too many identity files specified (max %d)", SSH_MAX_IDENTITY_FILES); options.identity_files[options.num_identity_files++] = xstrdup(optarg); break; case 't': tty_flag = 1; break; case 'v': if (0 == debug_flag) { debug_flag = 1; options.log_level = SYSLOG_LEVEL_DEBUG1; } else if (options.log_level < SYSLOG_LEVEL_DEBUG3) { options.log_level++; break; } else { fatal("Too high debugging level.\n"); } /* fallthrough */ case 'V': fprintf(stderr, "SSH Version %s, protocol versions %d.%d/%d.%d.\n", SSH_VERSION, PROTOCOL_MAJOR_1, PROTOCOL_MINOR_1, PROTOCOL_MAJOR_2, PROTOCOL_MINOR_2); fprintf(stderr, "Compiled with SSL (0x%8.8lx).\n", SSLeay()); if (opt == 'V') exit(0); break; case 'q': options.log_level = SYSLOG_LEVEL_QUIET; break; case 'e': if (optarg[0] == '^' && optarg[2] == 0 && (unsigned char) optarg[1] >= 64 && (unsigned char) optarg[1] < 128) options.escape_char = (unsigned char) optarg[1] & 31; else if (strlen(optarg) == 1) options.escape_char = (unsigned char) optarg[0]; else if (strcmp(optarg, "none") == 0) options.escape_char = -2; else { fprintf(stderr, "Bad escape character '%s'.\n", optarg); exit(1); } break; case 'c': if (ciphers_valid(optarg)) { /* SSH2 only */ options.ciphers = xstrdup(optarg); options.cipher = SSH_CIPHER_ILLEGAL; } else { /* SSH1 only */ Cipher *c = cipher_by_name(optarg); if (c == NULL || c->number < 0) { fprintf(stderr, "Unknown cipher type '%s'\n", optarg); exit(1); } options.cipher = c->number; } break; case 'p': options.port = atoi(optarg); break; case 'l': options.user = optarg; break; case 'R': if (sscanf(optarg, "%hu/%255[^/]/%hu", &fwd_port, buf, &fwd_host_port) != 3 && sscanf(optarg, "%hu:%255[^:]:%hu", &fwd_port, buf, &fwd_host_port) != 3) { fprintf(stderr, "Bad forwarding specification '%s'.\n", optarg); usage(); /* NOTREACHED */ } add_remote_forward(&options, fwd_port, buf, fwd_host_port); break; case 'L': if (sscanf(optarg, "%hu/%255[^/]/%hu", &fwd_port, buf, &fwd_host_port) != 3 && sscanf(optarg, "%hu:%255[^:]:%hu", &fwd_port, buf, &fwd_host_port) != 3) { fprintf(stderr, "Bad forwarding specification '%s'.\n", optarg); usage(); /* NOTREACHED */ } add_local_forward(&options, fwd_port, buf, fwd_host_port); break; case 'C': options.compression = 1; break; case 'N': no_shell_flag = 1; no_tty_flag = 1; break; case 'T': no_tty_flag = 1; break; case 'o': dummy = 1; if (process_config_line(&options, host ? host : "", optarg, "command-line", 0, &dummy) != 0) exit(1); break; default: usage(); } } /* Check that we got a host name. */ if (!host) usage(); SSLeay_add_all_algorithms(); /* Initialize the command to execute on remote host. */ buffer_init(&command); /* * Save the command to execute on the remote host in a buffer. There * is no limit on the length of the command, except by the maximum * packet size. Also sets the tty flag if there is no command. */ if (optind == ac) { /* No command specified - execute shell on a tty. */ tty_flag = 1; } else { /* A command has been specified. Store it into the buffer. */ for (i = optind; i < ac; i++) { if (i > optind) buffer_append(&command, " ", 1); buffer_append(&command, av[i], strlen(av[i])); } } /* Cannot fork to background if no command. */ if (fork_after_authentication_flag && buffer_len(&command) == 0 && !no_shell_flag) fatal("Cannot fork into background without a command to execute."); /* Allocate a tty by default if no command specified. */ if (buffer_len(&command) == 0) tty_flag = 1; /* Do not allocate a tty if stdin is not a tty. */ if (!isatty(fileno(stdin))) { if (tty_flag) fprintf(stderr, "Pseudo-terminal will not be allocated because stdin is not a terminal.\n"); tty_flag = 0; } /* force */ if (no_tty_flag) tty_flag = 0; /* Get user data. */ pw = getpwuid(original_real_uid); if (!pw) { fprintf(stderr, "You don't exist, go away!\n"); exit(1); } /* Take a copy of the returned structure. */ memset(&pwcopy, 0, sizeof(pwcopy)); pwcopy.pw_name = xstrdup(pw->pw_name); pwcopy.pw_passwd = xstrdup(pw->pw_passwd); pwcopy.pw_uid = pw->pw_uid; pwcopy.pw_gid = pw->pw_gid; pwcopy.pw_dir = xstrdup(pw->pw_dir); pwcopy.pw_shell = xstrdup(pw->pw_shell); pwcopy.pw_class = xstrdup(pw->pw_class); pwcopy.pw_expire = pw->pw_expire; pwcopy.pw_change = pw->pw_change; pw = &pwcopy; /* Initialize "log" output. Since we are the client all output actually goes to the terminal. */ log_init(av[0], options.log_level, SYSLOG_FACILITY_USER, 0); /* Read per-user configuration file. */ snprintf(buf, sizeof buf, "%.100s/%.100s", pw->pw_dir, SSH_USER_CONFFILE); read_config_file(buf, host, &options); /* Read systemwide configuration file. */ read_config_file(HOST_CONFIG_FILE, host, &options); /* Fill configuration defaults. */ fill_default_options(&options); /* reinit */ log_init(av[0], options.log_level, SYSLOG_FACILITY_USER, 0); /* check if RSA support exists */ if ((options.protocol & SSH_PROTO_1) && rsa_alive() == 0) { log("%s: no RSA support in libssl and libcrypto. See ssl(8).", __progname); log("Disabling protocol version 1"); options.protocol &= ~ (SSH_PROTO_1|SSH_PROTO_1_PREFERRED); } if (! options.protocol & (SSH_PROTO_1|SSH_PROTO_2)) { fprintf(stderr, "%s: No protocol version available.\n", __progname); exit(1); } if (options.user == NULL) options.user = xstrdup(pw->pw_name); if (options.hostname != NULL) host = options.hostname; + /* Find canonic host name. */ + if (strchr(host, '.') == 0) { + struct addrinfo hints; + struct addrinfo *ai = NULL; + int errgai; + memset(&hints, 0, sizeof(hints)); + hints.ai_family = IPv4or6; + hints.ai_flags = AI_CANONNAME; + hints.ai_socktype = SOCK_STREAM; + errgai = getaddrinfo(host, NULL, &hints, &ai); + if (errgai == 0) { + if (ai->ai_canonname != NULL) + host = xstrdup(ai->ai_canonname); + freeaddrinfo(ai); + } + } /* Disable rhosts authentication if not running as root. */ if (original_effective_uid != 0 || !options.use_privileged_port) { options.rhosts_authentication = 0; options.rhosts_rsa_authentication = 0; } /* * If using rsh has been selected, exec it now (without trying * anything else). Note that we must release privileges first. */ if (options.use_rsh) { /* * Restore our superuser privileges. This must be done * before permanently setting the uid. */ restore_uid(); /* Switch to the original uid permanently. */ permanently_set_uid(original_real_uid); /* Execute rsh. */ rsh_connect(host, options.user, &command); fatal("rsh_connect returned"); } /* Restore our superuser privileges. */ restore_uid(); /* * Open a connection to the remote host. This needs root privileges * if rhosts_{rsa_}authentication is enabled. */ - ok = ssh_connect(&host, &hostaddr, options.port, + ok = ssh_connect(host, &hostaddr, options.port, options.connection_attempts, !options.rhosts_authentication && !options.rhosts_rsa_authentication, original_real_uid, options.proxy_command); /* * If we successfully made the connection, load the host private key * in case we will need it later for combined rsa-rhosts * authentication. This must be done before releasing extra * privileges, because the file is only readable by root. */ if (ok && (options.protocol & SSH_PROTO_1)) { Key k; host_private_key = RSA_new(); k.type = KEY_RSA; k.rsa = host_private_key; if (load_private_key(HOST_KEY_FILE, "", &k, NULL)) host_private_key_loaded = 1; } /* * Get rid of any extra privileges that we may have. We will no * longer need them. Also, extra privileges could make it very hard * to read identity files and other non-world-readable files from the * user's home directory if it happens to be on a NFS volume where * root is mapped to nobody. */ /* * Note that some legacy systems need to postpone the following call * to permanently_set_uid() until the private hostkey is destroyed * with RSA_free(). Otherwise the calling user could ptrace() the * process, read the private hostkey and impersonate the host. * OpenBSD does not allow ptracing of setuid processes. */ permanently_set_uid(original_real_uid); /* * Now that we are back to our own permissions, create ~/.ssh * directory if it doesn\'t already exist. */ snprintf(buf, sizeof buf, "%.100s/%.100s", pw->pw_dir, SSH_USER_DIR); if (stat(buf, &st) < 0) if (mkdir(buf, 0700) < 0) error("Could not create directory '%.200s'.", buf); /* Check if the connection failed, and try "rsh" if appropriate. */ if (!ok) { if (options.port != 0) log("Secure connection to %.100s on port %hu refused%.100s.", host, options.port, options.fallback_to_rsh ? "; reverting to insecure method" : ""); else log("Secure connection to %.100s refused%.100s.", host, options.fallback_to_rsh ? "; reverting to insecure method" : ""); if (options.fallback_to_rsh) { rsh_connect(host, options.user, &command); fatal("rsh_connect returned"); } exit(1); } /* Expand ~ in options.identity_files. */ /* XXX mem-leaks */ for (i = 0; i < options.num_identity_files; i++) options.identity_files[i] = tilde_expand_filename(options.identity_files[i], original_real_uid); for (i = 0; i < options.num_identity_files2; i++) options.identity_files2[i] = tilde_expand_filename(options.identity_files2[i], original_real_uid); /* Expand ~ in known host file names. */ options.system_hostfile = tilde_expand_filename(options.system_hostfile, original_real_uid); options.user_hostfile = tilde_expand_filename(options.user_hostfile, original_real_uid); options.system_hostfile2 = tilde_expand_filename(options.system_hostfile2, original_real_uid); options.user_hostfile2 = tilde_expand_filename(options.user_hostfile2, original_real_uid); /* Log into the remote system. This never returns if the login fails. */ ssh_login(host_private_key_loaded, host_private_key, host, (struct sockaddr *)&hostaddr, original_real_uid); /* We no longer need the host private key. Clear it now. */ if (host_private_key_loaded) RSA_free(host_private_key); /* Destroys contents safely */ exit_status = compat20 ? ssh_session2() : ssh_session(); packet_close(); return exit_status; } void x11_get_proto(char *proto, int proto_len, char *data, int data_len) { char line[512]; FILE *f; int got_data = 0, i; if (options.xauth_location) { /* Try to get Xauthority information for the display. */ snprintf(line, sizeof line, "%.100s list %.200s 2>/dev/null", options.xauth_location, getenv("DISPLAY")); f = popen(line, "r"); if (f && fgets(line, sizeof(line), f) && sscanf(line, "%*s %s %s", proto, data) == 2) got_data = 1; if (f) pclose(f); } /* * If we didn't get authentication data, just make up some * data. The forwarding code will check the validity of the * response anyway, and substitute this data. The X11 * server, however, will ignore this fake data and use * whatever authentication mechanisms it was using otherwise * for the local connection. */ if (!got_data) { u_int32_t rand = 0; strlcpy(proto, "MIT-MAGIC-COOKIE-1", proto_len); for (i = 0; i < 16; i++) { if (i % 4 == 0) rand = arc4random(); snprintf(data + 2 * i, data_len - 2 * i, "%02x", rand & 0xff); rand >>= 8; } } } int ssh_session(void) { int type; int i; int plen; int interactive = 0; int have_tty = 0; struct winsize ws; int authfd; char *cp; /* Enable compression if requested. */ if (options.compression) { debug("Requesting compression at level %d.", options.compression_level); if (options.compression_level < 1 || options.compression_level > 9) fatal("Compression level must be from 1 (fast) to 9 (slow, best)."); /* Send the request. */ packet_start(SSH_CMSG_REQUEST_COMPRESSION); packet_put_int(options.compression_level); packet_send(); packet_write_wait(); type = packet_read(&plen); if (type == SSH_SMSG_SUCCESS) packet_start_compression(options.compression_level); else if (type == SSH_SMSG_FAILURE) log("Warning: Remote host refused compression."); else packet_disconnect("Protocol error waiting for compression response."); } /* Allocate a pseudo tty if appropriate. */ if (tty_flag) { debug("Requesting pty."); /* Start the packet. */ packet_start(SSH_CMSG_REQUEST_PTY); /* Store TERM in the packet. There is no limit on the length of the string. */ cp = getenv("TERM"); if (!cp) cp = ""; packet_put_string(cp, strlen(cp)); /* Store window size in the packet. */ if (ioctl(fileno(stdin), TIOCGWINSZ, &ws) < 0) memset(&ws, 0, sizeof(ws)); packet_put_int(ws.ws_row); packet_put_int(ws.ws_col); packet_put_int(ws.ws_xpixel); packet_put_int(ws.ws_ypixel); /* Store tty modes in the packet. */ tty_make_modes(fileno(stdin)); /* Send the packet, and wait for it to leave. */ packet_send(); packet_write_wait(); /* Read response from the server. */ type = packet_read(&plen); if (type == SSH_SMSG_SUCCESS) { interactive = 1; have_tty = 1; } else if (type == SSH_SMSG_FAILURE) log("Warning: Remote host failed or refused to allocate a pseudo tty."); else packet_disconnect("Protocol error waiting for pty request response."); } /* Request X11 forwarding if enabled and DISPLAY is set. */ if (options.forward_x11 && getenv("DISPLAY") != NULL) { char proto[512], data[512]; /* Get reasonable local authentication information. */ x11_get_proto(proto, sizeof proto, data, sizeof data); /* Request forwarding with authentication spoofing. */ debug("Requesting X11 forwarding with authentication spoofing."); x11_request_forwarding_with_spoofing(0, proto, data); /* Read response from the server. */ type = packet_read(&plen); if (type == SSH_SMSG_SUCCESS) { interactive = 1; } else if (type == SSH_SMSG_FAILURE) { log("Warning: Remote host denied X11 forwarding."); } else { packet_disconnect("Protocol error waiting for X11 forwarding"); } } /* Tell the packet module whether this is an interactive session. */ packet_set_interactive(interactive, options.keepalives); /* Clear agent forwarding if we don\'t have an agent. */ authfd = ssh_get_authentication_socket(); if (authfd < 0) options.forward_agent = 0; else ssh_close_authentication_socket(authfd); /* Request authentication agent forwarding if appropriate. */ if (options.forward_agent) { debug("Requesting authentication agent forwarding."); auth_request_forwarding(); /* Read response from the server. */ type = packet_read(&plen); packet_integrity_check(plen, 0, type); if (type != SSH_SMSG_SUCCESS) log("Warning: Remote host denied authentication agent forwarding."); } /* Initiate local TCP/IP port forwardings. */ for (i = 0; i < options.num_local_forwards; i++) { debug("Connections to local port %d forwarded to remote address %.200s:%d", options.local_forwards[i].port, options.local_forwards[i].host, options.local_forwards[i].host_port); channel_request_local_forwarding(options.local_forwards[i].port, options.local_forwards[i].host, options.local_forwards[i].host_port, options.gateway_ports); } /* Initiate remote TCP/IP port forwardings. */ for (i = 0; i < options.num_remote_forwards; i++) { debug("Connections to remote port %d forwarded to local address %.200s:%d", options.remote_forwards[i].port, options.remote_forwards[i].host, options.remote_forwards[i].host_port); channel_request_remote_forwarding(options.remote_forwards[i].port, options.remote_forwards[i].host, options.remote_forwards[i].host_port); } /* If requested, let ssh continue in the background. */ if (fork_after_authentication_flag) if (daemon(1, 1) < 0) fatal("daemon() failed: %.200s", strerror(errno)); /* * If a command was specified on the command line, execute the * command now. Otherwise request the server to start a shell. */ if (buffer_len(&command) > 0) { int len = buffer_len(&command); if (len > 900) len = 900; debug("Sending command: %.*s", len, buffer_ptr(&command)); packet_start(SSH_CMSG_EXEC_CMD); packet_put_string(buffer_ptr(&command), buffer_len(&command)); packet_send(); packet_write_wait(); } else { debug("Requesting shell."); packet_start(SSH_CMSG_EXEC_SHELL); packet_send(); packet_write_wait(); } /* Enter the interactive session. */ return client_loop(have_tty, tty_flag ? options.escape_char : -1, 0); } void init_local_fwd(void) { int i; /* Initiate local TCP/IP port forwardings. */ for (i = 0; i < options.num_local_forwards; i++) { debug("Connections to local port %d forwarded to remote address %.200s:%d", options.local_forwards[i].port, options.local_forwards[i].host, options.local_forwards[i].host_port); channel_request_local_forwarding(options.local_forwards[i].port, options.local_forwards[i].host, options.local_forwards[i].host_port, options.gateway_ports); } } extern void client_set_session_ident(int id); void client_init(int id, void *arg) { int len; debug("client_init id %d arg %d", id, (int)arg); if (no_shell_flag) goto done; if (tty_flag) { struct winsize ws; char *cp; cp = getenv("TERM"); if (!cp) cp = ""; /* Store window size in the packet. */ if (ioctl(fileno(stdin), TIOCGWINSZ, &ws) < 0) memset(&ws, 0, sizeof(ws)); channel_request_start(id, "pty-req", 0); packet_put_cstring(cp); packet_put_int(ws.ws_col); packet_put_int(ws.ws_row); packet_put_int(ws.ws_xpixel); packet_put_int(ws.ws_ypixel); packet_put_cstring(""); /* XXX: encode terminal modes */ packet_send(); /* XXX wait for reply */ } if (options.forward_x11 && getenv("DISPLAY") != NULL) { char proto[512], data[512]; /* Get reasonable local authentication information. */ x11_get_proto(proto, sizeof proto, data, sizeof data); /* Request forwarding with authentication spoofing. */ debug("Requesting X11 forwarding with authentication spoofing."); x11_request_forwarding_with_spoofing(id, proto, data); /* XXX wait for reply */ } len = buffer_len(&command); if (len > 0) { if (len > 900) len = 900; debug("Sending command: %.*s", len, buffer_ptr(&command)); channel_request_start(id, "exec", 0); packet_put_string(buffer_ptr(&command), len); packet_send(); } else { channel_request(id, "shell", 0); } /* channel_callback(id, SSH2_MSG_OPEN_CONFIGMATION, client_init, 0); */ done: /* register different callback, etc. XXX */ client_set_session_ident(id); } int ssh_session2(void) { int window, packetmax, id; int in, out, err; if (stdin_null_flag) { in = open("/dev/null", O_RDONLY); } else { in = dup(STDIN_FILENO); } out = dup(STDOUT_FILENO); err = dup(STDERR_FILENO); if (in < 0 || out < 0 || err < 0) fatal("dup() in/out/err failed"); /* enable nonblocking unless tty */ if (!isatty(in)) set_nonblock(in); if (!isatty(out)) set_nonblock(out); if (!isatty(err)) set_nonblock(err); /* should be pre-session */ init_local_fwd(); /* If requested, let ssh continue in the background. */ if (fork_after_authentication_flag) if (daemon(1, 1) < 0) fatal("daemon() failed: %.200s", strerror(errno)); window = CHAN_SES_WINDOW_DEFAULT; packetmax = CHAN_SES_PACKET_DEFAULT; if (!tty_flag) { window *= 2; packetmax *=2; } id = channel_new( "session", SSH_CHANNEL_OPENING, in, out, err, window, packetmax, CHAN_EXTENDED_WRITE, xstrdup("client-session"), /*nonblock*/0); channel_open(id); channel_register_callback(id, SSH2_MSG_CHANNEL_OPEN_CONFIRMATION, client_init, (void *)0); return client_loop(tty_flag, tty_flag ? options.escape_char : -1, id); } diff --git a/crypto/openssh/ssh.h b/crypto/openssh/ssh.h index 82ed9141cdac..b7ecde7524bf 100644 --- a/crypto/openssh/ssh.h +++ b/crypto/openssh/ssh.h @@ -1,535 +1,535 @@ /* * Author: Tatu Ylonen * Copyright (c) 1995 Tatu Ylonen , Espoo, Finland * All rights reserved * * Generic header file for ssh. * * As far as I am concerned, the code I have written for this software * can be used freely for any purpose. Any derived versions of this * software must be clearly marked as such, and if the derived work is * incompatible with the protocol description in the RFC file, it must be * called by a name other than "ssh" or "Secure Shell". */ /* RCSID("$OpenBSD: ssh.h,v 1.54 2000/10/11 20:27:24 markus Exp $"); */ /* $FreeBSD$ */ #ifndef SSH_H #define SSH_H #include "rsa.h" #include "cipher.h" /* Cipher used for encrypting authentication files. */ #define SSH_AUTHFILE_CIPHER SSH_CIPHER_3DES /* Default port number. */ #define SSH_DEFAULT_PORT 22 /* Maximum number of TCP/IP ports forwarded per direction. */ #define SSH_MAX_FORWARDS_PER_DIRECTION 100 /* * Maximum number of RSA authentication identity files that can be specified * in configuration files or on the command line. */ #define SSH_MAX_IDENTITY_FILES 100 /* * Major protocol version. Different version indicates major incompatiblity * that prevents communication. * * Minor protocol version. Different version indicates minor incompatibility * that does not prevent interoperation. */ #define PROTOCOL_MAJOR_1 1 #define PROTOCOL_MINOR_1 5 /* We support both SSH1 and SSH2 */ #define PROTOCOL_MAJOR_2 2 #define PROTOCOL_MINOR_2 0 /* * Name for the service. The port named by this service overrides the * default port if present. */ #define SSH_SERVICE_NAME "ssh" #define ETCDIR "/etc/ssh" #define PIDDIR "/var/run" /* * System-wide file containing host keys of known hosts. This file should be * world-readable. */ #define SSH_SYSTEM_HOSTFILE ETCDIR "/ssh_known_hosts" #define SSH_SYSTEM_HOSTFILE2 ETCDIR "/ssh_known_hosts2" /* * Of these, ssh_host_key must be readable only by root, whereas ssh_config * should be world-readable. */ #define HOST_KEY_FILE ETCDIR "/ssh_host_key" #define SERVER_CONFIG_FILE ETCDIR "/sshd_config" #define HOST_CONFIG_FILE ETCDIR "/ssh_config" #define HOST_DSA_KEY_FILE ETCDIR "/ssh_host_dsa_key" #define DH_PRIMES ETCDIR "/primes" #define SSH_PROGRAM "/usr/bin/ssh" /* * The process id of the daemon listening for connections is saved here to * make it easier to kill the correct daemon when necessary. */ #define SSH_DAEMON_PID_FILE PIDDIR "/sshd.pid" /* * The directory in user\'s home directory in which the files reside. The * directory should be world-readable (though not all files are). */ #define SSH_USER_DIR ".ssh" /* * Per-user file containing host keys of known hosts. This file need not be * readable by anyone except the user him/herself, though this does not * contain anything particularly secret. */ #define SSH_USER_HOSTFILE "~/.ssh/known_hosts" #define SSH_USER_HOSTFILE2 "~/.ssh/known_hosts2" /* * Name of the default file containing client-side authentication key. This * file should only be readable by the user him/herself. */ #define SSH_CLIENT_IDENTITY ".ssh/identity" #define SSH_CLIENT_ID_DSA ".ssh/id_dsa" /* * Configuration file in user\'s home directory. This file need not be * readable by anyone but the user him/herself, but does not contain anything * particularly secret. If the user\'s home directory resides on an NFS * volume where root is mapped to nobody, this may need to be world-readable. */ #define SSH_USER_CONFFILE ".ssh/config" /* * File containing a list of those rsa keys that permit logging in as this * user. This file need not be readable by anyone but the user him/herself, * but does not contain anything particularly secret. If the user\'s home * directory resides on an NFS volume where root is mapped to nobody, this * may need to be world-readable. (This file is read by the daemon which is * running as root.) */ #define SSH_USER_PERMITTED_KEYS ".ssh/authorized_keys" #define SSH_USER_PERMITTED_KEYS2 ".ssh/authorized_keys2" /* * Per-user and system-wide ssh "rc" files. These files are executed with * /bin/sh before starting the shell or command if they exist. They will be * passed "proto cookie" as arguments if X11 forwarding with spoofing is in * use. xauth will be run if neither of these exists. */ #define SSH_USER_RC ".ssh/rc" #define SSH_SYSTEM_RC ETCDIR "/sshrc" /* * Ssh-only version of /etc/hosts.equiv. Additionally, the daemon may use * ~/.rhosts and /etc/hosts.equiv if rhosts authentication is enabled. */ #define SSH_HOSTS_EQUIV ETCDIR "/shosts.equiv" /* * Name of the environment variable containing the pathname of the * authentication socket. */ #define SSH_AUTHSOCKET_ENV_NAME "SSH_AUTH_SOCK" /* * Name of the environment variable containing the pathname of the * authentication socket. */ #define SSH_AGENTPID_ENV_NAME "SSH_AGENT_PID" /* * Default path to ssh-askpass used by ssh-add, * environment variable for overwriting the default location */ #define SSH_ASKPASS_DEFAULT "/usr/X11R6/bin/ssh-askpass" #define SSH_ASKPASS_ENV "SSH_ASKPASS" /* * Force host key length and server key length to differ by at least this * many bits. This is to make double encryption with rsaref work. */ #define SSH_KEY_BITS_RESERVED 128 /* * Length of the session key in bytes. (Specified as 256 bits in the * protocol.) */ #define SSH_SESSION_KEY_LENGTH 32 /* Name of Kerberos service for SSH to use. */ #define KRB4_SERVICE_NAME "rcmd" /* * Authentication methods. New types can be added, but old types should not * be removed for compatibility. The maximum allowed value is 31. */ #define SSH_AUTH_RHOSTS 1 #define SSH_AUTH_RSA 2 #define SSH_AUTH_PASSWORD 3 #define SSH_AUTH_RHOSTS_RSA 4 #define SSH_AUTH_TIS 5 #define SSH_AUTH_KERBEROS 6 #define SSH_PASS_KERBEROS_TGT 7 /* 8 to 15 are reserved */ #define SSH_PASS_AFS_TOKEN 21 /* Protocol flags. These are bit masks. */ #define SSH_PROTOFLAG_SCREEN_NUMBER 1 /* X11 forwarding includes screen */ #define SSH_PROTOFLAG_HOST_IN_FWD_OPEN 2 /* forwarding opens contain host */ /* * Definition of message types. New values can be added, but old values * should not be removed or without careful consideration of the consequences * for compatibility. The maximum value is 254; value 255 is reserved for * future extension. */ /* Message name */ /* msg code */ /* arguments */ #define SSH_MSG_NONE 0 /* no message */ #define SSH_MSG_DISCONNECT 1 /* cause (string) */ #define SSH_SMSG_PUBLIC_KEY 2 /* ck,msk,srvk,hostk */ #define SSH_CMSG_SESSION_KEY 3 /* key (BIGNUM) */ #define SSH_CMSG_USER 4 /* user (string) */ #define SSH_CMSG_AUTH_RHOSTS 5 /* user (string) */ #define SSH_CMSG_AUTH_RSA 6 /* modulus (BIGNUM) */ #define SSH_SMSG_AUTH_RSA_CHALLENGE 7 /* int (BIGNUM) */ #define SSH_CMSG_AUTH_RSA_RESPONSE 8 /* int (BIGNUM) */ #define SSH_CMSG_AUTH_PASSWORD 9 /* pass (string) */ #define SSH_CMSG_REQUEST_PTY 10 /* TERM, tty modes */ #define SSH_CMSG_WINDOW_SIZE 11 /* row,col,xpix,ypix */ #define SSH_CMSG_EXEC_SHELL 12 /* */ #define SSH_CMSG_EXEC_CMD 13 /* cmd (string) */ #define SSH_SMSG_SUCCESS 14 /* */ #define SSH_SMSG_FAILURE 15 /* */ #define SSH_CMSG_STDIN_DATA 16 /* data (string) */ #define SSH_SMSG_STDOUT_DATA 17 /* data (string) */ #define SSH_SMSG_STDERR_DATA 18 /* data (string) */ #define SSH_CMSG_EOF 19 /* */ #define SSH_SMSG_EXITSTATUS 20 /* status (int) */ #define SSH_MSG_CHANNEL_OPEN_CONFIRMATION 21 /* channel (int) */ #define SSH_MSG_CHANNEL_OPEN_FAILURE 22 /* channel (int) */ #define SSH_MSG_CHANNEL_DATA 23 /* ch,data (int,str) */ #define SSH_MSG_CHANNEL_CLOSE 24 /* channel (int) */ #define SSH_MSG_CHANNEL_CLOSE_CONFIRMATION 25 /* channel (int) */ /* SSH_CMSG_X11_REQUEST_FORWARDING 26 OBSOLETE */ #define SSH_SMSG_X11_OPEN 27 /* channel (int) */ #define SSH_CMSG_PORT_FORWARD_REQUEST 28 /* p,host,hp (i,s,i) */ #define SSH_MSG_PORT_OPEN 29 /* ch,h,p (i,s,i) */ #define SSH_CMSG_AGENT_REQUEST_FORWARDING 30 /* */ #define SSH_SMSG_AGENT_OPEN 31 /* port (int) */ #define SSH_MSG_IGNORE 32 /* string */ #define SSH_CMSG_EXIT_CONFIRMATION 33 /* */ #define SSH_CMSG_X11_REQUEST_FORWARDING 34 /* proto,data (s,s) */ #define SSH_CMSG_AUTH_RHOSTS_RSA 35 /* user,mod (s,mpi) */ #define SSH_MSG_DEBUG 36 /* string */ #define SSH_CMSG_REQUEST_COMPRESSION 37 /* level 1-9 (int) */ #define SSH_CMSG_MAX_PACKET_SIZE 38 /* size 4k-1024k (int) */ #define SSH_CMSG_AUTH_TIS 39 /* we use this for s/key */ #define SSH_SMSG_AUTH_TIS_CHALLENGE 40 /* challenge (string) */ #define SSH_CMSG_AUTH_TIS_RESPONSE 41 /* response (string) */ #define SSH_CMSG_AUTH_KERBEROS 42 /* (KTEXT) */ #define SSH_SMSG_AUTH_KERBEROS_RESPONSE 43 /* (KTEXT) */ #define SSH_CMSG_HAVE_KERBEROS_TGT 44 #define SSH_CMSG_HAVE_AFS_TOKEN 65 /* token (s) */ /* Kerberos IV tickets can't be forwarded. This is an AFS hack! */ #define SSH_CMSG_HAVE_KRB4_TGT SSH_CMSG_HAVE_KERBEROS_TGT /* credentials (s) */ /*------------ definitions for login.c -------------*/ /* * Returns the time when the user last logged in. Returns 0 if the * information is not available. This must be called before record_login. * The host from which the user logged in is stored in buf. */ unsigned long get_last_login_time(uid_t uid, const char *logname, char *buf, unsigned int bufsize); /* * Records that the user has logged in. This does many things normally done * by login(1). */ void record_login(pid_t pid, const char *ttyname, const char *user, uid_t uid, const char *host, struct sockaddr *addr); /* * Records that the user has logged out. This does many thigs normally done * by login(1) or init. */ void record_logout(pid_t pid, const char *ttyname); /*------------ definitions for sshconnect.c ----------*/ /* * Opens a TCP/IP connection to the remote server on the given host. If port * is 0, the default port will be used. If anonymous is zero, a privileged * port will be allocated to make the connection. This requires super-user * privileges if anonymous is false. Connection_attempts specifies the * maximum number of tries, one per second. This returns true on success, * and zero on failure. If the connection is successful, this calls * packet_set_connection for the connection. */ int -ssh_connect(char **host, struct sockaddr_storage * hostaddr, +ssh_connect(const char *host, struct sockaddr_storage * hostaddr, u_short port, int connection_attempts, int anonymous, uid_t original_real_uid, const char *proxy_command); /* * Starts a dialog with the server, and authenticates the current user on the * server. This does not need any extra privileges. The basic connection to * the server must already have been established before this is called. If * login fails, this function prints an error and never returns. This * initializes the random state, and leaves it initialized (it will also have * references from the packet module). */ void ssh_login(int host_key_valid, RSA * host_key, const char *host, struct sockaddr * hostaddr, uid_t original_real_uid); /*------------ Definitions for various authentication methods. -------*/ /* * Tries to authenticate the user using the .rhosts file. Returns true if * authentication succeeds. If ignore_rhosts is non-zero, this will not * consider .rhosts and .shosts (/etc/hosts.equiv will still be used). */ int auth_rhosts(struct passwd * pw, const char *client_user); /* * Tries to authenticate the user using the .rhosts file and the host using * its host key. Returns true if authentication succeeds. */ int auth_rhosts_rsa(struct passwd * pw, const char *client_user, RSA* client_host_key); /* * Tries to authenticate the user using password. Returns true if * authentication succeeds. */ int auth_password(struct passwd * pw, const char *password); /* * Performs the RSA authentication dialog with the client. This returns 0 if * the client could not be authenticated, and 1 if authentication was * successful. This may exit if there is a serious protocol violation. */ int auth_rsa(struct passwd * pw, BIGNUM * client_n); /* * Parses an RSA key (number of bits, e, n) from a string. Moves the pointer * over the key. Skips any whitespace at the beginning and at end. */ int auth_rsa_read_key(char **cpp, unsigned int *bitsp, BIGNUM * e, BIGNUM * n); /* * Returns the name of the machine at the other end of the socket. The * returned string should be freed by the caller. */ char *get_remote_hostname(int socket); /* * Return the canonical name of the host in the other side of the current * connection (as returned by packet_get_connection). The host name is * cached, so it is efficient to call this several times. */ const char *get_canonical_hostname(void); /* * Returns the local IP address as an ascii string. */ const char *get_ipaddr(int socket); /* * Returns the remote IP address as an ascii string. The value need not be * freed by the caller. */ const char *get_remote_ipaddr(void); /* Returns the port number of the peer of the socket. */ int get_peer_port(int sock); /* Returns the port number of the remote/local host. */ int get_remote_port(void); int get_local_port(void); /* * Performs the RSA authentication challenge-response dialog with the client, * and returns true (non-zero) if the client gave the correct answer to our * challenge; returns zero if the client gives a wrong answer. */ int auth_rsa_challenge_dialog(RSA *pk); /* * Reads a passphrase from /dev/tty with echo turned off. Returns the * passphrase (allocated with xmalloc). Exits if EOF is encountered. If * from_stdin is true, the passphrase will be read from stdin instead. */ char *read_passphrase(char *prompt, int from_stdin); /*------------ Definitions for logging. -----------------------*/ /* Supported syslog facilities and levels. */ typedef enum { SYSLOG_FACILITY_DAEMON, SYSLOG_FACILITY_USER, SYSLOG_FACILITY_AUTH, SYSLOG_FACILITY_LOCAL0, SYSLOG_FACILITY_LOCAL1, SYSLOG_FACILITY_LOCAL2, SYSLOG_FACILITY_LOCAL3, SYSLOG_FACILITY_LOCAL4, SYSLOG_FACILITY_LOCAL5, SYSLOG_FACILITY_LOCAL6, SYSLOG_FACILITY_LOCAL7 } SyslogFacility; typedef enum { SYSLOG_LEVEL_QUIET, SYSLOG_LEVEL_FATAL, SYSLOG_LEVEL_ERROR, SYSLOG_LEVEL_INFO, SYSLOG_LEVEL_VERBOSE, SYSLOG_LEVEL_DEBUG1, SYSLOG_LEVEL_DEBUG2, SYSLOG_LEVEL_DEBUG3 } LogLevel; /* Initializes logging. */ void log_init(char *av0, LogLevel level, SyslogFacility facility, int on_stderr); /* Logging implementation, depending on server or client */ void do_log(LogLevel level, const char *fmt, va_list args); /* name to facility/level */ SyslogFacility log_facility_number(char *name); LogLevel log_level_number(char *name); /* Output a message to syslog or stderr */ void fatal(const char *fmt,...) __attribute__((format(printf, 1, 2))); void error(const char *fmt,...) __attribute__((format(printf, 1, 2))); void log(const char *fmt,...) __attribute__((format(printf, 1, 2))); void verbose(const char *fmt,...) __attribute__((format(printf, 1, 2))); void debug(const char *fmt,...) __attribute__((format(printf, 1, 2))); void debug2(const char *fmt,...) __attribute__((format(printf, 1, 2))); void debug3(const char *fmt,...) __attribute__((format(printf, 1, 2))); /* same as fatal() but w/o logging */ void fatal_cleanup(void); /* * Registers a cleanup function to be called by fatal()/fatal_cleanup() * before exiting. It is permissible to call fatal_remove_cleanup for the * function itself from the function. */ void fatal_add_cleanup(void (*proc) (void *context), void *context); /* Removes a cleanup function to be called at fatal(). */ void fatal_remove_cleanup(void (*proc) (void *context), void *context); /* ---- misc */ /* * Expands tildes in the file name. Returns data allocated by xmalloc. * Warning: this calls getpw*. */ char *tilde_expand_filename(const char *filename, uid_t my_uid); /* remove newline at end of string */ char *chop(char *s); /* return next token in configuration line */ char *strdelim(char **s); /* set filedescriptor to non-blocking */ void set_nonblock(int fd); /* * Performs the interactive session. This handles data transmission between * the client and the program. Note that the notion of stdin, stdout, and * stderr in this function is sort of reversed: this function writes to stdin * (of the child program), and reads from stdout and stderr (of the child * program). */ void server_loop(pid_t pid, int fdin, int fdout, int fderr); void server_loop2(void); /* Client side main loop for the interactive session. */ int client_loop(int have_pty, int escape_char, int id); /* Linked list of custom environment strings (see auth-rsa.c). */ struct envstring { struct envstring *next; char *s; }; /* * Ensure all of data on socket comes through. f==read || f==write */ ssize_t atomicio(ssize_t (*f)(), int fd, void *s, size_t n); #ifdef KRB5 #include int auth_krb5(); /* XXX Doplnit prototypy */ int auth_krb5_tgt(); int krb5_init(); void krb5_cleanup_proc(void *ignore); int auth_krb5_password(struct passwd *pw, const char *password); #endif /* KRB5 */ #ifdef KRB4 #include /* * Performs Kerberos v4 mutual authentication with the client. This returns 0 * if the client could not be authenticated, and 1 if authentication was * successful. This may exit if there is a serious protocol violation. */ int auth_krb4(const char *server_user, KTEXT auth, char **client); int krb4_init(uid_t uid); void krb4_cleanup_proc(void *ignore); int auth_krb4_password(struct passwd * pw, const char *password); #ifdef AFS #include /* Accept passed Kerberos v4 ticket-granting ticket and AFS tokens. */ int auth_krb4_tgt(struct passwd * pw, const char *string); int auth_afs_token(struct passwd * pw, const char *token_string); int creds_to_radix(CREDENTIALS * creds, unsigned char *buf, size_t buflen); int radix_to_creds(const char *buf, CREDENTIALS * creds); #endif /* AFS */ #endif /* KRB4 */ #ifdef SKEY #include char *skey_fake_keyinfo(char *username); int auth_skey_password(struct passwd * pw, const char *password); #endif /* SKEY */ /* AF_UNSPEC or AF_INET or AF_INET6 */ extern int IPv4or6; #ifdef USE_PAM #include "auth-pam.h" #endif /* USE_PAM */ #endif /* SSH_H */ diff --git a/crypto/openssh/sshconnect.c b/crypto/openssh/sshconnect.c index 364a7c963830..21ee0e60c1b7 100644 --- a/crypto/openssh/sshconnect.c +++ b/crypto/openssh/sshconnect.c @@ -1,917 +1,910 @@ /* * Author: Tatu Ylonen * Copyright (c) 1995 Tatu Ylonen , Espoo, Finland * All rights reserved * Code to connect to a remote host, and to perform the client side of the * login (authentication) dialog. * * As far as I am concerned, the code I have written for this software * can be used freely for any purpose. Any derived versions of this * software must be clearly marked as such, and if the derived work is * incompatible with the protocol description in the RFC file, it must be * called by a name other than "ssh" or "Secure Shell". */ #include "includes.h" RCSID("$OpenBSD: sshconnect.c,v 1.79 2000/09/17 15:52:51 markus Exp $"); RCSID("$FreeBSD$"); #include #include #include #include "xmalloc.h" #include "rsa.h" #include "ssh.h" #include "buffer.h" #include "packet.h" #include "uidswap.h" #include "compat.h" #include "readconf.h" #include "key.h" #include "sshconnect.h" #include "hostfile.h" char *client_version_string = NULL; char *server_version_string = NULL; extern Options options; extern char *__progname; /* * Connect to the given ssh server using a proxy command. */ int ssh_proxy_connect(const char *host, u_short port, uid_t original_real_uid, const char *proxy_command) { Buffer command; const char *cp; char *command_string; int pin[2], pout[2]; pid_t pid; char strport[NI_MAXSERV]; /* Convert the port number into a string. */ snprintf(strport, sizeof strport, "%hu", port); /* Build the final command string in the buffer by making the appropriate substitutions to the given proxy command. */ buffer_init(&command); for (cp = proxy_command; *cp; cp++) { if (cp[0] == '%' && cp[1] == '%') { buffer_append(&command, "%", 1); cp++; continue; } if (cp[0] == '%' && cp[1] == 'h') { buffer_append(&command, host, strlen(host)); cp++; continue; } if (cp[0] == '%' && cp[1] == 'p') { buffer_append(&command, strport, strlen(strport)); cp++; continue; } buffer_append(&command, cp, 1); } buffer_append(&command, "\0", 1); /* Get the final command string. */ command_string = buffer_ptr(&command); /* Create pipes for communicating with the proxy. */ if (pipe(pin) < 0 || pipe(pout) < 0) fatal("Could not create pipes to communicate with the proxy: %.100s", strerror(errno)); debug("Executing proxy command: %.500s", command_string); /* Fork and execute the proxy command. */ if ((pid = fork()) == 0) { char *argv[10]; /* Child. Permanently give up superuser privileges. */ permanently_set_uid(original_real_uid); /* Redirect stdin and stdout. */ close(pin[1]); if (pin[0] != 0) { if (dup2(pin[0], 0) < 0) perror("dup2 stdin"); close(pin[0]); } close(pout[0]); if (dup2(pout[1], 1) < 0) perror("dup2 stdout"); /* Cannot be 1 because pin allocated two descriptors. */ close(pout[1]); /* Stderr is left as it is so that error messages get printed on the user's terminal. */ argv[0] = "/bin/sh"; argv[1] = "-c"; argv[2] = command_string; argv[3] = NULL; /* Execute the proxy command. Note that we gave up any extra privileges above. */ execv("/bin/sh", argv); perror("/bin/sh"); exit(1); } /* Parent. */ if (pid < 0) fatal("fork failed: %.100s", strerror(errno)); /* Close child side of the descriptors. */ close(pin[0]); close(pout[1]); /* Free the command name. */ buffer_free(&command); /* Set the connection file descriptors. */ packet_set_connection(pout[0], pin[1]); return 1; } /* * Creates a (possibly privileged) socket for use as the ssh connection. */ int ssh_create_socket(uid_t original_real_uid, int privileged, int family) { int sock; /* * If we are running as root and want to connect to a privileged * port, bind our own socket to a privileged port. */ if (privileged) { int p = IPPORT_RESERVED - 1; sock = rresvport_af(&p, family); if (sock < 0) error("rresvport: af=%d %.100s", family, strerror(errno)); else debug("Allocated local port %d.", p); } else { /* * Just create an ordinary socket on arbitrary port. We use * the user's uid to create the socket. */ temporarily_use_uid(original_real_uid); sock = socket(family, SOCK_STREAM, 0); if (sock < 0) error("socket: %.100s", strerror(errno)); restore_uid(); } return sock; } /* * Opens a TCP/IP connection to the remote server on the given host. - * The canonical host name used to connect will be returned in *host. * The address of the remote host will be returned in hostaddr. * If port is 0, the default port will be used. If anonymous is zero, * a privileged port will be allocated to make the connection. * This requires super-user privileges if anonymous is false. * Connection_attempts specifies the maximum number of tries (one per * second). If proxy_command is non-NULL, it specifies the command (with %h * and %p substituted for host and port, respectively) to use to contact * the daemon. */ int -ssh_connect(char **host, struct sockaddr_storage * hostaddr, +ssh_connect(const char *host, struct sockaddr_storage * hostaddr, u_short port, int connection_attempts, int anonymous, uid_t original_real_uid, const char *proxy_command) { int sock = -1, attempt; struct servent *sp; struct addrinfo hints, *ai, *aitop; char ntop[NI_MAXHOST], strport[NI_MAXSERV]; int gaierr; struct linger linger; debug("ssh_connect: getuid %u geteuid %u anon %d", (u_int) getuid(), (u_int) geteuid(), anonymous); /* Get default port if port has not been set. */ if (port == 0) { sp = getservbyname(SSH_SERVICE_NAME, "tcp"); if (sp) port = ntohs(sp->s_port); else port = SSH_DEFAULT_PORT; } /* If a proxy command is given, connect using it. */ if (proxy_command != NULL) - return ssh_proxy_connect(*host, port, original_real_uid, proxy_command); + return ssh_proxy_connect(host, port, original_real_uid, proxy_command); /* No proxy command. */ memset(&hints, 0, sizeof(hints)); hints.ai_family = IPv4or6; hints.ai_socktype = SOCK_STREAM; - hints.ai_flags = AI_CANONNAME; snprintf(strport, sizeof strport, "%d", port); - if ((gaierr = getaddrinfo(*host, strport, &hints, &aitop)) != 0) - fatal("%s: %.100s: %s", __progname, *host, + if ((gaierr = getaddrinfo(host, strport, &hints, &aitop)) != 0) + fatal("%s: %.100s: %s", __progname, host, gai_strerror(gaierr)); /* * Try to connect several times. On some machines, the first time * will sometimes fail. In general socket code appears to behave * quite magically on many machines. */ for (attempt = 0; attempt < connection_attempts; attempt++) { if (attempt > 0) debug("Trying again..."); /* Loop through addresses for this host, and try each one in sequence until the connection succeeds. */ for (ai = aitop; ai; ai = ai->ai_next) { if (ai->ai_family != AF_INET && ai->ai_family != AF_INET6) continue; if (getnameinfo(ai->ai_addr, ai->ai_addrlen, ntop, sizeof(ntop), strport, sizeof(strport), NI_NUMERICHOST|NI_NUMERICSERV) != 0) { error("ssh_connect: getnameinfo failed"); continue; } debug("Connecting to %.200s [%.100s] port %s.", - ai->ai_canonname, ntop, strport); + host, ntop, strport); /* Create a socket for connecting. */ sock = ssh_create_socket(original_real_uid, !anonymous && geteuid() == 0 && port < IPPORT_RESERVED, ai->ai_family); if (sock < 0) continue; /* Connect to the host. We use the user's uid in the * hope that it will help with tcp_wrappers showing * the remote uid as root. */ temporarily_use_uid(original_real_uid); if (connect(sock, ai->ai_addr, ai->ai_addrlen) >= 0) { /* Successful connection. */ memcpy(hostaddr, ai->ai_addr, ai->ai_addrlen); restore_uid(); break; } else { debug("connect: %.100s", strerror(errno)); restore_uid(); /* * Close the failed socket; there appear to * be some problems when reusing a socket for * which connect() has already returned an * error. */ shutdown(sock, SHUT_RDWR); close(sock); } } - if (ai) { -#if 0 - if (ai->ai_canonname != NULL) - *host = xstrdup(ai->ai_canonname); -#endif + if (ai) break; /* Successful connection. */ - } /* Sleep a moment before retrying. */ sleep(1); } freeaddrinfo(aitop); /* Return failure if we didn't get a successful connection. */ if (attempt >= connection_attempts) return 0; debug("Connection established."); /* * Set socket options. We would like the socket to disappear as soon * as it has been closed for whatever reason. */ /* setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&on, sizeof(on)); */ linger.l_onoff = 1; linger.l_linger = 5; setsockopt(sock, SOL_SOCKET, SO_LINGER, (void *) &linger, sizeof(linger)); /* Set the connection. */ packet_set_connection(sock, sock); return 1; } /* * Waits for the server identification string, and sends our own * identification string. */ void ssh_exchange_identification() { char buf[256], remote_version[256]; /* must be same size! */ int remote_major, remote_minor, i, mismatch; int connection_in = packet_get_connection_in(); int connection_out = packet_get_connection_out(); /* Read other side\'s version identification. */ for (;;) { for (i = 0; i < sizeof(buf) - 1; i++) { int len = atomicio(read, connection_in, &buf[i], 1); if (len < 0) fatal("ssh_exchange_identification: read: %.100s", strerror(errno)); if (len != 1) fatal("ssh_exchange_identification: Connection closed by remote host"); if (buf[i] == '\r') { buf[i] = '\n'; buf[i + 1] = 0; continue; /**XXX wait for \n */ } if (buf[i] == '\n') { buf[i + 1] = 0; break; } } buf[sizeof(buf) - 1] = 0; if (strncmp(buf, "SSH-", 4) == 0) break; debug("ssh_exchange_identification: %s", buf); } server_version_string = xstrdup(buf); /* * Check that the versions match. In future this might accept * several versions and set appropriate flags to handle them. */ if (sscanf(server_version_string, "SSH-%d.%d-%[^\n]\n", &remote_major, &remote_minor, remote_version) != 3) fatal("Bad remote protocol version identification: '%.100s'", buf); debug("Remote protocol version %d.%d, remote software version %.100s", remote_major, remote_minor, remote_version); compat_datafellows(remote_version); mismatch = 0; switch(remote_major) { case 1: if (remote_minor == 99 && (options.protocol & SSH_PROTO_2) && !(options.protocol & SSH_PROTO_1_PREFERRED)) { enable_compat20(); break; } if (!(options.protocol & SSH_PROTO_1)) { mismatch = 1; break; } if (remote_minor < 3) { fatal("Remote machine has too old SSH software version."); } else if (remote_minor == 3) { /* We speak 1.3, too. */ enable_compat13(); if (options.forward_agent) { log("Agent forwarding disabled for protocol 1.3"); options.forward_agent = 0; } } break; case 2: if (options.protocol & SSH_PROTO_2) { enable_compat20(); break; } /* FALLTHROUGH */ default: mismatch = 1; break; } if (mismatch) fatal("Protocol major versions differ: %d vs. %d", (options.protocol & SSH_PROTO_2) ? PROTOCOL_MAJOR_2 : PROTOCOL_MAJOR_1, remote_major); if (compat20) packet_set_ssh2_format(); /* Send our own protocol version identification. */ snprintf(buf, sizeof buf, "SSH-%d.%d-%.100s\n", compat20 ? PROTOCOL_MAJOR_2 : PROTOCOL_MAJOR_1, compat20 ? PROTOCOL_MINOR_2 : PROTOCOL_MINOR_1, SSH_VERSION); if (atomicio(write, connection_out, buf, strlen(buf)) != strlen(buf)) fatal("write: %.100s", strerror(errno)); client_version_string = xstrdup(buf); chop(client_version_string); chop(server_version_string); debug("Local version string %.100s", client_version_string); } int read_yes_or_no(const char *prompt, int defval) { char buf[1024]; FILE *f; int retval = -1; if (isatty(0)) f = stdin; else f = fopen("/dev/tty", "rw"); if (f == NULL) return 0; fflush(stdout); while (1) { fprintf(stderr, "%s", prompt); if (fgets(buf, sizeof(buf), f) == NULL) { /* Print a newline (the prompt probably didn\'t have one). */ fprintf(stderr, "\n"); strlcpy(buf, "no", sizeof buf); } /* Remove newline from response. */ if (strchr(buf, '\n')) *strchr(buf, '\n') = 0; if (buf[0] == 0) retval = defval; if (strcmp(buf, "yes") == 0) retval = 1; else if (strcmp(buf, "no") == 0) retval = 0; else fprintf(stderr, "Please type 'yes' or 'no'.\n"); if (retval != -1) { if (f != stdin) fclose(f); return retval; } } } /* * check whether the supplied host key is valid, return only if ok. */ void check_host_key(char *host, struct sockaddr *hostaddr, Key *host_key, const char *user_hostfile, const char *system_hostfile) { Key *file_key; char *type = key_type(host_key); char *ip = NULL; char hostline[1000], *hostp; HostStatus host_status; HostStatus ip_status; int local = 0, host_ip_differ = 0; char ntop[NI_MAXHOST]; /* * Force accepting of the host key for loopback/localhost. The * problem is that if the home directory is NFS-mounted to multiple * machines, localhost will refer to a different machine in each of * them, and the user will get bogus HOST_CHANGED warnings. This * essentially disables host authentication for localhost; however, * this is probably not a real problem. */ /** hostaddr == 0! */ switch (hostaddr->sa_family) { case AF_INET: local = (ntohl(((struct sockaddr_in *)hostaddr)->sin_addr.s_addr) >> 24) == IN_LOOPBACKNET; break; case AF_INET6: local = IN6_IS_ADDR_LOOPBACK(&(((struct sockaddr_in6 *)hostaddr)->sin6_addr)); break; default: local = 0; break; } if (local) { debug("Forcing accepting of host key for loopback/localhost."); return; } /* * Turn off check_host_ip for proxy connects, since * we don't have the remote ip-address */ if (options.proxy_command != NULL && options.check_host_ip) options.check_host_ip = 0; if (options.check_host_ip) { if (getnameinfo(hostaddr, hostaddr->sa_len, ntop, sizeof(ntop), NULL, 0, NI_NUMERICHOST) != 0) fatal("check_host_key: getnameinfo failed"); ip = xstrdup(ntop); } /* * Store the host key from the known host file in here so that we can * compare it with the key for the IP address. */ file_key = key_new(host_key->type); /* * Check if the host key is present in the user\'s list of known * hosts or in the systemwide list. */ host_status = check_host_in_hostfile(user_hostfile, host, host_key, file_key); if (host_status == HOST_NEW) host_status = check_host_in_hostfile(system_hostfile, host, host_key, file_key); /* * Also perform check for the ip address, skip the check if we are * localhost or the hostname was an ip address to begin with */ if (options.check_host_ip && !local && strcmp(host, ip)) { Key *ip_key = key_new(host_key->type); ip_status = check_host_in_hostfile(user_hostfile, ip, host_key, ip_key); if (ip_status == HOST_NEW) ip_status = check_host_in_hostfile(system_hostfile, ip, host_key, ip_key); if (host_status == HOST_CHANGED && (ip_status != HOST_CHANGED || !key_equal(ip_key, file_key))) host_ip_differ = 1; key_free(ip_key); } else ip_status = host_status; key_free(file_key); switch (host_status) { case HOST_OK: /* The host is known and the key matches. */ debug("Host '%.200s' is known and matches the %s host key.", host, type); if (options.check_host_ip) { if (ip_status == HOST_NEW) { if (!add_host_to_hostfile(user_hostfile, ip, host_key)) log("Failed to add the %s host key for IP address '%.30s' to the list of known hosts (%.30s).", type, ip, user_hostfile); else log("Warning: Permanently added the %s host key for IP address '%.30s' to the list of known hosts.", type, ip); } else if (ip_status != HOST_OK) log("Warning: the %s host key for '%.200s' differs from the key for the IP address '%.30s'", type, host, ip); } break; case HOST_NEW: /* The host is new. */ if (options.strict_host_key_checking == 1) { /* User has requested strict host key checking. We will not add the host key automatically. The only alternative left is to abort. */ fatal("No %s host key is known for %.200s and you have requested strict checking.", type, host); } else if (options.strict_host_key_checking == 2) { /* The default */ char prompt[1024]; char *fp = key_fingerprint(host_key); snprintf(prompt, sizeof(prompt), "The authenticity of host '%.200s' can't be established.\n" "%s key fingerprint is %s.\n" "Are you sure you want to continue connecting (yes/no)? ", host, type, fp); if (!read_yes_or_no(prompt, -1)) fatal("Aborted by user!\n"); } if (options.check_host_ip && ip_status == HOST_NEW && strcmp(host, ip)) { snprintf(hostline, sizeof(hostline), "%s,%s", host, ip); hostp = hostline; } else hostp = host; /* If not in strict mode, add the key automatically to the local known_hosts file. */ if (!add_host_to_hostfile(user_hostfile, hostp, host_key)) log("Failed to add the host to the list of known hosts (%.500s).", user_hostfile); else log("Warning: Permanently added '%.200s' (%s) to the list of known hosts.", hostp, type); break; case HOST_CHANGED: if (options.check_host_ip && host_ip_differ) { char *msg; if (ip_status == HOST_NEW) msg = "is unknown"; else if (ip_status == HOST_OK) msg = "is unchanged"; else msg = "has a different value"; error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"); error("@ WARNING: POSSIBLE DNS SPOOFING DETECTED! @"); error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"); error("The %s host key for %s has changed,", type, host); error("and the key for the according IP address %s", ip); error("%s. This could either mean that", msg); error("DNS SPOOFING is happening or the IP address for the host"); error("and its host key have changed at the same time"); } /* The host key has changed. */ error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"); error("@ WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! @"); error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"); error("IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!"); error("Someone could be eavesdropping on you right now (man-in-the-middle attack)!"); error("It is also possible that the %s host key has just been changed.", type); error("Please contact your system administrator."); error("Add correct host key in %.100s to get rid of this message.", user_hostfile); /* * If strict host key checking is in use, the user will have * to edit the key manually and we can only abort. */ if (options.strict_host_key_checking) fatal("%s host key for %.200s has changed and you have requested strict checking.", type, host); /* * If strict host key checking has not been requested, allow * the connection but without password authentication or * agent forwarding. */ if (options.password_authentication) { error("Password authentication is disabled to avoid trojan horses."); options.password_authentication = 0; } if (options.forward_agent) { error("Agent forwarding is disabled to avoid trojan horses."); options.forward_agent = 0; } /* * XXX Should permit the user to change to use the new id. * This could be done by converting the host key to an * identifying sentence, tell that the host identifies itself * by that sentence, and ask the user if he/she whishes to * accept the authentication. */ break; } if (options.check_host_ip) xfree(ip); } #ifdef KRB5 int try_krb5_authentication(krb5_context *context, krb5_auth_context *auth_context) { krb5_error_code problem; const char *tkfile; struct stat buf; krb5_ccache ccache = NULL; const char *remotehost; krb5_data ap; int type, payload_len; krb5_ap_rep_enc_part *reply = NULL; int ret; memset(&ap, 0, sizeof(ap)); problem = krb5_init_context(context); if (problem) { ret = 0; goto out; } tkfile = krb5_cc_default_name(*context); if (strncmp(tkfile, "FILE:", 5) == 0) tkfile += 5; if (stat(tkfile, &buf) == 0 && getuid() != buf.st_uid) { debug("Kerberos V5: could not get default ccache (permission denied)."); ret = 0; goto out; } problem = krb5_cc_default(*context, &ccache); if (problem) { ret = 0; goto out; } remotehost = get_canonical_hostname(); problem = krb5_mk_req(*context, auth_context, AP_OPTS_MUTUAL_REQUIRED, "host", remotehost, NULL, ccache, &ap); if (problem) { ret = 0; goto out; } packet_start(SSH_CMSG_AUTH_KERBEROS); packet_put_string((char *) ap.data, ap.length); packet_send(); packet_write_wait(); xfree(ap.data); ap.length = 0; type = packet_read(&payload_len); switch (type) { case SSH_SMSG_FAILURE: /* Should really be SSH_SMSG_AUTH_KERBEROS_FAILURE */ debug("Kerberos V5 authentication failed."); ret = 0; break; case SSH_SMSG_AUTH_KERBEROS_RESPONSE: /* SSH_SMSG_AUTH_KERBEROS_SUCCESS */ debug("Kerberos V5 authentication accepted."); /* Get server's response. */ ap.data = packet_get_string((unsigned int *) &ap.length); packet_integrity_check(payload_len, 4 + ap.length, type); /* XXX je to dobre? */ problem = krb5_rd_rep(*context, *auth_context, &ap, &reply); if (problem) { ret = 0; } ret = 1; break; default: packet_disconnect("Protocol error on Kerberos V5 response: %d", type); ret = 0; break; } out: if (ccache != NULL) krb5_cc_close(*context, ccache); if (reply != NULL) krb5_free_ap_rep_enc_part(*context, reply); if (ap.length > 0) krb5_data_free(&ap); return ret; } void send_krb5_tgt(krb5_context context, krb5_auth_context auth_context) { int fd; int type, payload_len; krb5_error_code problem; krb5_data outbuf; krb5_ccache ccache = NULL; krb5_creds creds; krb5_kdc_flags flags; const char* remotehost = get_canonical_hostname(); memset(&creds, 0, sizeof(creds)); memset(&outbuf, 0, sizeof(outbuf)); fd = packet_get_connection_in(); problem = krb5_auth_con_setaddrs_from_fd(context, auth_context, &fd); if (problem) { goto out; } #if 0 tkfile = krb5_cc_default_name(context); if (strncmp(tkfile, "FILE:", 5) == 0) tkfile += 5; if (stat(tkfile, &buf) == 0 && getuid() != buf.st_uid) { debug("Kerberos V5: could not get default ccache (permission denied)."); goto out; } #endif problem = krb5_cc_default(context, &ccache); if (problem) { goto out; } problem = krb5_cc_get_principal(context, ccache, &creds.client); if (problem) { goto out; } problem = krb5_build_principal(context, &creds.server, strlen(creds.client->realm), creds.client->realm, "krbtgt", creds.client->realm, NULL); if (problem) { goto out; } creds.times.endtime = 0; flags.i = 0; flags.b.forwarded = 1; flags.b.forwardable = krb5_config_get_bool(context, NULL, "libdefaults", "forwardable", NULL); problem = krb5_get_forwarded_creds (context, auth_context, ccache, flags.i, remotehost, &creds, &outbuf); if (problem) { goto out; } packet_start(SSH_CMSG_HAVE_KERBEROS_TGT); packet_put_string((char *)outbuf.data, outbuf.length); packet_send(); packet_write_wait(); type = packet_read(&payload_len); switch (type) { case SSH_SMSG_SUCCESS: break; case SSH_SMSG_FAILURE: break; default: break; } out: if (creds.client) krb5_free_principal(context, creds.client); if (creds.server) krb5_free_principal(context, creds.server); if (ccache) krb5_cc_close(context, ccache); if (outbuf.data) xfree(outbuf.data); return; } #endif /* KRB5 */ /* * Starts a dialog with the server, and authenticates the current user on the * server. This does not need any extra privileges. The basic connection * to the server must already have been established before this is called. * If login fails, this function prints an error and never returns. * This function does not require super-user privileges. */ void ssh_login(int host_key_valid, RSA *own_host_key, const char *orighost, struct sockaddr *hostaddr, uid_t original_real_uid) { struct passwd *pw; char *host, *cp; char *server_user, *local_user; /* Get local user name. Use it as server user if no user name was given. */ pw = getpwuid(original_real_uid); if (!pw) fatal("User id %u not found from user database.", original_real_uid); local_user = xstrdup(pw->pw_name); server_user = options.user ? options.user : local_user; /* Convert the user-supplied hostname into all lowercase. */ host = xstrdup(orighost); for (cp = host; *cp; cp++) if (isupper(*cp)) *cp = tolower(*cp); /* Exchange protocol version identification strings with the server. */ ssh_exchange_identification(); /* Put the connection into non-blocking mode. */ packet_set_nonblocking(); /* key exchange */ /* authenticate user */ if (compat20) { ssh_kex2(host, hostaddr); ssh_userauth2(server_user, host); } else { ssh_kex(host, hostaddr); ssh_userauth(local_user, server_user, host, host_key_valid, own_host_key); } } void ssh_put_password(char *password) { int size; char *padded; size = roundup(strlen(password) + 1, 32); padded = xmalloc(size); memset(padded, 0, size); strlcpy(padded, password, size); packet_put_string(padded, size); memset(padded, 0, size); xfree(padded); }