sshconnect.c

   1 /*
   2  * Author: Tatu Ylonen <ylo@cs.hut.fi>
   3  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
   4  *                    All rights reserved
   5  * Created: Sat Mar 18 22:15:47 1995 ylo
   6  * Code to connect to a remote host, and to perform the client side of the
   7  * login (authentication) dialog.
   8  *
   9  * SSH2 support added by Markus Friedl.
  10  */
  11
  12 #include "includes.h"
  13 RCSID("$OpenBSD: sshconnect.c,v 1.68 2000/04/14 10:30:33 markus Exp $");
  14
  15 #ifdef HAVE_OPENSSL
  16 #include <openssl/bn.h>
  17 #include <openssl/rsa.h>
  18 #include <openssl/dsa.h>
  19 #include <openssl/md5.h>
  20 #endif
  21 #ifdef HAVE_SSL
  22 #include <ssl/bn.h>
  23 #include <ssl/rsa.h>
  24 #include <ssl/dsa.h>
  25 #include <ssl/md5.h>
  26 #endif
  27
  28 #include "xmalloc.h"
  29 #include "rsa.h"
  30 #include "ssh.h"
  31 #include "buffer.h"
  32 #include "packet.h"
  33 #include "authfd.h"
  34 #include "cipher.h"
  35 #include "mpaux.h"
  36 #include "uidswap.h"
  37 #include "compat.h"
  38 #include "readconf.h"
  39
  40 #include "bufaux.h"
  41
  42 #include "ssh2.h"
  43 #include "kex.h"
  44 #include "myproposal.h"
  45 #include "key.h"
  46 #include "dsa.h"
  47 #include "hostfile.h"
  48
  49 /* Session id for the current session. */
  50 unsigned char session_id[16];
  51
  52 /* authentications supported by server */
  53 unsigned int supported_authentications;
  54
  55 static char *client_version_string = NULL;
  56 static char *server_version_string = NULL;
  57
  58 extern Options options;
  59 extern char *__progname;
  60
  61 /*
  62  * Connect to the given ssh server using a proxy command.
  63  */
  64 int
  65 ssh_proxy_connect(const char *host, u_short port, uid_t original_real_uid,
  66                   const char *proxy_command)
  67 {
  68         Buffer command;
  69         const char *cp;
  70         char *command_string;
  71         int pin[2], pout[2];
  72         int pid;
  73         char strport[NI_MAXSERV];
  74
  75         /* Convert the port number into a string. */
  76         snprintf(strport, sizeof strport, "%hu", port);
  77
  78         /* Build the final command string in the buffer by making the
  79            appropriate substitutions to the given proxy command. */
  80         buffer_init(&command);
  81         for (cp = proxy_command; *cp; cp++) {
  82                 if (cp[0] == '%' && cp[1] == '%') {
  83                         buffer_append(&command, "%", 1);
  84                         cp++;
  85                         continue;
  86                 }
  87                 if (cp[0] == '%' && cp[1] == 'h') {
  88                         buffer_append(&command, host, strlen(host));
  89                         cp++;
  90                         continue;
  91                 }
  92                 if (cp[0] == '%' && cp[1] == 'p') {
  93                         buffer_append(&command, strport, strlen(strport));
  94                         cp++;
  95                         continue;
  96                 }
  97                 buffer_append(&command, cp, 1);
  98         }
  99         buffer_append(&command, "\0", 1);
 100
 101         /* Get the final command string. */
 102         command_string = buffer_ptr(&command);
 103
 104         /* Create pipes for communicating with the proxy. */
 105         if (pipe(pin) < 0 || pipe(pout) < 0)
 106                 fatal("Could not create pipes to communicate with the proxy: %.100s",
 107                       strerror(errno));
 108
 109         debug("Executing proxy command: %.500s", command_string);
 110
 111         /* Fork and execute the proxy command. */
 112         if ((pid = fork()) == 0) {
 113                 char *argv[10];
 114
 115                 /* Child.  Permanently give up superuser privileges. */
 116                 permanently_set_uid(original_real_uid);
 117
 118                 /* Redirect stdin and stdout. */
 119                 close(pin[1]);
 120                 if (pin[0] != 0) {
 121                         if (dup2(pin[0], 0) < 0)
 122                                 perror("dup2 stdin");
 123                         close(pin[0]);
 124                 }
 125                 close(pout[0]);
 126                 if (dup2(pout[1], 1) < 0)
 127                         perror("dup2 stdout");
 128                 /* Cannot be 1 because pin allocated two descriptors. */
 129                 close(pout[1]);
 130
 131                 /* Stderr is left as it is so that error messages get
 132                    printed on the user's terminal. */
 133                 argv[0] = "/bin/sh";
 134                 argv[1] = "-c";
 135                 argv[2] = command_string;
 136                 argv[3] = NULL;
 137
 138                 /* Execute the proxy command.  Note that we gave up any
 139                    extra privileges above. */
 140                 execv("/bin/sh", argv);
 141                 perror("/bin/sh");
 142                 exit(1);
 143         }
 144         /* Parent. */
 145         if (pid < 0)
 146                 fatal("fork failed: %.100s", strerror(errno));
 147
 148         /* Close child side of the descriptors. */
 149         close(pin[0]);
 150         close(pout[1]);
 151
 152         /* Free the command name. */
 153         buffer_free(&command);
 154
 155         /* Set the connection file descriptors. */
 156         packet_set_connection(pout[0], pin[1]);
 157
 158         return 1;
 159 }
 160
 161 /*
 162  * Creates a (possibly privileged) socket for use as the ssh connection.
 163  */
 164 int
 165 ssh_create_socket(uid_t original_real_uid, int privileged, int family)
 166 {
 167         int sock;
 168
 169         /*
 170          * If we are running as root and want to connect to a privileged
 171          * port, bind our own socket to a privileged port.
 172          */
 173         if (privileged) {
 174                 int p = IPPORT_RESERVED - 1;
 175                 sock = rresvport_af(&p, family);
 176                 if (sock < 0)
 177                         error("rresvport: af=%d %.100s", family, strerror(errno));
 178                 else
 179                         debug("Allocated local port %d.", p);
 180         } else {
 181                 /*
 182                  * Just create an ordinary socket on arbitrary port.  We use
 183                  * the user's uid to create the socket.
 184                  */
 185                 temporarily_use_uid(original_real_uid);
 186                 sock = socket(family, SOCK_STREAM, 0);
 187                 if (sock < 0)
 188                         error("socket: %.100s", strerror(errno));
 189                 restore_uid();
 190         }
 191         return sock;
 192 }
 193
 194 /*
 195  * Opens a TCP/IP connection to the remote server on the given host.
 196  * The address of the remote host will be returned in hostaddr.
 197  * If port is 0, the default port will be used.  If anonymous is zero,
 198  * a privileged port will be allocated to make the connection.
 199  * This requires super-user privileges if anonymous is false.
 200  * Connection_attempts specifies the maximum number of tries (one per
 201  * second).  If proxy_command is non-NULL, it specifies the command (with %h
 202  * and %p substituted for host and port, respectively) to use to contact
 203  * the daemon.
 204  */
 205 int
 206 ssh_connect(const char *host, struct sockaddr_storage * hostaddr,
 207             u_short port, int connection_attempts,
 208             int anonymous, uid_t original_real_uid,
 209             const char *proxy_command)
 210 {
 211         int sock = -1, attempt;
 212         struct servent *sp;
 213         struct addrinfo hints, *ai, *aitop;
 214         char ntop[NI_MAXHOST], strport[NI_MAXSERV];
 215         int gaierr;
 216         struct linger linger;
 217
 218         debug("ssh_connect: getuid %d geteuid %d anon %d",
 219               (int) getuid(), (int) geteuid(), anonymous);
 220
 221         /* Get default port if port has not been set. */
 222         if (port == 0) {
 223                 sp = getservbyname(SSH_SERVICE_NAME, "tcp");
 224                 if (sp)
 225                         port = ntohs(sp->s_port);
 226                 else
 227                         port = SSH_DEFAULT_PORT;
 228         }
 229         /* If a proxy command is given, connect using it. */
 230         if (proxy_command != NULL)
 231                 return ssh_proxy_connect(host, port, original_real_uid, proxy_command);
 232
 233         /* No proxy command. */
 234
 235         memset(&hints, 0, sizeof(hints));
 236         hints.ai_family = IPv4or6;
 237         hints.ai_socktype = SOCK_STREAM;
 238         snprintf(strport, sizeof strport, "%d", port);
 239         if ((gaierr = getaddrinfo(host, strport, &hints, &aitop)) != 0)
 240                 fatal("%s: %.100s: %s", __progname, host,
 241                     gai_strerror(gaierr));
 242
 243         /*
 244          * Try to connect several times.  On some machines, the first time
 245          * will sometimes fail.  In general socket code appears to behave
 246          * quite magically on many machines.
 247          */
 248         for (attempt = 0; attempt < connection_attempts; attempt++) {
 249                 if (attempt > 0)
 250                         debug("Trying again...");
 251
 252                 /* Loop through addresses for this host, and try each one in
 253                    sequence until the connection succeeds. */
 254                 for (ai = aitop; ai; ai = ai->ai_next) {
 255                         if (ai->ai_family != AF_INET && ai->ai_family != AF_INET6)
 256                                 continue;
 257                         if (getnameinfo(ai->ai_addr, ai->ai_addrlen,
 258                             ntop, sizeof(ntop), strport, sizeof(strport),
 259                             NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
 260                                 error("ssh_connect: getnameinfo failed");
 261                                 continue;
 262                         }
 263                         debug("Connecting to %.200s [%.100s] port %s.",
 264                                 host, ntop, strport);
 265
 266                         /* Create a socket for connecting. */
 267                         sock = ssh_create_socket(original_real_uid,
 268                             !anonymous && geteuid() == 0 && port < IPPORT_RESERVED,
 269                             ai->ai_family);
 270                         if (sock < 0)
 271                                 continue;
 272
 273                         /* Connect to the host.  We use the user's uid in the
 274                          * hope that it will help with tcp_wrappers showing
 275                          * the remote uid as root.
 276                          */
 277                         temporarily_use_uid(original_real_uid);
 278                         if (connect(sock, ai->ai_addr, ai->ai_addrlen) >= 0) {
 279                                 /* Successful connection. */
 280                                 memcpy(hostaddr, ai->ai_addr, sizeof(*(ai->ai_addr)));
 281                                 restore_uid();
 282                                 break;
 283                         } else {
 284                                 debug("connect: %.100s", strerror(errno));
 285                                 restore_uid();
 286                                 /*
 287                                  * Close the failed socket; there appear to
 288                                  * be some problems when reusing a socket for
 289                                  * which connect() has already returned an
 290                                  * error.
 291                                  */
 292                                 shutdown(sock, SHUT_RDWR);
 293                                 close(sock);
 294                         }
 295                 }
 296                 if (ai)
 297                         break;  /* Successful connection. */
 298
 299                 /* Sleep a moment before retrying. */
 300                 sleep(1);
 301         }
 302
 303         freeaddrinfo(aitop);
 304
 305         /* Return failure if we didn't get a successful connection. */
 306         if (attempt >= connection_attempts)
 307                 return 0;
 308
 309         debug("Connection established.");
 310
 311         /*
 312          * Set socket options.  We would like the socket to disappear as soon
 313          * as it has been closed for whatever reason.
 314          */
 315         /* setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&on, sizeof(on)); */
 316         linger.l_onoff = 1;
 317         linger.l_linger = 5;
 318         setsockopt(sock, SOL_SOCKET, SO_LINGER, (void *) &linger, sizeof(linger));
 319
 320         /* Set the connection. */
 321         packet_set_connection(sock, sock);
 322
 323         return 1;
 324 }
 325
 326 /*
 327  * Checks if the user has an authentication agent, and if so, tries to
 328  * authenticate using the agent.
 329  */
 330 int
 331 try_agent_authentication()
 332 {
 333         int status, type;
 334         char *comment;
 335         AuthenticationConnection *auth;
 336         unsigned char response[16];
 337         unsigned int i;
 338         BIGNUM *e, *n, *challenge;
 339
 340         /* Get connection to the agent. */
 341         auth = ssh_get_authentication_connection();
 342         if (!auth)
 343                 return 0;
 344
 345         e = BN_new();
 346         n = BN_new();
 347         challenge = BN_new();
 348
 349         /* Loop through identities served by the agent. */
 350         for (status = ssh_get_first_identity(auth, e, n, &comment);
 351              status;
 352              status = ssh_get_next_identity(auth, e, n, &comment)) {
 353                 int plen, clen;
 354
 355                 /* Try this identity. */
 356                 debug("Trying RSA authentication via agent with '%.100s'", comment);
 357                 xfree(comment);
 358
 359                 /* Tell the server that we are willing to authenticate using this key. */
 360                 packet_start(SSH_CMSG_AUTH_RSA);
 361                 packet_put_bignum(n);
 362                 packet_send();
 363                 packet_write_wait();
 364
 365                 /* Wait for server's response. */
 366                 type = packet_read(&plen);
 367
 368                 /* The server sends failure if it doesn\'t like our key or
 369                    does not support RSA authentication. */
 370                 if (type == SSH_SMSG_FAILURE) {
 371                         debug("Server refused our key.");
 372                         continue;
 373                 }
 374                 /* Otherwise it should have sent a challenge. */
 375                 if (type != SSH_SMSG_AUTH_RSA_CHALLENGE)
 376                         packet_disconnect("Protocol error during RSA authentication: %d",
 377                                           type);
 378
 379                 packet_get_bignum(challenge, &clen);
 380
 381                 packet_integrity_check(plen, clen, type);
 382
 383                 debug("Received RSA challenge from server.");
 384
 385                 /* Ask the agent to decrypt the challenge. */
 386                 if (!ssh_decrypt_challenge(auth, e, n, challenge,
 387                                            session_id, 1, response)) {
 388                         /* The agent failed to authenticate this identifier although it
 389                            advertised it supports this.  Just return a wrong value. */
 390                         log("Authentication agent failed to decrypt challenge.");
 391                         memset(response, 0, sizeof(response));
 392                 }
 393                 debug("Sending response to RSA challenge.");
 394
 395                 /* Send the decrypted challenge back to the server. */
 396                 packet_start(SSH_CMSG_AUTH_RSA_RESPONSE);
 397                 for (i = 0; i < 16; i++)
 398                         packet_put_char(response[i]);
 399                 packet_send();
 400                 packet_write_wait();
 401
 402                 /* Wait for response from the server. */
 403                 type = packet_read(&plen);
 404
 405                 /* The server returns success if it accepted the authentication. */
 406                 if (type == SSH_SMSG_SUCCESS) {
 407                         debug("RSA authentication accepted by server.");
 408                         BN_clear_free(e);
 409                         BN_clear_free(n);
 410                         BN_clear_free(challenge);
 411                         return 1;
 412                 }
 413                 /* Otherwise it should return failure. */
 414                 if (type != SSH_SMSG_FAILURE)
 415                         packet_disconnect("Protocol error waiting RSA auth response: %d",
 416                                           type);
 417         }
 418
 419         BN_clear_free(e);
 420         BN_clear_free(n);
 421         BN_clear_free(challenge);
 422
 423         debug("RSA authentication using agent refused.");
 424         return 0;
 425 }
 426
 427 /*
 428  * Computes the proper response to a RSA challenge, and sends the response to
 429  * the server.
 430  */
 431 void
 432 respond_to_rsa_challenge(BIGNUM * challenge, RSA * prv)
 433 {
 434         unsigned char buf[32], response[16];
 435         MD5_CTX md;
 436         int i, len;
 437
 438         /* Decrypt the challenge using the private key. */
 439         rsa_private_decrypt(challenge, challenge, prv);
 440
 441         /* Compute the response. */
 442         /* The response is MD5 of decrypted challenge plus session id. */
 443         len = BN_num_bytes(challenge);
 444         if (len <= 0 || len > sizeof(buf))
 445                 packet_disconnect("respond_to_rsa_challenge: bad challenge length %d",
 446                                   len);
 447
 448         memset(buf, 0, sizeof(buf));
 449         BN_bn2bin(challenge, buf + sizeof(buf) - len);
 450         MD5_Init(&md);
 451         MD5_Update(&md, buf, 32);
 452         MD5_Update(&md, session_id, 16);
 453         MD5_Final(response, &md);
 454
 455         debug("Sending response to host key RSA challenge.");
 456
 457         /* Send the response back to the server. */
 458         packet_start(SSH_CMSG_AUTH_RSA_RESPONSE);
 459         for (i = 0; i < 16; i++)
 460                 packet_put_char(response[i]);
 461         packet_send();
 462         packet_write_wait();
 463
 464         memset(buf, 0, sizeof(buf));
 465         memset(response, 0, sizeof(response));
 466         memset(&md, 0, sizeof(md));
 467 }
 468
 469 /*
 470  * Checks if the user has authentication file, and if so, tries to authenticate
 471  * the user using it.
 472  */
 473 int
 474 try_rsa_authentication(const char *authfile)
 475 {
 476         BIGNUM *challenge;
 477         RSA *private_key;
 478         RSA *public_key;
 479         char *passphrase, *comment;
 480         int type, i;
 481         int plen, clen;
 482
 483         /* Try to load identification for the authentication key. */
 484         public_key = RSA_new();
 485         if (!load_public_key(authfile, public_key, &comment)) {
 486                 RSA_free(public_key);
 487                 /* Could not load it.  Fail. */
 488                 return 0;
 489         }
 490         debug("Trying RSA authentication with key '%.100s'", comment);
 491
 492         /* Tell the server that we are willing to authenticate using this key. */
 493         packet_start(SSH_CMSG_AUTH_RSA);
 494         packet_put_bignum(public_key->n);
 495         packet_send();
 496         packet_write_wait();
 497
 498         /* We no longer need the public key. */
 499         RSA_free(public_key);
 500
 501         /* Wait for server's response. */
 502         type = packet_read(&plen);
 503
 504         /*
 505          * The server responds with failure if it doesn\'t like our key or
 506          * doesn\'t support RSA authentication.
 507          */
 508         if (type == SSH_SMSG_FAILURE) {
 509                 debug("Server refused our key.");
 510                 xfree(comment);
 511                 return 0;
 512         }
 513         /* Otherwise, the server should respond with a challenge. */
 514         if (type != SSH_SMSG_AUTH_RSA_CHALLENGE)
 515                 packet_disconnect("Protocol error during RSA authentication: %d", type);
 516
 517         /* Get the challenge from the packet. */
 518         challenge = BN_new();
 519         packet_get_bignum(challenge, &clen);
 520
 521         packet_integrity_check(plen, clen, type);
 522
 523         debug("Received RSA challenge from server.");
 524
 525         private_key = RSA_new();
 526         /*
 527          * Load the private key.  Try first with empty passphrase; if it
 528          * fails, ask for a passphrase.
 529          */
 530         if (!load_private_key(authfile, "", private_key, NULL)) {
 531                 char buf[300];
 532                 snprintf(buf, sizeof buf, "Enter passphrase for RSA key '%.100s': ",
 533                     comment);
 534                 if (!options.batch_mode)
 535                         passphrase = read_passphrase(buf, 0);
 536                 else {
 537                         debug("Will not query passphrase for %.100s in batch mode.",
 538                               comment);
 539                         passphrase = xstrdup("");
 540                 }
 541
 542                 /* Load the authentication file using the pasphrase. */
 543                 if (!load_private_key(authfile, passphrase, private_key, NULL)) {
 544                         memset(passphrase, 0, strlen(passphrase));
 545                         xfree(passphrase);
 546                         error("Bad passphrase.");
 547
 548                         /* Send a dummy response packet to avoid protocol error. */
 549                         packet_start(SSH_CMSG_AUTH_RSA_RESPONSE);
 550                         for (i = 0; i < 16; i++)
 551                                 packet_put_char(0);
 552                         packet_send();
 553                         packet_write_wait();
 554
 555                         /* Expect the server to reject it... */
 556                         packet_read_expect(&plen, SSH_SMSG_FAILURE);
 557                         xfree(comment);
 558                         return 0;
 559                 }
 560                 /* Destroy the passphrase. */
 561                 memset(passphrase, 0, strlen(passphrase));
 562                 xfree(passphrase);
 563         }
 564         /* We no longer need the comment. */
 565         xfree(comment);
 566
 567         /* Compute and send a response to the challenge. */
 568         respond_to_rsa_challenge(challenge, private_key);
 569
 570         /* Destroy the private key. */
 571         RSA_free(private_key);
 572
 573         /* We no longer need the challenge. */
 574         BN_clear_free(challenge);
 575
 576         /* Wait for response from the server. */
 577         type = packet_read(&plen);
 578         if (type == SSH_SMSG_SUCCESS) {
 579                 debug("RSA authentication accepted by server.");
 580                 return 1;
 581         }
 582         if (type != SSH_SMSG_FAILURE)
 583                 packet_disconnect("Protocol error waiting RSA auth response: %d", type);
 584         debug("RSA authentication refused.");
 585         return 0;
 586 }
 587
 588 /*
 589  * Tries to authenticate the user using combined rhosts or /etc/hosts.equiv
 590  * authentication and RSA host authentication.
 591  */
 592 int
 593 try_rhosts_rsa_authentication(const char *local_user, RSA * host_key)
 594 {
 595         int type;
 596         BIGNUM *challenge;
 597         int plen, clen;
 598
 599         debug("Trying rhosts or /etc/hosts.equiv with RSA host authentication.");
 600
 601         /* Tell the server that we are willing to authenticate using this key. */
 602         packet_start(SSH_CMSG_AUTH_RHOSTS_RSA);
 603         packet_put_string(local_user, strlen(local_user));
 604         packet_put_int(BN_num_bits(host_key->n));
 605         packet_put_bignum(host_key->e);
 606         packet_put_bignum(host_key->n);
 607         packet_send();
 608         packet_write_wait();
 609
 610         /* Wait for server's response. */
 611         type = packet_read(&plen);
 612
 613         /* The server responds with failure if it doesn't admit our
 614            .rhosts authentication or doesn't know our host key. */
 615         if (type == SSH_SMSG_FAILURE) {
 616                 debug("Server refused our rhosts authentication or host key.");
 617                 return 0;
 618         }
 619         /* Otherwise, the server should respond with a challenge. */
 620         if (type != SSH_SMSG_AUTH_RSA_CHALLENGE)
 621                 packet_disconnect("Protocol error during RSA authentication: %d", type);
 622
 623         /* Get the challenge from the packet. */
 624         challenge = BN_new();
 625         packet_get_bignum(challenge, &clen);
 626
 627         packet_integrity_check(plen, clen, type);
 628
 629         debug("Received RSA challenge for host key from server.");
 630
 631         /* Compute a response to the challenge. */
 632         respond_to_rsa_challenge(challenge, host_key);
 633
 634         /* We no longer need the challenge. */
 635         BN_clear_free(challenge);
 636
 637         /* Wait for response from the server. */
 638         type = packet_read(&plen);
 639         if (type == SSH_SMSG_SUCCESS) {
 640                 debug("Rhosts or /etc/hosts.equiv with RSA host authentication accepted by server.");
 641                 return 1;
 642         }
 643         if (type != SSH_SMSG_FAILURE)
 644                 packet_disconnect("Protocol error waiting RSA auth response: %d", type);
 645         debug("Rhosts or /etc/hosts.equiv with RSA host authentication refused.");
 646         return 0;
 647 }
 648
 649 #ifdef KRB4
 650 int
 651 try_kerberos_authentication()
 652 {
 653         KTEXT_ST auth;          /* Kerberos data */
 654         char *reply;
 655         char inst[INST_SZ];
 656         char *realm;
 657         CREDENTIALS cred;
 658         int r, type, plen;
 659         socklen_t slen;
 660         Key_schedule schedule;
 661         u_long checksum, cksum;
 662         MSG_DAT msg_data;
 663         struct sockaddr_in local, foreign;
 664         struct stat st;
 665
 666         /* Don't do anything if we don't have any tickets. */
 667         if (stat(tkt_string(), &st) < 0)
 668                 return 0;
 669
 670         strncpy(inst, (char *) krb_get_phost(get_canonical_hostname()), INST_SZ);
 671
 672         realm = (char *) krb_realmofhost(get_canonical_hostname());
 673         if (!realm) {
 674                 debug("Kerberos V4: no realm for %s", get_canonical_hostname());
 675                 return 0;
 676         }
 677         /* This can really be anything. */
 678         checksum = (u_long) getpid();
 679
 680         r = krb_mk_req(&auth, KRB4_SERVICE_NAME, inst, realm, checksum);
 681         if (r != KSUCCESS) {
 682                 debug("Kerberos V4 krb_mk_req failed: %s", krb_err_txt[r]);
 683                 return 0;
 684         }
 685         /* Get session key to decrypt the server's reply with. */
 686         r = krb_get_cred(KRB4_SERVICE_NAME, inst, realm, &cred);
 687         if (r != KSUCCESS) {
 688                 debug("get_cred failed: %s", krb_err_txt[r]);
 689                 return 0;
 690         }
 691         des_key_sched((des_cblock *) cred.session, schedule);
 692
 693         /* Send authentication info to server. */
 694         packet_start(SSH_CMSG_AUTH_KERBEROS);
 695         packet_put_string((char *) auth.dat, auth.length);
 696         packet_send();
 697         packet_write_wait();
 698
 699         /* Zero the buffer. */
 700         (void) memset(auth.dat, 0, MAX_KTXT_LEN);
 701
 702         slen = sizeof(local);
 703         memset(&local, 0, sizeof(local));
 704         if (getsockname(packet_get_connection_in(),
 705                         (struct sockaddr *) & local, &slen) < 0)
 706                 debug("getsockname failed: %s", strerror(errno));
 707
 708         slen = sizeof(foreign);
 709         memset(&foreign, 0, sizeof(foreign));
 710         if (getpeername(packet_get_connection_in(),
 711                         (struct sockaddr *) & foreign, &slen) < 0) {
 712                 debug("getpeername failed: %s", strerror(errno));
 713                 fatal_cleanup();
 714         }
 715         /* Get server reply. */
 716         type = packet_read(&plen);
 717         switch (type) {
 718         case SSH_SMSG_FAILURE:
 719                 /* Should really be SSH_SMSG_AUTH_KERBEROS_FAILURE */
 720                 debug("Kerberos V4 authentication failed.");
 721                 return 0;
 722                 break;
 723
 724         case SSH_SMSG_AUTH_KERBEROS_RESPONSE:
 725                 /* SSH_SMSG_AUTH_KERBEROS_SUCCESS */
 726                 debug("Kerberos V4 authentication accepted.");
 727
 728                 /* Get server's response. */
 729                 reply = packet_get_string((unsigned int *) &auth.length);
 730                 memcpy(auth.dat, reply, auth.length);
 731                 xfree(reply);
 732
 733                 packet_integrity_check(plen, 4 + auth.length, type);
 734
 735                 /*
 736                  * If his response isn't properly encrypted with the session
 737                  * key, and the decrypted checksum fails to match, he's
 738                  * bogus. Bail out.
 739                  */
 740                 r = krb_rd_priv(auth.dat, auth.length, schedule, &cred.session,
 741                                 &foreign, &local, &msg_data);
 742                 if (r != KSUCCESS) {
 743                         debug("Kerberos V4 krb_rd_priv failed: %s", krb_err_txt[r]);
 744                         packet_disconnect("Kerberos V4 challenge failed!");
 745                 }
 746                 /* Fetch the (incremented) checksum that we supplied in the request. */
 747                 (void) memcpy((char *) &cksum, (char *) msg_data.app_data, sizeof(cksum));
 748                 cksum = ntohl(cksum);
 749
 750                 /* If it matches, we're golden. */
 751                 if (cksum == checksum + 1) {
 752                         debug("Kerberos V4 challenge successful.");
 753                         return 1;
 754                 } else
 755                         packet_disconnect("Kerberos V4 challenge failed!");
 756                 break;
 757
 758         default:
 759                 packet_disconnect("Protocol error on Kerberos V4 response: %d", type);
 760         }
 761         return 0;
 762 }
 763
 764 #endif /* KRB4 */
 765
 766 #ifdef AFS
 767 int
 768 send_kerberos_tgt()
 769 {
 770         CREDENTIALS *creds;
 771         char pname[ANAME_SZ], pinst[INST_SZ], prealm[REALM_SZ];
 772         int r, type, plen;
 773         char buffer[8192];
 774         struct stat st;
 775
 776         /* Don't do anything if we don't have any tickets. */
 777         if (stat(tkt_string(), &st) < 0)
 778                 return 0;
 779
 780         creds = xmalloc(sizeof(*creds));
 781
 782         if ((r = krb_get_tf_fullname(TKT_FILE, pname, pinst, prealm)) != KSUCCESS) {
 783                 debug("Kerberos V4 tf_fullname failed: %s", krb_err_txt[r]);
 784                 return 0;
 785         }
 786         if ((r = krb_get_cred("krbtgt", prealm, prealm, creds)) != GC_OK) {
 787                 debug("Kerberos V4 get_cred failed: %s", krb_err_txt[r]);
 788                 return 0;
 789         }
 790         if (time(0) > krb_life_to_time(creds->issue_date, creds->lifetime)) {
 791                 debug("Kerberos V4 ticket expired: %s", TKT_FILE);
 792                 return 0;
 793         }
 794         creds_to_radix(creds, (unsigned char *)buffer);
 795         xfree(creds);
 796
 797         packet_start(SSH_CMSG_HAVE_KERBEROS_TGT);
 798         packet_put_string(buffer, strlen(buffer));
 799         packet_send();
 800         packet_write_wait();
 801
 802         type = packet_read(&plen);
 803
 804         if (type == SSH_SMSG_FAILURE)
 805                 debug("Kerberos TGT for realm %s rejected.", prealm);
 806         else if (type != SSH_SMSG_SUCCESS)
 807                 packet_disconnect("Protocol error on Kerberos TGT response: %d", type);
 808
 809         return 1;
 810 }
 811
 812 void
 813 send_afs_tokens(void)
 814 {
 815         CREDENTIALS creds;
 816         struct ViceIoctl parms;
 817         struct ClearToken ct;
 818         int i, type, len, plen;
 819         char buf[2048], *p, *server_cell;
 820         char buffer[8192];
 821
 822         /* Move over ktc_GetToken, here's something leaner. */
 823         for (i = 0; i < 100; i++) {     /* just in case */
 824                 parms.in = (char *) &i;
 825                 parms.in_size = sizeof(i);
 826                 parms.out = buf;
 827                 parms.out_size = sizeof(buf);
 828                 if (k_pioctl(0, VIOCGETTOK, &parms, 0) != 0)
 829                         break;
 830                 p = buf;
 831
 832                 /* Get secret token. */
 833                 memcpy(&creds.ticket_st.length, p, sizeof(unsigned int));
 834                 if (creds.ticket_st.length > MAX_KTXT_LEN)
 835                         break;
 836                 p += sizeof(unsigned int);
 837                 memcpy(creds.ticket_st.dat, p, creds.ticket_st.length);
 838                 p += creds.ticket_st.length;
 839
 840                 /* Get clear token. */
 841                 memcpy(&len, p, sizeof(len));
 842                 if (len != sizeof(struct ClearToken))
 843                         break;
 844                 p += sizeof(len);
 845                 memcpy(&ct, p, len);
 846                 p += len;
 847                 p += sizeof(len);       /* primary flag */
 848                 server_cell = p;
 849
 850                 /* Flesh out our credentials. */
 851                 strlcpy(creds.service, "afs", sizeof creds.service);
 852                 creds.instance[0] = '\0';
 853                 strlcpy(creds.realm, server_cell, REALM_SZ);
 854                 memcpy(creds.session, ct.HandShakeKey, DES_KEY_SZ);
 855                 creds.issue_date = ct.BeginTimestamp;
 856                 creds.lifetime = krb_time_to_life(creds.issue_date, ct.EndTimestamp);
 857                 creds.kvno = ct.AuthHandle;
 858                 snprintf(creds.pname, sizeof(creds.pname), "AFS ID %d", ct.ViceId);
 859                 creds.pinst[0] = '\0';
 860
 861                 /* Encode token, ship it off. */
 862                 if (!creds_to_radix(&creds, (unsigned char*) buffer))
 863                         break;
 864                 packet_start(SSH_CMSG_HAVE_AFS_TOKEN);
 865                 packet_put_string(buffer, strlen(buffer));
 866                 packet_send();
 867                 packet_write_wait();
 868
 869                 /* Roger, Roger. Clearance, Clarence. What's your vector,
 870                    Victor? */
 871                 type = packet_read(&plen);
 872
 873                 if (type == SSH_SMSG_FAILURE)
 874                         debug("AFS token for cell %s rejected.", server_cell);
 875                 else if (type != SSH_SMSG_SUCCESS)
 876                         packet_disconnect("Protocol error on AFS token response: %d", type);
 877         }
 878 }
 879
 880 #endif /* AFS */
 881
 882 /*
 883  * Tries to authenticate with any string-based challenge/response system.
 884  * Note that the client code is not tied to s/key or TIS.
 885  */
 886 int
 887 try_skey_authentication()
 888 {
 889         int type, i;
 890         int payload_len;
 891         unsigned int clen;
 892         char *challenge, *response;
 893
 894         debug("Doing skey authentication.");
 895
 896         /* request a challenge */
 897         packet_start(SSH_CMSG_AUTH_TIS);
 898         packet_send();
 899         packet_write_wait();
 900
 901         type = packet_read(&payload_len);
 902         if (type != SSH_SMSG_FAILURE &&
 903             type != SSH_SMSG_AUTH_TIS_CHALLENGE) {
 904                 packet_disconnect("Protocol error: got %d in response "
 905                                   "to skey-auth", type);
 906         }
 907         if (type != SSH_SMSG_AUTH_TIS_CHALLENGE) {
 908                 debug("No challenge for skey authentication.");
 909                 return 0;
 910         }
 911         challenge = packet_get_string(&clen);
 912         packet_integrity_check(payload_len, (4 + clen), type);
 913         if (options.cipher == SSH_CIPHER_NONE)
 914                 log("WARNING: Encryption is disabled! "
 915                     "Reponse will be transmitted in clear text.");
 916         fprintf(stderr, "%s\n", challenge);
 917         xfree(challenge);
 918         fflush(stderr);
 919         for (i = 0; i < options.number_of_password_prompts; i++) {
 920                 if (i != 0)
 921                         error("Permission denied, please try again.");
 922                 response = read_passphrase("Response: ", 0);
 923                 packet_start(SSH_CMSG_AUTH_TIS_RESPONSE);
 924                 packet_put_string(response, strlen(response));
 925                 memset(response, 0, strlen(response));
 926                 xfree(response);
 927                 packet_send();
 928                 packet_write_wait();
 929                 type = packet_read(&payload_len);
 930                 if (type == SSH_SMSG_SUCCESS)
 931                         return 1;
 932                 if (type != SSH_SMSG_FAILURE)
 933                         packet_disconnect("Protocol error: got %d in response "
 934                                           "to skey-auth-reponse", type);
 935         }
 936         /* failure */
 937         return 0;
 938 }
 939
 940 /*
 941  * Tries to authenticate with plain passwd authentication.
 942  */
 943 int
 944 try_password_authentication(char *prompt)
 945 {
 946         int type, i, payload_len;
 947         char *password;
 948
 949         debug("Doing password authentication.");
 950         if (options.cipher == SSH_CIPHER_NONE)
 951                 log("WARNING: Encryption is disabled! Password will be transmitted in clear text.");
 952         for (i = 0; i < options.number_of_password_prompts; i++) {
 953                 if (i != 0)
 954                         error("Permission denied, please try again.");
 955                 password = read_passphrase(prompt, 0);
 956                 packet_start(SSH_CMSG_AUTH_PASSWORD);
 957                 packet_put_string(password, strlen(password));
 958                 memset(password, 0, strlen(password));
 959                 xfree(password);
 960                 packet_send();
 961                 packet_write_wait();
 962
 963                 type = packet_read(&payload_len);
 964                 if (type == SSH_SMSG_SUCCESS)
 965                         return 1;
 966                 if (type != SSH_SMSG_FAILURE)
 967                         packet_disconnect("Protocol error: got %d in response to passwd auth", type);
 968         }
 969         /* failure */
 970         return 0;
 971 }
 972
 973 char *
 974 chop(char *s)
 975 {
 976         char *t = s;
 977         while (*t) {
 978                 if(*t == '\n' || *t == '\r') {
 979                         *t = '\0';
 980                         return s;
 981                 }
 982                 t++;
 983         }
 984         return s;
 985
 986 }
 987
 988 /*
 989  * Waits for the server identification string, and sends our own
 990  * identification string.
 991  */
 992 void
 993 ssh_exchange_identification()
 994 {
 995         char buf[256], remote_version[256];     /* must be same size! */
 996         int remote_major, remote_minor, i, mismatch;
 997         int connection_in = packet_get_connection_in();
 998         int connection_out = packet_get_connection_out();
 999
1000         /* Read other side\'s version identification. */
1001         for (i = 0; i < sizeof(buf) - 1; i++) {
1002                 int len = read(connection_in, &buf[i], 1);
1003                 if (len < 0)
1004                         fatal("ssh_exchange_identification: read: %.100s", strerror(errno));
1005                 if (len != 1)
1006                         fatal("ssh_exchange_identification: Connection closed by remote host");
1007                 if (buf[i] == '\r') {
1008                         buf[i] = '\n';
1009                         buf[i + 1] = 0;
1010                         continue;               /**XXX wait for \n */
1011                 }
1012                 if (buf[i] == '\n') {
1013                         buf[i + 1] = 0;
1014                         break;
1015                 }
1016         }
1017         buf[sizeof(buf) - 1] = 0;
1018         server_version_string = xstrdup(buf);
1019
1020         /*
1021          * Check that the versions match.  In future this might accept
1022          * several versions and set appropriate flags to handle them.
1023          */
1024         if (sscanf(server_version_string, "SSH-%d.%d-%[^\n]\n",
1025             &remote_major, &remote_minor, remote_version) != 3)
1026                 fatal("Bad remote protocol version identification: '%.100s'", buf);
1027         debug("Remote protocol version %d.%d, remote software version %.100s",
1028               remote_major, remote_minor, remote_version);
1029
1030         compat_datafellows(remote_version);
1031         mismatch = 0;
1032
1033         switch(remote_major) {
1034         case 1:
1035                 if (remote_minor == 99 &&
1036                     (options.protocol & SSH_PROTO_2) &&
1037                     !(options.protocol & SSH_PROTO_1_PREFERRED)) {
1038                         enable_compat20();
1039                         break;
1040                 }
1041                 if (!(options.protocol & SSH_PROTO_1)) {
1042                         mismatch = 1;
1043                         break;
1044                 }
1045                 if (remote_minor < 3) {
1046                         fatal("Remote machine has too old SSH software version.");
1047                 } else if (remote_minor == 3) {
1048                         /* We speak 1.3, too. */
1049                         enable_compat13();
1050                         if (options.forward_agent) {
1051                                 log("Agent forwarding disabled for protocol 1.3");
1052                                 options.forward_agent = 0;
1053                         }
1054                 }
1055                 break;
1056         case 2:
1057                 if (options.protocol & SSH_PROTO_2) {
1058                         enable_compat20();
1059                         break;
1060                 }
1061                 /* FALLTHROUGH */
1062         default:
1063                 mismatch = 1;
1064                 break;
1065         }
1066         if (mismatch)
1067                 fatal("Protocol major versions differ: %d vs. %d",
1068                     (options.protocol & SSH_PROTO_2) ? PROTOCOL_MAJOR_2 : PROTOCOL_MAJOR_1,
1069                     remote_major);
1070
1071         /* Send our own protocol version identification. */
1072         snprintf(buf, sizeof buf, "SSH-%d.%d-%.100s\n",
1073             compat20 ? PROTOCOL_MAJOR_2 : PROTOCOL_MAJOR_1,
1074             compat20 ? PROTOCOL_MINOR_2 : PROTOCOL_MINOR_1,
1075             SSH_VERSION);
1076         if (atomicio(write, connection_out, buf, strlen(buf)) != strlen(buf))
1077                 fatal("write: %.100s", strerror(errno));
1078         client_version_string = xstrdup(buf);
1079         chop(client_version_string);
1080         chop(server_version_string);
1081         debug("Local version string %.100s", client_version_string);
1082 }
1083
1084 int
1085 read_yes_or_no(const char *prompt, int defval)
1086 {
1087         char buf[1024];
1088         FILE *f;
1089         int retval = -1;
1090
1091         if (isatty(0))
1092                 f = stdin;
1093         else
1094                 f = fopen("/dev/tty", "rw");
1095
1096         if (f == NULL)
1097                 return 0;
1098
1099         fflush(stdout);
1100
1101         while (1) {
1102                 fprintf(stderr, "%s", prompt);
1103                 if (fgets(buf, sizeof(buf), f) == NULL) {
1104                         /* Print a newline (the prompt probably didn\'t have one). */
1105                         fprintf(stderr, "\n");
1106                         strlcpy(buf, "no", sizeof buf);
1107                 }
1108                 /* Remove newline from response. */
1109                 if (strchr(buf, '\n'))
1110                         *strchr(buf, '\n') = 0;
1111
1112                 if (buf[0] == 0)
1113                         retval = defval;
1114                 if (strcmp(buf, "yes") == 0)
1115                         retval = 1;
1116                 if (strcmp(buf, "no") == 0)
1117                         retval = 0;
1118
1119                 if (retval != -1) {
1120                         if (f != stdin)
1121                                 fclose(f);
1122                         return retval;
1123                 }
1124         }
1125 }
1126
1127 /*
1128  * check whether the supplied host key is valid, return only if ok.
1129  */
1130
1131 void
1132 check_host_key(char *host, struct sockaddr *hostaddr, Key *host_key)
1133 {
1134         Key *file_key;
1135         char *ip = NULL;
1136         char hostline[1000], *hostp;
1137         HostStatus host_status;
1138         HostStatus ip_status;
1139         int local = 0, host_ip_differ = 0;
1140         int salen;
1141         char ntop[NI_MAXHOST];
1142
1143         /*
1144          * Force accepting of the host key for loopback/localhost. The
1145          * problem is that if the home directory is NFS-mounted to multiple
1146          * machines, localhost will refer to a different machine in each of
1147          * them, and the user will get bogus HOST_CHANGED warnings.  This
1148          * essentially disables host authentication for localhost; however,
1149          * this is probably not a real problem.
1150          */
1151         switch (hostaddr->sa_family) {
1152         case AF_INET:
1153                 local = (ntohl(((struct sockaddr_in *)hostaddr)->sin_addr.s_addr) >> 24) == IN_LOOPBACKNET;
1154                 salen = sizeof(struct sockaddr_in);
1155                 break;
1156         case AF_INET6:
1157                 local = IN6_IS_ADDR_LOOPBACK(&(((struct sockaddr_in6 *)hostaddr)->sin6_addr));
1158                 salen = sizeof(struct sockaddr_in6);
1159                 break;
1160         default:
1161                 local = 0;
1162                 salen = sizeof(struct sockaddr_storage);
1163                 break;
1164         }
1165         if (local) {
1166                 debug("Forcing accepting of host key for loopback/localhost.");
1167                 return;
1168         }
1169
1170         /*
1171          * Turn off check_host_ip for proxy connects, since
1172          * we don't have the remote ip-address
1173          */
1174         if (options.proxy_command != NULL && options.check_host_ip)
1175                 options.check_host_ip = 0;
1176
1177         if (options.check_host_ip) {
1178                 if (getnameinfo(hostaddr, salen, ntop, sizeof(ntop),
1179                     NULL, 0, NI_NUMERICHOST) != 0)
1180                         fatal("check_host_key: getnameinfo failed");
1181                 ip = xstrdup(ntop);
1182         }
1183
1184         /*
1185          * Store the host key from the known host file in here so that we can
1186          * compare it with the key for the IP address.
1187          */
1188         file_key = key_new(host_key->type);
1189
1190         /*
1191          * Check if the host key is present in the user\'s list of known
1192          * hosts or in the systemwide list.
1193          */
1194         host_status = check_host_in_hostfile(options.user_hostfile, host, host_key, file_key);
1195         if (host_status == HOST_NEW)
1196                 host_status = check_host_in_hostfile(options.system_hostfile, host, host_key, file_key);
1197         /*
1198          * Also perform check for the ip address, skip the check if we are
1199          * localhost or the hostname was an ip address to begin with
1200          */
1201         if (options.check_host_ip && !local && strcmp(host, ip)) {
1202                 Key *ip_key = key_new(host_key->type);
1203                 ip_status = check_host_in_hostfile(options.user_hostfile, ip, host_key, ip_key);
1204
1205                 if (ip_status == HOST_NEW)
1206                         ip_status = check_host_in_hostfile(options.system_hostfile, ip, host_key, ip_key);
1207                 if (host_status == HOST_CHANGED &&
1208                     (ip_status != HOST_CHANGED || !key_equal(ip_key, file_key)))
1209                         host_ip_differ = 1;
1210
1211                 key_free(ip_key);
1212         } else
1213                 ip_status = host_status;
1214
1215         key_free(file_key);
1216
1217         switch (host_status) {
1218         case HOST_OK:
1219                 /* The host is known and the key matches. */
1220                 debug("Host '%.200s' is known and matches the host key.", host);
1221                 if (options.check_host_ip) {
1222                         if (ip_status == HOST_NEW) {
1223                                 if (!add_host_to_hostfile(options.user_hostfile, ip, host_key))
1224                                         log("Failed to add the host key for IP address '%.30s' to the list of known hosts (%.30s).",
1225                                             ip, options.user_hostfile);
1226                                 else
1227                                         log("Warning: Permanently added host key for IP address '%.30s' to the list of known hosts.",
1228                                             ip);
1229                         } else if (ip_status != HOST_OK)
1230                                 log("Warning: the host key for '%.200s' differs from the key for the IP address '%.30s'",
1231                                     host, ip);
1232                 }
1233                 break;
1234         case HOST_NEW:
1235                 /* The host is new. */
1236                 if (options.strict_host_key_checking == 1) {
1237                         /* User has requested strict host key checking.  We will not add the host key
1238                            automatically.  The only alternative left is to abort. */
1239                         fatal("No host key is known for %.200s and you have requested strict checking.", host);
1240                 } else if (options.strict_host_key_checking == 2) {
1241                         /* The default */
1242                         char prompt[1024];
1243                         char *fp = key_fingerprint(host_key);
1244                         snprintf(prompt, sizeof(prompt),
1245                             "The authenticity of host '%.200s' can't be established.\n"
1246                             "Key fingerprint is %s.\n"
1247                             "Are you sure you want to continue connecting (yes/no)? ",
1248                             host, fp);
1249                         if (!read_yes_or_no(prompt, -1))
1250                                 fatal("Aborted by user!\n");
1251                 }
1252                 if (options.check_host_ip && ip_status == HOST_NEW && strcmp(host, ip)) {
1253                         snprintf(hostline, sizeof(hostline), "%s,%s", host, ip);
1254                         hostp = hostline;
1255                 } else
1256                         hostp = host;
1257
1258                 /* If not in strict mode, add the key automatically to the local known_hosts file. */
1259                 if (!add_host_to_hostfile(options.user_hostfile, hostp, host_key))
1260                         log("Failed to add the host to the list of known hosts (%.500s).",
1261                             options.user_hostfile);
1262                 else
1263                         log("Warning: Permanently added '%.200s' to the list of known hosts.",
1264                             hostp);
1265                 break;
1266         case HOST_CHANGED:
1267                 if (options.check_host_ip && host_ip_differ) {
1268                         char *msg;
1269                         if (ip_status == HOST_NEW)
1270                                 msg = "is unknown";
1271                         else if (ip_status == HOST_OK)
1272                                 msg = "is unchanged";
1273                         else
1274                                 msg = "has a different value";
1275                         error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
1276                         error("@       WARNING: POSSIBLE DNS SPOOFING DETECTED!          @");
1277                         error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
1278                         error("The host key for %s has changed,", host);
1279                         error("and the key for the according IP address %s", ip);
1280                         error("%s. This could either mean that", msg);
1281                         error("DNS SPOOFING is happening or the IP address for the host");
1282                         error("and its host key have changed at the same time");
1283                 }
1284                 /* The host key has changed. */
1285                 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
1286                 error("@    WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!     @");
1287                 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
1288                 error("IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!");
1289                 error("Someone could be eavesdropping on you right now (man-in-the-middle attack)!");
1290                 error("It is also possible that the host key has just been changed.");
1291                 error("Please contact your system administrator.");
1292                 error("Add correct host key in %.100s to get rid of this message.",
1293                       options.user_hostfile);
1294
1295                 /*
1296                  * If strict host key checking is in use, the user will have
1297                  * to edit the key manually and we can only abort.
1298                  */
1299                 if (options.strict_host_key_checking)
1300                         fatal("Host key for %.200s has changed and you have requested strict checking.", host);
1301
1302                 /*
1303                  * If strict host key checking has not been requested, allow
1304                  * the connection but without password authentication or
1305                  * agent forwarding.
1306                  */
1307                 if (options.password_authentication) {
1308                         error("Password authentication is disabled to avoid trojan horses.");
1309                         options.password_authentication = 0;
1310                 }
1311                 if (options.forward_agent) {
1312                         error("Agent forwarding is disabled to avoid trojan horses.");
1313                         options.forward_agent = 0;
1314                 }
1315                 /*
1316                  * XXX Should permit the user to change to use the new id.
1317                  * This could be done by converting the host key to an
1318                  * identifying sentence, tell that the host identifies itself
1319                  * by that sentence, and ask the user if he/she whishes to
1320                  * accept the authentication.
1321                  */
1322                 break;
1323         }
1324         if (options.check_host_ip)
1325                 xfree(ip);
1326 }
1327 void
1328 check_rsa_host_key(char *host, struct sockaddr *hostaddr, RSA *host_key)
1329 {
1330         Key k;
1331         k.type = KEY_RSA;
1332         k.rsa = host_key;
1333         check_host_key(host, hostaddr, &k);
1334 }
1335
1336 /*
1337  * SSH2 key exchange
1338  */
1339 void
1340 ssh_kex2(char *host, struct sockaddr *hostaddr)
1341 {
1342         Kex *kex;
1343         char *cprop[PROPOSAL_MAX];
1344         char *sprop[PROPOSAL_MAX];
1345         Buffer *client_kexinit;
1346         Buffer *server_kexinit;
1347         int payload_len, dlen;
1348         unsigned int klen, kout;
1349         char *ptr;
1350         char *signature = NULL;
1351         unsigned int slen;
1352         char *server_host_key_blob = NULL;
1353         Key *server_host_key;
1354         unsigned int sbloblen;
1355         DH *dh;
1356         BIGNUM *dh_server_pub = 0;
1357         BIGNUM *shared_secret = 0;
1358         int i;
1359         unsigned char *kbuf;
1360         unsigned char *hash;
1361
1362 /* KEXINIT */
1363
1364         debug("Sending KEX init.");
1365         if (options.ciphers != NULL) {
1366                 myproposal[PROPOSAL_ENC_ALGS_CTOS] =
1367                 myproposal[PROPOSAL_ENC_ALGS_STOC] = options.ciphers;
1368         } else if (
1369             options.cipher == SSH_CIPHER_ARCFOUR ||
1370             options.cipher == SSH_CIPHER_3DES_CBC ||
1371             options.cipher == SSH_CIPHER_CAST128_CBC ||
1372             options.cipher == SSH_CIPHER_BLOWFISH_CBC) {
1373                 myproposal[PROPOSAL_ENC_ALGS_CTOS] =
1374                 myproposal[PROPOSAL_ENC_ALGS_STOC] = cipher_name(options.cipher);
1375         }
1376         if (options.compression) {
1377                 myproposal[PROPOSAL_COMP_ALGS_CTOS] = "zlib";
1378                 myproposal[PROPOSAL_COMP_ALGS_STOC] = "zlib";
1379         } else {
1380                 myproposal[PROPOSAL_COMP_ALGS_CTOS] = "none";
1381                 myproposal[PROPOSAL_COMP_ALGS_STOC] = "none";
1382         }
1383         for (i = 0; i < PROPOSAL_MAX; i++)
1384                 cprop[i] = xstrdup(myproposal[i]);
1385
1386         client_kexinit = kex_init(cprop);
1387         packet_start(SSH2_MSG_KEXINIT);
1388         packet_put_raw(buffer_ptr(client_kexinit), buffer_len(client_kexinit));
1389         packet_send();
1390         packet_write_wait();
1391
1392         debug("done");
1393
1394         packet_read_expect(&payload_len, SSH2_MSG_KEXINIT);
1395
1396         /* save payload for session_id */
1397         server_kexinit = xmalloc(sizeof(*server_kexinit));
1398         buffer_init(server_kexinit);
1399         ptr = packet_get_raw(&payload_len);
1400         buffer_append(server_kexinit, ptr, payload_len);
1401
1402         /* skip cookie */
1403         for (i = 0; i < 16; i++)
1404                 (void) packet_get_char();
1405         /* kex init proposal strings */
1406         for (i = 0; i < PROPOSAL_MAX; i++) {
1407                 sprop[i] = packet_get_string(NULL);
1408                 debug("got kexinit string: %s", sprop[i]);
1409         }
1410         i = (int) packet_get_char();
1411         debug("first kex follow == %d", i);
1412         i = packet_get_int();
1413         debug("reserved == %d", i);
1414         packet_done();
1415
1416         debug("done read kexinit");
1417         kex = kex_choose_conf(cprop, sprop, 0);
1418
1419 /* KEXDH */
1420
1421         debug("Sending SSH2_MSG_KEXDH_INIT.");
1422
1423         /* generate and send 'e', client DH public key */
1424         dh = dh_new_group1();
1425         packet_start(SSH2_MSG_KEXDH_INIT);
1426         packet_put_bignum2(dh->pub_key);
1427         packet_send();
1428         packet_write_wait();
1429
1430 #ifdef DEBUG_KEXDH
1431         fprintf(stderr, "\np= ");
1432         bignum_print(dh->p);
1433         fprintf(stderr, "\ng= ");
1434         bignum_print(dh->g);
1435         fprintf(stderr, "\npub= ");
1436         bignum_print(dh->pub_key);
1437         fprintf(stderr, "\n");
1438         DHparams_print_fp(stderr, dh);
1439 #endif
1440
1441         debug("Wait SSH2_MSG_KEXDH_REPLY.");
1442
1443         packet_read_expect(&payload_len, SSH2_MSG_KEXDH_REPLY);
1444
1445         debug("Got SSH2_MSG_KEXDH_REPLY.");
1446
1447         /* key, cert */
1448         server_host_key_blob = packet_get_string(&sbloblen);
1449         server_host_key = dsa_serverkey_from_blob(server_host_key_blob, sbloblen);
1450         if (server_host_key == NULL)
1451                 fatal("cannot decode server_host_key_blob");
1452
1453         check_host_key(host, hostaddr, server_host_key);
1454
1455         /* DH paramter f, server public DH key */
1456         dh_server_pub = BN_new();
1457         if (dh_server_pub == NULL)
1458                 fatal("dh_server_pub == NULL");
1459         packet_get_bignum2(dh_server_pub, &dlen);
1460
1461 #ifdef DEBUG_KEXDH
1462         fprintf(stderr, "\ndh_server_pub= ");
1463         bignum_print(dh_server_pub);
1464         fprintf(stderr, "\n");
1465         debug("bits %d", BN_num_bits(dh_server_pub));
1466 #endif
1467
1468         /* signed H */
1469         signature = packet_get_string(&slen);
1470         packet_done();
1471
1472         if (!dh_pub_is_valid(dh, dh_server_pub))
1473                 packet_disconnect("bad server public DH value");
1474
1475         klen = DH_size(dh);
1476         kbuf = xmalloc(klen);
1477         kout = DH_compute_key(kbuf, dh_server_pub, dh);
1478 #ifdef DEBUG_KEXDH
1479         debug("shared secret: len %d/%d", klen, kout);
1480         fprintf(stderr, "shared secret == ");
1481         for (i = 0; i< kout; i++)
1482                 fprintf(stderr, "%02x", (kbuf[i])&0xff);
1483         fprintf(stderr, "\n");
1484 #endif
1485         shared_secret = BN_new();
1486
1487         BN_bin2bn(kbuf, kout, shared_secret);
1488         memset(kbuf, 0, klen);
1489         xfree(kbuf);
1490
1491         /* calc and verify H */
1492         hash = kex_hash(
1493             client_version_string,
1494             server_version_string,
1495             buffer_ptr(client_kexinit), buffer_len(client_kexinit),
1496             buffer_ptr(server_kexinit), buffer_len(server_kexinit),
1497             server_host_key_blob, sbloblen,
1498             dh->pub_key,
1499             dh_server_pub,
1500             shared_secret
1501         );
1502         buffer_free(client_kexinit);
1503         buffer_free(server_kexinit);
1504         xfree(client_kexinit);
1505         xfree(server_kexinit);
1506 #ifdef DEBUG_KEXDH
1507         fprintf(stderr, "hash == ");
1508         for (i = 0; i< 20; i++)
1509                 fprintf(stderr, "%02x", (hash[i])&0xff);
1510         fprintf(stderr, "\n");
1511 #endif
1512         dsa_verify(server_host_key, (unsigned char *)signature, slen, hash, 20);
1513         key_free(server_host_key);
1514
1515         kex_derive_keys(kex, hash, shared_secret);
1516         packet_set_kex(kex);
1517
1518         /* have keys, free DH */
1519         DH_free(dh);
1520
1521         debug("Wait SSH2_MSG_NEWKEYS.");
1522         packet_read_expect(&payload_len, SSH2_MSG_NEWKEYS);
1523         packet_done();
1524         debug("GOT SSH2_MSG_NEWKEYS.");
1525
1526         debug("send SSH2_MSG_NEWKEYS.");
1527         packet_start(SSH2_MSG_NEWKEYS);
1528         packet_send();
1529         packet_write_wait();
1530         debug("done: send SSH2_MSG_NEWKEYS.");
1531
1532 #ifdef DEBUG_KEXDH
1533         /* send 1st encrypted/maced/compressed message */
1534         packet_start(SSH2_MSG_IGNORE);
1535         packet_put_cstring("markus");
1536         packet_send();
1537         packet_write_wait();
1538 #endif
1539         debug("done: KEX2.");
1540 }
1541 /*
1542  * Authenticate user
1543  */
1544 void
1545 ssh_userauth2(int host_key_valid, RSA *own_host_key,
1546     uid_t original_real_uid, char *host)
1547 {
1548         int type;
1549         int plen;
1550         unsigned int dlen;
1551         int partial;
1552         struct passwd *pw;
1553         char prompt[80];
1554         char *server_user, *local_user;
1555         char *auths;
1556         char *password;
1557         char *service = "ssh-connection";               /* service name */
1558
1559         debug("send SSH2_MSG_SERVICE_REQUEST");
1560         packet_start(SSH2_MSG_SERVICE_REQUEST);
1561         packet_put_cstring("ssh-userauth");
1562         packet_send();
1563         packet_write_wait();
1564
1565         type = packet_read(&plen);
1566         if (type != SSH2_MSG_SERVICE_ACCEPT) {
1567                 fatal("denied SSH2_MSG_SERVICE_ACCEPT: %d", type);
1568         }
1569         if (packet_remaining() > 0) {
1570                 char *reply = packet_get_string(&plen);
1571                 debug("service_accept: %s", reply);
1572                 xfree(reply);
1573         } else {
1574                 /* payload empty for ssh-2.0.13 ?? */
1575                 log("buggy server: service_accept w/o service");
1576         }
1577         packet_done();
1578         debug("got SSH2_MSG_SERVICE_ACCEPT");
1579
1580         /*XX COMMONCODE: */
1581         /* Get local user name.  Use it as server user if no user name was given. */
1582         pw = getpwuid(original_real_uid);
1583         if (!pw)
1584                 fatal("User id %d not found from user database.", original_real_uid);
1585         local_user = xstrdup(pw->pw_name);
1586         server_user = options.user ? options.user : local_user;
1587
1588         /* INITIAL request for auth */
1589         packet_start(SSH2_MSG_USERAUTH_REQUEST);
1590         packet_put_cstring(server_user);
1591         packet_put_cstring(service);
1592         packet_put_cstring("none");
1593         packet_send();
1594         packet_write_wait();
1595
1596         for (;;) {
1597                 type = packet_read(&plen);
1598                 if (type == SSH2_MSG_USERAUTH_SUCCESS)
1599                         break;
1600                 if (type != SSH2_MSG_USERAUTH_FAILURE)
1601                         fatal("access denied: %d", type);
1602                 /* SSH2_MSG_USERAUTH_FAILURE means: try again */
1603                 auths = packet_get_string(&dlen);
1604                 debug("authentications that can continue: %s", auths);
1605                 partial = packet_get_char();
1606                 packet_done();
1607                 if (partial)
1608                         debug("partial success");
1609                 if (strstr(auths, "password") == NULL)
1610                         fatal("passwd auth not supported: %s", auths);
1611                 xfree(auths);
1612                 /* try passwd */
1613                 snprintf(prompt, sizeof(prompt), "%.30s@%.40s's password: ",
1614                     server_user, host);
1615                 password = read_passphrase(prompt, 0);
1616                 packet_start(SSH2_MSG_USERAUTH_REQUEST);
1617                 packet_put_cstring(server_user);
1618                 packet_put_cstring(service);
1619                 packet_put_cstring("password");
1620                 packet_put_char(0);
1621                 packet_put_cstring(password);
1622                 memset(password, 0, strlen(password));
1623                 xfree(password);
1624                 packet_send();
1625                 packet_write_wait();
1626         }
1627         packet_done();
1628         debug("ssh-userauth2 successfull");
1629 }
1630
1631 /*
1632  * SSH1 key exchange
1633  */
1634 void
1635 ssh_kex(char *host, struct sockaddr *hostaddr)
1636 {
1637         int i;
1638         BIGNUM *key;
1639         RSA *host_key;
1640         RSA *public_key;
1641         int bits, rbits;
1642         int ssh_cipher_default = SSH_CIPHER_3DES;
1643         unsigned char session_key[SSH_SESSION_KEY_LENGTH];
1644         unsigned char cookie[8];
1645         unsigned int supported_ciphers;
1646         unsigned int server_flags, client_flags;
1647         int payload_len, clen, sum_len = 0;
1648         u_int32_t rand = 0;
1649
1650         debug("Waiting for server public key.");
1651
1652         /* Wait for a public key packet from the server. */
1653         packet_read_expect(&payload_len, SSH_SMSG_PUBLIC_KEY);
1654
1655         /* Get cookie from the packet. */
1656         for (i = 0; i < 8; i++)
1657                 cookie[i] = packet_get_char();
1658
1659         /* Get the public key. */
1660         public_key = RSA_new();
1661         bits = packet_get_int();/* bits */
1662         public_key->e = BN_new();
1663         packet_get_bignum(public_key->e, &clen);
1664         sum_len += clen;
1665         public_key->n = BN_new();
1666         packet_get_bignum(public_key->n, &clen);
1667         sum_len += clen;
1668
1669         rbits = BN_num_bits(public_key->n);
1670         if (bits != rbits) {
1671                 log("Warning: Server lies about size of server public key: "
1672                     "actual size is %d bits vs. announced %d.", rbits, bits);
1673                 log("Warning: This may be due to an old implementation of ssh.");
1674         }
1675         /* Get the host key. */
1676         host_key = RSA_new();
1677         bits = packet_get_int();/* bits */
1678         host_key->e = BN_new();
1679         packet_get_bignum(host_key->e, &clen);
1680         sum_len += clen;
1681         host_key->n = BN_new();
1682         packet_get_bignum(host_key->n, &clen);
1683         sum_len += clen;
1684
1685         rbits = BN_num_bits(host_key->n);
1686         if (bits != rbits) {
1687                 log("Warning: Server lies about size of server host key: "
1688                     "actual size is %d bits vs. announced %d.", rbits, bits);
1689                 log("Warning: This may be due to an old implementation of ssh.");
1690         }
1691
1692         /* Get protocol flags. */
1693         server_flags = packet_get_int();
1694         packet_set_protocol_flags(server_flags);
1695
1696         supported_ciphers = packet_get_int();
1697         supported_authentications = packet_get_int();
1698
1699         debug("Received server public key (%d bits) and host key (%d bits).",
1700               BN_num_bits(public_key->n), BN_num_bits(host_key->n));
1701
1702         packet_integrity_check(payload_len,
1703                                8 + 4 + sum_len + 0 + 4 + 0 + 0 + 4 + 4 + 4,
1704                                SSH_SMSG_PUBLIC_KEY);
1705
1706         check_rsa_host_key(host, hostaddr, host_key);
1707
1708         client_flags = SSH_PROTOFLAG_SCREEN_NUMBER | SSH_PROTOFLAG_HOST_IN_FWD_OPEN;
1709
1710         compute_session_id(session_id, cookie, host_key->n, public_key->n);
1711
1712         /* Generate a session key. */
1713         arc4random_stir();
1714
1715         /*
1716          * Generate an encryption key for the session.   The key is a 256 bit
1717          * random number, interpreted as a 32-byte key, with the least
1718          * significant 8 bits being the first byte of the key.
1719          */
1720         for (i = 0; i < 32; i++) {
1721                 if (i % 4 == 0)
1722                         rand = arc4random();
1723                 session_key[i] = rand & 0xff;
1724                 rand >>= 8;
1725         }
1726
1727         /*
1728          * According to the protocol spec, the first byte of the session key
1729          * is the highest byte of the integer.  The session key is xored with
1730          * the first 16 bytes of the session id.
1731          */
1732         key = BN_new();
1733         BN_set_word(key, 0);
1734         for (i = 0; i < SSH_SESSION_KEY_LENGTH; i++) {
1735                 BN_lshift(key, key, 8);
1736                 if (i < 16)
1737                         BN_add_word(key, session_key[i] ^ session_id[i]);
1738                 else
1739                         BN_add_word(key, session_key[i]);
1740         }
1741
1742         /*
1743          * Encrypt the integer using the public key and host key of the
1744          * server (key with smaller modulus first).
1745          */
1746         if (BN_cmp(public_key->n, host_key->n) < 0) {
1747                 /* Public key has smaller modulus. */
1748                 if (BN_num_bits(host_key->n) <
1749                     BN_num_bits(public_key->n) + SSH_KEY_BITS_RESERVED) {
1750                         fatal("respond_to_rsa_challenge: host_key %d < public_key %d + "
1751                               "SSH_KEY_BITS_RESERVED %d",
1752                               BN_num_bits(host_key->n),
1753                               BN_num_bits(public_key->n),
1754                               SSH_KEY_BITS_RESERVED);
1755                 }
1756                 rsa_public_encrypt(key, key, public_key);
1757                 rsa_public_encrypt(key, key, host_key);
1758         } else {
1759                 /* Host key has smaller modulus (or they are equal). */
1760                 if (BN_num_bits(public_key->n) <
1761                     BN_num_bits(host_key->n) + SSH_KEY_BITS_RESERVED) {
1762                         fatal("respond_to_rsa_challenge: public_key %d < host_key %d + "
1763                               "SSH_KEY_BITS_RESERVED %d",
1764                               BN_num_bits(public_key->n),
1765                               BN_num_bits(host_key->n),
1766                               SSH_KEY_BITS_RESERVED);
1767                 }
1768                 rsa_public_encrypt(key, key, host_key);
1769                 rsa_public_encrypt(key, key, public_key);
1770         }
1771
1772         /* Destroy the public keys since we no longer need them. */
1773         RSA_free(public_key);
1774         RSA_free(host_key);
1775
1776         if (options.cipher == SSH_CIPHER_NOT_SET) {
1777                 if (cipher_mask1() & supported_ciphers & (1 << ssh_cipher_default))
1778                         options.cipher = ssh_cipher_default;
1779                 else {
1780                         debug("Cipher %s not supported, using %.100s instead.",
1781                               cipher_name(ssh_cipher_default),
1782                               cipher_name(SSH_FALLBACK_CIPHER));
1783                         options.cipher = SSH_FALLBACK_CIPHER;
1784                 }
1785         }
1786         /* Check that the selected cipher is supported. */
1787         if (!(supported_ciphers & (1 << options.cipher)))
1788                 fatal("Selected cipher type %.100s not supported by server.",
1789                       cipher_name(options.cipher));
1790
1791         debug("Encryption type: %.100s", cipher_name(options.cipher));
1792
1793         /* Send the encrypted session key to the server. */
1794         packet_start(SSH_CMSG_SESSION_KEY);
1795         packet_put_char(options.cipher);
1796
1797         /* Send the cookie back to the server. */
1798         for (i = 0; i < 8; i++)
1799                 packet_put_char(cookie[i]);
1800
1801         /* Send and destroy the encrypted encryption key integer. */
1802         packet_put_bignum(key);
1803         BN_clear_free(key);
1804
1805         /* Send protocol flags. */
1806         packet_put_int(client_flags);
1807
1808         /* Send the packet now. */
1809         packet_send();
1810         packet_write_wait();
1811
1812         debug("Sent encrypted session key.");
1813
1814         /* Set the encryption key. */
1815         packet_set_encryption_key(session_key, SSH_SESSION_KEY_LENGTH, options.cipher);
1816
1817         /* We will no longer need the session key here.  Destroy any extra copies. */
1818         memset(session_key, 0, sizeof(session_key));
1819
1820         /*
1821          * Expect a success message from the server.  Note that this message
1822          * will be received in encrypted form.
1823          */
1824         packet_read_expect(&payload_len, SSH_SMSG_SUCCESS);
1825
1826         debug("Received encrypted confirmation.");
1827 }
1828
1829 /*
1830  * Authenticate user
1831  */
1832 void
1833 ssh_userauth(int host_key_valid, RSA *own_host_key,
1834     uid_t original_real_uid, char *host)
1835 {
1836         int i, type;
1837         int payload_len;
1838         struct passwd *pw;
1839         const char *server_user, *local_user;
1840
1841         /* Get local user name.  Use it as server user if no user name was given. */
1842         pw = getpwuid(original_real_uid);
1843         if (!pw)
1844                 fatal("User id %d not found from user database.", original_real_uid);
1845         local_user = xstrdup(pw->pw_name);
1846         server_user = options.user ? options.user : local_user;
1847
1848         /* Send the name of the user to log in as on the server. */
1849         packet_start(SSH_CMSG_USER);
1850         packet_put_string(server_user, strlen(server_user));
1851         packet_send();
1852         packet_write_wait();
1853
1854         /*
1855          * The server should respond with success if no authentication is
1856          * needed (the user has no password).  Otherwise the server responds
1857          * with failure.
1858          */
1859         type = packet_read(&payload_len);
1860
1861         /* check whether the connection was accepted without authentication. */
1862         if (type == SSH_SMSG_SUCCESS)
1863                 return;
1864         if (type != SSH_SMSG_FAILURE)
1865                 packet_disconnect("Protocol error: got %d in response to SSH_CMSG_USER",
1866                                   type);
1867
1868 #ifdef AFS
1869         /* Try Kerberos tgt passing if the server supports it. */
1870         if ((supported_authentications & (1 << SSH_PASS_KERBEROS_TGT)) &&
1871             options.kerberos_tgt_passing) {
1872                 if (options.cipher == SSH_CIPHER_NONE)
1873                         log("WARNING: Encryption is disabled! Ticket will be transmitted in the clear!");
1874                 (void) send_kerberos_tgt();
1875         }
1876         /* Try AFS token passing if the server supports it. */
1877         if ((supported_authentications & (1 << SSH_PASS_AFS_TOKEN)) &&
1878             options.afs_token_passing && k_hasafs()) {
1879                 if (options.cipher == SSH_CIPHER_NONE)
1880                         log("WARNING: Encryption is disabled! Token will be transmitted in the clear!");
1881                 send_afs_tokens();
1882         }
1883 #endif /* AFS */
1884
1885 #ifdef KRB4
1886         if ((supported_authentications & (1 << SSH_AUTH_KERBEROS)) &&
1887             options.kerberos_authentication) {
1888                 debug("Trying Kerberos authentication.");
1889                 if (try_kerberos_authentication()) {
1890                         /* The server should respond with success or failure. */
1891                         type = packet_read(&payload_len);
1892                         if (type == SSH_SMSG_SUCCESS)
1893                                 return;
1894                         if (type != SSH_SMSG_FAILURE)
1895                                 packet_disconnect("Protocol error: got %d in response to Kerberos auth", type);
1896                 }
1897         }
1898 #endif /* KRB4 */
1899
1900         /*
1901          * Use rhosts authentication if running in privileged socket and we
1902          * do not wish to remain anonymous.
1903          */
1904         if ((supported_authentications & (1 << SSH_AUTH_RHOSTS)) &&
1905             options.rhosts_authentication) {
1906                 debug("Trying rhosts authentication.");
1907                 packet_start(SSH_CMSG_AUTH_RHOSTS);
1908                 packet_put_string(local_user, strlen(local_user));
1909                 packet_send();
1910                 packet_write_wait();
1911
1912                 /* The server should respond with success or failure. */
1913                 type = packet_read(&payload_len);
1914                 if (type == SSH_SMSG_SUCCESS)
1915                         return;
1916                 if (type != SSH_SMSG_FAILURE)
1917                         packet_disconnect("Protocol error: got %d in response to rhosts auth",
1918                                           type);
1919         }
1920         /*
1921          * Try .rhosts or /etc/hosts.equiv authentication with RSA host
1922          * authentication.
1923          */
1924         if ((supported_authentications & (1 << SSH_AUTH_RHOSTS_RSA)) &&
1925             options.rhosts_rsa_authentication && host_key_valid) {
1926                 if (try_rhosts_rsa_authentication(local_user, own_host_key))
1927                         return;
1928         }
1929         /* Try RSA authentication if the server supports it. */
1930         if ((supported_authentications & (1 << SSH_AUTH_RSA)) &&
1931             options.rsa_authentication) {
1932                 /*
1933                  * Try RSA authentication using the authentication agent. The
1934                  * agent is tried first because no passphrase is needed for
1935                  * it, whereas identity files may require passphrases.
1936                  */
1937                 if (try_agent_authentication())
1938                         return;
1939
1940                 /* Try RSA authentication for each identity. */
1941                 for (i = 0; i < options.num_identity_files; i++)
1942                         if (try_rsa_authentication(options.identity_files[i]))
1943                                 return;
1944         }
1945         /* Try skey authentication if the server supports it. */
1946         if ((supported_authentications & (1 << SSH_AUTH_TIS)) &&
1947             options.skey_authentication && !options.batch_mode) {
1948                 if (try_skey_authentication())
1949                         return;
1950         }
1951         /* Try password authentication if the server supports it. */
1952         if ((supported_authentications & (1 << SSH_AUTH_PASSWORD)) &&
1953             options.password_authentication && !options.batch_mode) {
1954                 char prompt[80];
1955
1956                 snprintf(prompt, sizeof(prompt), "%.30s@%.40s's password: ",
1957                     server_user, host);
1958                 if (try_password_authentication(prompt))
1959                         return;
1960         }
1961         /* All authentication methods have failed.  Exit with an error message. */
1962         fatal("Permission denied.");
1963         /* NOTREACHED */
1964 }
1965 /*
1966  * Starts a dialog with the server, and authenticates the current user on the
1967  * server.  This does not need any extra privileges.  The basic connection
1968  * to the server must already have been established before this is called.
1969  * If login fails, this function prints an error and never returns.
1970  * This function does not require super-user privileges.
1971  */
1972 void
1973 ssh_login(int host_key_valid, RSA *own_host_key, const char *orighost,
1974     struct sockaddr *hostaddr, uid_t original_real_uid)
1975 {
1976         char *host, *cp;
1977
1978         /* Convert the user-supplied hostname into all lowercase. */
1979         host = xstrdup(orighost);
1980         for (cp = host; *cp; cp++)
1981                 if (isupper(*cp))
1982                         *cp = tolower(*cp);
1983
1984         /* Exchange protocol version identification strings with the server. */
1985         ssh_exchange_identification();
1986
1987         /* Put the connection into non-blocking mode. */
1988         packet_set_nonblocking();
1989
1990         /* key exchange */
1991         /* authenticate user */
1992         if (compat20) {
1993                 ssh_kex2(host, hostaddr);
1994                 ssh_userauth2(host_key_valid, own_host_key, original_real_uid, host);
1995         } else {
1996                 supported_authentications = 0;
1997                 ssh_kex(host, hostaddr);
1998                 if (supported_authentications == 0)
1999                         fatal("supported_authentications == 0.");
2000                 ssh_userauth(host_key_valid, own_host_key, original_real_uid, host);
2001         }
2002 }