[BACK]Return to sshconnect1.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/Attic/sshconnect1.c between version 1.41.2.4 and 1.42

version 1.41.2.4, 2002/10/11 14:53:07 version 1.42, 2001/12/19 07:18:56
Line 16 
Line 16 
 RCSID("$OpenBSD$");  RCSID("$OpenBSD$");
   
 #include <openssl/bn.h>  #include <openssl/bn.h>
 #include <openssl/md5.h>  #include <openssl/evp.h>
   
 #ifdef KRB4  #ifdef KRB4
 #include <krb.h>  #include <krb.h>
Line 67 
Line 67 
         AuthenticationConnection *auth;          AuthenticationConnection *auth;
         u_char response[16];          u_char response[16];
         u_int i;          u_int i;
           int plen, clen;
         Key *key;          Key *key;
         BIGNUM *challenge;          BIGNUM *challenge;
   
Line 75 
Line 76 
         if (!auth)          if (!auth)
                 return 0;                  return 0;
   
         if ((challenge = BN_new()) == NULL)          challenge = BN_new();
                 fatal("try_agent_authentication: BN_new failed");  
         /* Loop through identities served by the agent. */          /* Loop through identities served by the agent. */
         for (key = ssh_get_first_identity(auth, &comment, 1);          for (key = ssh_get_first_identity(auth, &comment, 1);
             key != NULL;              key != NULL;
Line 93 
Line 94 
                 packet_write_wait();                  packet_write_wait();
   
                 /* Wait for server's response. */                  /* Wait for server's response. */
                 type = packet_read();                  type = packet_read(&plen);
   
                 /* The server sends failure if it doesn\'t like our key or                  /* The server sends failure if it doesn\'t like our key or
                    does not support RSA authentication. */                     does not support RSA authentication. */
Line 107 
Line 108 
                         packet_disconnect("Protocol error during RSA authentication: %d",                          packet_disconnect("Protocol error during RSA authentication: %d",
                                           type);                                            type);
   
                 packet_get_bignum(challenge);                  packet_get_bignum(challenge, &clen);
                 packet_check_eom();  
   
                   packet_integrity_check(plen, clen, type);
   
                 debug("Received RSA challenge from server.");                  debug("Received RSA challenge from server.");
   
                 /* Ask the agent to decrypt the challenge. */                  /* Ask the agent to decrypt the challenge. */
Line 133 
Line 135 
                 packet_write_wait();                  packet_write_wait();
   
                 /* Wait for response from the server. */                  /* Wait for response from the server. */
                 type = packet_read();                  type = packet_read(&plen);
   
                 /* The server returns success if it accepted the authentication. */                  /* The server returns success if it accepted the authentication. */
                 if (type == SSH_SMSG_SUCCESS) {                  if (type == SSH_SMSG_SUCCESS) {
Line 208 
Line 210 
         BIGNUM *challenge;          BIGNUM *challenge;
         Key *public, *private;          Key *public, *private;
         char buf[300], *passphrase, *comment, *authfile;          char buf[300], *passphrase, *comment, *authfile;
         int i, type, quit;          int i, type, quit, plen, clen;
   
         public = options.identity_keys[idx];          public = options.identity_keys[idx];
         authfile = options.identity_files[idx];          authfile = options.identity_files[idx];
Line 223 
Line 225 
         packet_write_wait();          packet_write_wait();
   
         /* Wait for server's response. */          /* Wait for server's response. */
         type = packet_read();          type = packet_read(&plen);
   
         /*          /*
          * The server responds with failure if it doesn\'t like our key or           * The server responds with failure if it doesn\'t like our key or
Line 239 
Line 241 
                 packet_disconnect("Protocol error during RSA authentication: %d", type);                  packet_disconnect("Protocol error during RSA authentication: %d", type);
   
         /* Get the challenge from the packet. */          /* Get the challenge from the packet. */
         if ((challenge = BN_new()) == NULL)          challenge = BN_new();
                 fatal("try_rsa_authentication: BN_new failed");          packet_get_bignum(challenge, &clen);
         packet_get_bignum(challenge);  
         packet_check_eom();  
   
           packet_integrity_check(plen, clen, type);
   
         debug("Received RSA challenge from server.");          debug("Received RSA challenge from server.");
   
         /*          /*
Line 251 
Line 253 
          * load the private key.  Try first with empty passphrase; if it           * load the private key.  Try first with empty passphrase; if it
          * fails, ask for a passphrase.           * fails, ask for a passphrase.
          */           */
         if (public->flags & KEY_FLAG_EXT)          if (public->flags && KEY_FLAG_EXT)
                 private = public;                  private = public;
         else          else
                 private = key_load_private_type(KEY_RSA1, authfile, "", NULL);                  private = key_load_private_type(KEY_RSA1, authfile, "", NULL);
Line 290 
Line 292 
                 packet_write_wait();                  packet_write_wait();
   
                 /* Expect the server to reject it... */                  /* Expect the server to reject it... */
                 packet_read_expect(SSH_SMSG_FAILURE);                  packet_read_expect(&plen, SSH_SMSG_FAILURE);
                 BN_clear_free(challenge);                  BN_clear_free(challenge);
                 return 0;                  return 0;
         }          }
Line 306 
Line 308 
         BN_clear_free(challenge);          BN_clear_free(challenge);
   
         /* Wait for response from the server. */          /* Wait for response from the server. */
         type = packet_read();          type = packet_read(&plen);
         if (type == SSH_SMSG_SUCCESS) {          if (type == SSH_SMSG_SUCCESS) {
                 debug("RSA authentication accepted by server.");                  debug("RSA authentication accepted by server.");
                 return 1;                  return 1;
Line 326 
Line 328 
 {  {
         int type;          int type;
         BIGNUM *challenge;          BIGNUM *challenge;
           int plen, clen;
   
         debug("Trying rhosts or /etc/hosts.equiv with RSA host authentication.");          debug("Trying rhosts or /etc/hosts.equiv with RSA host authentication.");
   
Line 339 
Line 342 
         packet_write_wait();          packet_write_wait();
   
         /* Wait for server's response. */          /* Wait for server's response. */
         type = packet_read();          type = packet_read(&plen);
   
         /* The server responds with failure if it doesn't admit our          /* The server responds with failure if it doesn't admit our
            .rhosts authentication or doesn't know our host key. */             .rhosts authentication or doesn't know our host key. */
Line 352 
Line 355 
                 packet_disconnect("Protocol error during RSA authentication: %d", type);                  packet_disconnect("Protocol error during RSA authentication: %d", type);
   
         /* Get the challenge from the packet. */          /* Get the challenge from the packet. */
         if ((challenge = BN_new()) == NULL)          challenge = BN_new();
                 fatal("try_rhosts_rsa_authentication: BN_new failed");          packet_get_bignum(challenge, &clen);
         packet_get_bignum(challenge);  
         packet_check_eom();  
   
           packet_integrity_check(plen, clen, type);
   
         debug("Received RSA challenge for host key from server.");          debug("Received RSA challenge for host key from server.");
   
         /* Compute a response to the challenge. */          /* Compute a response to the challenge. */
Line 366 
Line 369 
         BN_clear_free(challenge);          BN_clear_free(challenge);
   
         /* Wait for response from the server. */          /* Wait for response from the server. */
         type = packet_read();          type = packet_read(&plen);
         if (type == SSH_SMSG_SUCCESS) {          if (type == SSH_SMSG_SUCCESS) {
                 debug("Rhosts or /etc/hosts.equiv with RSA host authentication accepted by server.");                  debug("Rhosts or /etc/hosts.equiv with RSA host authentication accepted by server.");
                 return 1;                  return 1;
Line 386 
Line 389 
         char inst[INST_SZ];          char inst[INST_SZ];
         char *realm;          char *realm;
         CREDENTIALS cred;          CREDENTIALS cred;
         int r, type;          int r, type, plen;
         socklen_t slen;          socklen_t slen;
         Key_schedule schedule;          Key_schedule schedule;
         u_long checksum, cksum;          u_long checksum, cksum;
Line 445 
Line 448 
                 fatal_cleanup();                  fatal_cleanup();
         }          }
         /* Get server reply. */          /* Get server reply. */
         type = packet_read();          type = packet_read(&plen);
         switch (type) {          switch (type) {
         case SSH_SMSG_FAILURE:          case SSH_SMSG_FAILURE:
                 /* Should really be SSH_SMSG_AUTH_KERBEROS_FAILURE */                  /* Should really be SSH_SMSG_AUTH_KERBEROS_FAILURE */
Line 459 
Line 462 
   
                 /* Get server's response. */                  /* Get server's response. */
                 reply = packet_get_string((u_int *) &auth.length);                  reply = packet_get_string((u_int *) &auth.length);
                 if (auth.length >= MAX_KTXT_LEN)  
                         fatal("Kerberos v4: Malformed response from server");  
                 memcpy(auth.dat, reply, auth.length);                  memcpy(auth.dat, reply, auth.length);
                 xfree(reply);                  xfree(reply);
   
                 packet_check_eom();                  packet_integrity_check(plen, 4 + auth.length, type);
   
                 /*                  /*
                  * If his response isn't properly encrypted with the session                   * If his response isn't properly encrypted with the session
Line 509 
Line 510 
         krb5_ccache ccache = NULL;          krb5_ccache ccache = NULL;
         const char *remotehost;          const char *remotehost;
         krb5_data ap;          krb5_data ap;
         int type;          int type, payload_len;
         krb5_ap_rep_enc_part *reply = NULL;          krb5_ap_rep_enc_part *reply = NULL;
         int ret;          int ret;
   
Line 559 
Line 560 
         xfree(ap.data);          xfree(ap.data);
         ap.length = 0;          ap.length = 0;
   
         type = packet_read();          type = packet_read(&payload_len);
         switch (type) {          switch (type) {
         case SSH_SMSG_FAILURE:          case SSH_SMSG_FAILURE:
                 /* Should really be SSH_SMSG_AUTH_KERBEROS_FAILURE */                  /* Should really be SSH_SMSG_AUTH_KERBEROS_FAILURE */
Line 573 
Line 574 
   
                 /* Get server's response. */                  /* Get server's response. */
                 ap.data = packet_get_string((unsigned int *) &ap.length);                  ap.data = packet_get_string((unsigned int *) &ap.length);
                 packet_check_eom();  
                   packet_integrity_check(payload_len, 4 + ap.length, type);
                 /* XXX je to dobre? */                  /* XXX je to dobre? */
   
                 problem = krb5_rd_rep(*context, *auth_context, &ap, &reply);                  problem = krb5_rd_rep(*context, *auth_context, &ap, &reply);
Line 605 
Line 607 
 static void  static void
 send_krb5_tgt(krb5_context context, krb5_auth_context auth_context)  send_krb5_tgt(krb5_context context, krb5_auth_context auth_context)
 {  {
         int fd, type;          int fd, type, payload_len;
         krb5_error_code problem;          krb5_error_code problem;
         krb5_data outbuf;          krb5_data outbuf;
         krb5_ccache ccache = NULL;          krb5_ccache ccache = NULL;
Line 655 
Line 657 
         packet_send();          packet_send();
         packet_write_wait();          packet_write_wait();
   
         type = packet_read();          type = packet_read(&payload_len);
   
         if (type == SSH_SMSG_SUCCESS) {          if (type == SSH_SMSG_SUCCESS) {
                 char *pname;                  char *pname;
Line 690 
Line 692 
         CREDENTIALS *creds;          CREDENTIALS *creds;
         struct stat st;          struct stat st;
         char buffer[4096], pname[ANAME_SZ], pinst[INST_SZ], prealm[REALM_SZ];          char buffer[4096], pname[ANAME_SZ], pinst[INST_SZ], prealm[REALM_SZ];
         int problem, type;          int problem, type, len;
   
         /* Don't do anything if we don't have any tickets. */          /* Don't do anything if we don't have any tickets. */
         if (stat(tkt_string(), &st) < 0)          if (stat(tkt_string(), &st) < 0)
Line 717 
Line 719 
         packet_send();          packet_send();
         packet_write_wait();          packet_write_wait();
   
         type = packet_read();          type = packet_read(&len);
   
         if (type == SSH_SMSG_SUCCESS)          if (type == SSH_SMSG_SUCCESS)
                 debug("Kerberos v4 TGT forwarded (%s%s%s@%s).",                  debug("Kerberos v4 TGT forwarded (%s%s%s@%s).",
Line 795 
Line 797 
   
                 /* Roger, Roger. Clearance, Clarence. What's your vector,                  /* Roger, Roger. Clearance, Clarence. What's your vector,
                    Victor? */                     Victor? */
                 type = packet_read();                  type = packet_read(&len);
   
                 if (type == SSH_SMSG_FAILURE)                  if (type == SSH_SMSG_FAILURE)
                         debug("AFS token for cell %s rejected.", server_cell);                          debug("AFS token for cell %s rejected.", server_cell);
Line 814 
Line 816 
 try_challenge_response_authentication(void)  try_challenge_response_authentication(void)
 {  {
         int type, i;          int type, i;
           int payload_len;
         u_int clen;          u_int clen;
         char prompt[1024];          char prompt[1024];
         char *challenge, *response;          char *challenge, *response;
Line 826 
Line 829 
                 packet_send();                  packet_send();
                 packet_write_wait();                  packet_write_wait();
   
                 type = packet_read();                  type = packet_read(&payload_len);
                 if (type != SSH_SMSG_FAILURE &&                  if (type != SSH_SMSG_FAILURE &&
                     type != SSH_SMSG_AUTH_TIS_CHALLENGE) {                      type != SSH_SMSG_AUTH_TIS_CHALLENGE) {
                         packet_disconnect("Protocol error: got %d in response "                          packet_disconnect("Protocol error: got %d in response "
Line 837 
Line 840 
                         return 0;                          return 0;
                 }                  }
                 challenge = packet_get_string(&clen);                  challenge = packet_get_string(&clen);
                 packet_check_eom();                  packet_integrity_check(payload_len, (4 + clen), type);
                 snprintf(prompt, sizeof prompt, "%s%s", challenge,                  snprintf(prompt, sizeof prompt, "%s%s", challenge,
                     strchr(challenge, '\n') ? "" : "\nResponse: ");                      strchr(challenge, '\n') ? "" : "\nResponse: ");
                 xfree(challenge);                  xfree(challenge);
Line 845 
Line 848 
                         error("Permission denied, please try again.");                          error("Permission denied, please try again.");
                 if (options.cipher == SSH_CIPHER_NONE)                  if (options.cipher == SSH_CIPHER_NONE)
                         log("WARNING: Encryption is disabled! "                          log("WARNING: Encryption is disabled! "
                             "Response will be transmitted in clear text.");                              "Reponse will be transmitted in clear text.");
                 response = read_passphrase(prompt, 0);                  response = read_passphrase(prompt, 0);
                 if (strcmp(response, "") == 0) {                  if (strcmp(response, "") == 0) {
                         xfree(response);                          xfree(response);
Line 857 
Line 860 
                 xfree(response);                  xfree(response);
                 packet_send();                  packet_send();
                 packet_write_wait();                  packet_write_wait();
                 type = packet_read();                  type = packet_read(&payload_len);
                 if (type == SSH_SMSG_SUCCESS)                  if (type == SSH_SMSG_SUCCESS)
                         return 1;                          return 1;
                 if (type != SSH_SMSG_FAILURE)                  if (type != SSH_SMSG_FAILURE)
Line 874 
Line 877 
 static int  static int
 try_password_authentication(char *prompt)  try_password_authentication(char *prompt)
 {  {
         int type, i;          int type, i, payload_len;
         char *password;          char *password;
   
         debug("Doing password authentication.");          debug("Doing password authentication.");
Line 891 
Line 894 
                 packet_send();                  packet_send();
                 packet_write_wait();                  packet_write_wait();
   
                 type = packet_read();                  type = packet_read(&payload_len);
                 if (type == SSH_SMSG_SUCCESS)                  if (type == SSH_SMSG_SUCCESS)
                         return 1;                          return 1;
                 if (type != SSH_SMSG_FAILURE)                  if (type != SSH_SMSG_FAILURE)
Line 909 
Line 912 
 {  {
         int i;          int i;
         BIGNUM *key;          BIGNUM *key;
         Key *host_key, *server_key;          RSA *host_key;
           RSA *public_key;
           Key k;
         int bits, rbits;          int bits, rbits;
         int ssh_cipher_default = SSH_CIPHER_3DES;          int ssh_cipher_default = SSH_CIPHER_3DES;
         u_char session_key[SSH_SESSION_KEY_LENGTH];          u_char session_key[SSH_SESSION_KEY_LENGTH];
         u_char cookie[8];          u_char cookie[8];
         u_int supported_ciphers;          u_int supported_ciphers;
         u_int server_flags, client_flags;          u_int server_flags, client_flags;
           int payload_len, clen, sum_len = 0;
         u_int32_t rand = 0;          u_int32_t rand = 0;
   
         debug("Waiting for server public key.");          debug("Waiting for server public key.");
   
         /* Wait for a public key packet from the server. */          /* Wait for a public key packet from the server. */
         packet_read_expect(SSH_SMSG_PUBLIC_KEY);          packet_read_expect(&payload_len, SSH_SMSG_PUBLIC_KEY);
   
         /* Get cookie from the packet. */          /* Get cookie from the packet. */
         for (i = 0; i < 8; i++)          for (i = 0; i < 8; i++)
                 cookie[i] = packet_get_char();                  cookie[i] = packet_get_char();
   
         /* Get the public key. */          /* Get the public key. */
         server_key = key_new(KEY_RSA1);          public_key = RSA_new();
         bits = packet_get_int();          bits = packet_get_int();/* bits */
         packet_get_bignum(server_key->rsa->e);          public_key->e = BN_new();
         packet_get_bignum(server_key->rsa->n);          packet_get_bignum(public_key->e, &clen);
           sum_len += clen;
           public_key->n = BN_new();
           packet_get_bignum(public_key->n, &clen);
           sum_len += clen;
   
         rbits = BN_num_bits(server_key->rsa->n);          rbits = BN_num_bits(public_key->n);
         if (bits != rbits) {          if (bits != rbits) {
                 log("Warning: Server lies about size of server public key: "                  log("Warning: Server lies about size of server public key: "
                     "actual size is %d bits vs. announced %d.", rbits, bits);                      "actual size is %d bits vs. announced %d.", rbits, bits);
                 log("Warning: This may be due to an old implementation of ssh.");                  log("Warning: This may be due to an old implementation of ssh.");
         }          }
         /* Get the host key. */          /* Get the host key. */
         host_key = key_new(KEY_RSA1);          host_key = RSA_new();
         bits = packet_get_int();          bits = packet_get_int();/* bits */
         packet_get_bignum(host_key->rsa->e);          host_key->e = BN_new();
         packet_get_bignum(host_key->rsa->n);          packet_get_bignum(host_key->e, &clen);
           sum_len += clen;
           host_key->n = BN_new();
           packet_get_bignum(host_key->n, &clen);
           sum_len += clen;
   
         rbits = BN_num_bits(host_key->rsa->n);          rbits = BN_num_bits(host_key->n);
         if (bits != rbits) {          if (bits != rbits) {
                 log("Warning: Server lies about size of server host key: "                  log("Warning: Server lies about size of server host key: "
                     "actual size is %d bits vs. announced %d.", rbits, bits);                      "actual size is %d bits vs. announced %d.", rbits, bits);
Line 958 
Line 972 
   
         supported_ciphers = packet_get_int();          supported_ciphers = packet_get_int();
         supported_authentications = packet_get_int();          supported_authentications = packet_get_int();
         packet_check_eom();  
   
         debug("Received server public key (%d bits) and host key (%d bits).",          debug("Received server public key (%d bits) and host key (%d bits).",
             BN_num_bits(server_key->rsa->n), BN_num_bits(host_key->rsa->n));              BN_num_bits(public_key->n), BN_num_bits(host_key->n));
   
         if (verify_host_key(host, hostaddr, host_key) == -1)          packet_integrity_check(payload_len,
               8 + 4 + sum_len + 0 + 4 + 0 + 0 + 4 + 4 + 4,
               SSH_SMSG_PUBLIC_KEY);
           k.type = KEY_RSA1;
           k.rsa = host_key;
           if (verify_host_key(host, hostaddr, &k) == -1)
                 fatal("Host key verification failed.");                  fatal("Host key verification failed.");
   
         client_flags = SSH_PROTOFLAG_SCREEN_NUMBER | SSH_PROTOFLAG_HOST_IN_FWD_OPEN;          client_flags = SSH_PROTOFLAG_SCREEN_NUMBER | SSH_PROTOFLAG_HOST_IN_FWD_OPEN;
   
         compute_session_id(session_id, cookie, host_key->rsa->n, server_key->rsa->n);          compute_session_id(session_id, cookie, host_key->n, public_key->n);
   
         /* Generate a session key. */          /* Generate a session key. */
         arc4random_stir();          arc4random_stir();
Line 990 
Line 1008 
          * is the highest byte of the integer.  The session key is xored with           * is the highest byte of the integer.  The session key is xored with
          * the first 16 bytes of the session id.           * the first 16 bytes of the session id.
          */           */
         if ((key = BN_new()) == NULL)          key = BN_new();
                 fatal("respond_to_rsa_challenge: BN_new failed");  
         BN_set_word(key, 0);          BN_set_word(key, 0);
         for (i = 0; i < SSH_SESSION_KEY_LENGTH; i++) {          for (i = 0; i < SSH_SESSION_KEY_LENGTH; i++) {
                 BN_lshift(key, key, 8);                  BN_lshift(key, key, 8);
Line 1005 
Line 1022 
          * Encrypt the integer using the public key and host key of the           * Encrypt the integer using the public key and host key of the
          * server (key with smaller modulus first).           * server (key with smaller modulus first).
          */           */
         if (BN_cmp(server_key->rsa->n, host_key->rsa->n) < 0) {          if (BN_cmp(public_key->n, host_key->n) < 0) {
                 /* Public key has smaller modulus. */                  /* Public key has smaller modulus. */
                 if (BN_num_bits(host_key->rsa->n) <                  if (BN_num_bits(host_key->n) <
                     BN_num_bits(server_key->rsa->n) + SSH_KEY_BITS_RESERVED) {                      BN_num_bits(public_key->n) + SSH_KEY_BITS_RESERVED) {
                         fatal("respond_to_rsa_challenge: host_key %d < server_key %d + "                          fatal("respond_to_rsa_challenge: host_key %d < public_key %d + "
                             "SSH_KEY_BITS_RESERVED %d",                              "SSH_KEY_BITS_RESERVED %d",
                             BN_num_bits(host_key->rsa->n),                              BN_num_bits(host_key->n),
                             BN_num_bits(server_key->rsa->n),                              BN_num_bits(public_key->n),
                             SSH_KEY_BITS_RESERVED);                              SSH_KEY_BITS_RESERVED);
                 }                  }
                 rsa_public_encrypt(key, key, server_key->rsa);                  rsa_public_encrypt(key, key, public_key);
                 rsa_public_encrypt(key, key, host_key->rsa);                  rsa_public_encrypt(key, key, host_key);
         } else {          } else {
                 /* Host key has smaller modulus (or they are equal). */                  /* Host key has smaller modulus (or they are equal). */
                 if (BN_num_bits(server_key->rsa->n) <                  if (BN_num_bits(public_key->n) <
                     BN_num_bits(host_key->rsa->n) + SSH_KEY_BITS_RESERVED) {                      BN_num_bits(host_key->n) + SSH_KEY_BITS_RESERVED) {
                         fatal("respond_to_rsa_challenge: server_key %d < host_key %d + "                          fatal("respond_to_rsa_challenge: public_key %d < host_key %d + "
                             "SSH_KEY_BITS_RESERVED %d",                              "SSH_KEY_BITS_RESERVED %d",
                             BN_num_bits(server_key->rsa->n),                              BN_num_bits(public_key->n),
                             BN_num_bits(host_key->rsa->n),                              BN_num_bits(host_key->n),
                             SSH_KEY_BITS_RESERVED);                              SSH_KEY_BITS_RESERVED);
                 }                  }
                 rsa_public_encrypt(key, key, host_key->rsa);                  rsa_public_encrypt(key, key, host_key);
                 rsa_public_encrypt(key, key, server_key->rsa);                  rsa_public_encrypt(key, key, public_key);
         }          }
   
         /* Destroy the public keys since we no longer need them. */          /* Destroy the public keys since we no longer need them. */
         key_free(server_key);          RSA_free(public_key);
         key_free(host_key);          RSA_free(host_key);
   
         if (options.cipher == SSH_CIPHER_NOT_SET) {          if (options.cipher == SSH_CIPHER_NOT_SET) {
                 if (cipher_mask_ssh1(1) & supported_ciphers & (1 << ssh_cipher_default))                  if (cipher_mask_ssh1(1) & supported_ciphers & (1 << ssh_cipher_default))
Line 1082 
Line 1099 
          * Expect a success message from the server.  Note that this message           * Expect a success message from the server.  Note that this message
          * will be received in encrypted form.           * will be received in encrypted form.
          */           */
         packet_read_expect(SSH_SMSG_SUCCESS);          packet_read_expect(&payload_len, SSH_SMSG_SUCCESS);
   
         debug("Received encrypted confirmation.");          debug("Received encrypted confirmation.");
 }  }
Line 1092 
Line 1109 
  */   */
 void  void
 ssh_userauth1(const char *local_user, const char *server_user, char *host,  ssh_userauth1(const char *local_user, const char *server_user, char *host,
     Sensitive *sensitive)      Key **keys, int nkeys)
 {  {
 #ifdef KRB5  #ifdef KRB5
         krb5_context context = NULL;          krb5_context context = NULL;
         krb5_auth_context auth_context = NULL;          krb5_auth_context auth_context = NULL;
 #endif  #endif
         int i, type;          int i, type;
           int payload_len;
   
         if (supported_authentications == 0)          if (supported_authentications == 0)
                 fatal("ssh_userauth1: server supports no auth methods");                  fatal("ssh_userauth1: server supports no auth methods");
Line 1114 
Line 1132 
          * needed (the user has no password).  Otherwise the server responds           * needed (the user has no password).  Otherwise the server responds
          * with failure.           * with failure.
          */           */
         type = packet_read();          type = packet_read(&payload_len);
   
         /* check whether the connection was accepted without authentication. */          /* check whether the connection was accepted without authentication. */
         if (type == SSH_SMSG_SUCCESS)          if (type == SSH_SMSG_SUCCESS)
Line 1128 
Line 1146 
                 debug("Trying Kerberos v5 authentication.");                  debug("Trying Kerberos v5 authentication.");
   
                 if (try_krb5_authentication(&context, &auth_context)) {                  if (try_krb5_authentication(&context, &auth_context)) {
                         type = packet_read();                          type = packet_read(&payload_len);
                         if (type == SSH_SMSG_SUCCESS)                          if (type == SSH_SMSG_SUCCESS)
                                 goto success;                                  goto success;
                         if (type != SSH_SMSG_FAILURE)                          if (type != SSH_SMSG_FAILURE)
Line 1143 
Line 1161 
                 debug("Trying Kerberos v4 authentication.");                  debug("Trying Kerberos v4 authentication.");
   
                 if (try_krb4_authentication()) {                  if (try_krb4_authentication()) {
                         type = packet_read();                          type = packet_read(&payload_len);
                         if (type == SSH_SMSG_SUCCESS)                          if (type == SSH_SMSG_SUCCESS)
                                 goto success;                                  goto success;
                         if (type != SSH_SMSG_FAILURE)                          if (type != SSH_SMSG_FAILURE)
Line 1165 
Line 1183 
                 packet_write_wait();                  packet_write_wait();
   
                 /* The server should respond with success or failure. */                  /* The server should respond with success or failure. */
                 type = packet_read();                  type = packet_read(&payload_len);
                 if (type == SSH_SMSG_SUCCESS)                  if (type == SSH_SMSG_SUCCESS)
                         goto success;                          goto success;
                 if (type != SSH_SMSG_FAILURE)                  if (type != SSH_SMSG_FAILURE)
Line 1178 
Line 1196 
          */           */
         if ((supported_authentications & (1 << SSH_AUTH_RHOSTS_RSA)) &&          if ((supported_authentications & (1 << SSH_AUTH_RHOSTS_RSA)) &&
             options.rhosts_rsa_authentication) {              options.rhosts_rsa_authentication) {
                 for (i = 0; i < sensitive->nkeys; i++) {                  for (i = 0; i < nkeys; i++) {
                         if (sensitive->keys[i] != NULL &&                          if (keys[i] != NULL && keys[i]->type == KEY_RSA1 &&
                             sensitive->keys[i]->type == KEY_RSA1 &&                              try_rhosts_rsa_authentication(local_user, keys[i]))
                             try_rhosts_rsa_authentication(local_user,  
                             sensitive->keys[i]))  
                                 goto success;                                  goto success;
                 }                  }
         }          }
Legend:
Removed from v.1.41.2.4  
changed lines
  Added in v.1.42