[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 and 1.42

version 1.41, 2001/10/06 11:18:19 version 1.42, 2001/12/19 07:18:56
Line 80 
Line 80 
   
         /* 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;
              key = ssh_get_next_identity(auth, &comment, 1)) {              key = ssh_get_next_identity(auth, &comment, 1)) {
   
                 /* Try this identity. */                  /* Try this identity. */
                 debug("Trying RSA authentication via agent with '%.100s'", comment);                  debug("Trying RSA authentication via agent with '%.100s'", comment);
Line 400 
Line 400 
         /* 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)
                 return 0;                  return 0;
   
         strlcpy(inst, (char *)krb_get_phost(get_canonical_hostname(1)),          strlcpy(inst, (char *)krb_get_phost(get_canonical_hostname(1)),
             INST_SZ);              INST_SZ);
   
         realm = (char *)krb_realmofhost(get_canonical_hostname(1));          realm = (char *)krb_realmofhost(get_canonical_hostname(1));
         if (!realm) {          if (!realm) {
                 debug("Kerberos v4: no realm for %s", get_canonical_hostname(1));                  debug("Kerberos v4: no realm for %s", get_canonical_hostname(1));
Line 411 
Line 411 
         }          }
         /* This can really be anything. */          /* This can really be anything. */
         checksum = (u_long)getpid();          checksum = (u_long)getpid();
   
         r = krb_mk_req(&auth, KRB4_SERVICE_NAME, inst, realm, checksum);          r = krb_mk_req(&auth, KRB4_SERVICE_NAME, inst, realm, checksum);
         if (r != KSUCCESS) {          if (r != KSUCCESS) {
                 debug("Kerberos v4 krb_mk_req failed: %s", krb_err_txt[r]);                  debug("Kerberos v4 krb_mk_req failed: %s", krb_err_txt[r]);
Line 424 
Line 424 
                 return 0;                  return 0;
         }          }
         des_key_sched((des_cblock *) cred.session, schedule);          des_key_sched((des_cblock *) cred.session, schedule);
   
         /* Send authentication info to server. */          /* Send authentication info to server. */
         packet_start(SSH_CMSG_AUTH_KERBEROS);          packet_start(SSH_CMSG_AUTH_KERBEROS);
         packet_put_string((char *) auth.dat, auth.length);          packet_put_string((char *) auth.dat, auth.length);
         packet_send();          packet_send();
         packet_write_wait();          packet_write_wait();
   
         /* Zero the buffer. */          /* Zero the buffer. */
         (void) memset(auth.dat, 0, MAX_KTXT_LEN);          (void) memset(auth.dat, 0, MAX_KTXT_LEN);
   
         slen = sizeof(local);          slen = sizeof(local);
         memset(&local, 0, sizeof(local));          memset(&local, 0, sizeof(local));
         if (getsockname(packet_get_connection_in(),          if (getsockname(packet_get_connection_in(),
             (struct sockaddr *)&local, &slen) < 0)              (struct sockaddr *)&local, &slen) < 0)
                 debug("getsockname failed: %s", strerror(errno));                  debug("getsockname failed: %s", strerror(errno));
   
         slen = sizeof(foreign);          slen = sizeof(foreign);
         memset(&foreign, 0, sizeof(foreign));          memset(&foreign, 0, sizeof(foreign));
         if (getpeername(packet_get_connection_in(),          if (getpeername(packet_get_connection_in(),
Line 455 
Line 455 
                 debug("Kerberos v4 authentication failed.");                  debug("Kerberos v4 authentication failed.");
                 return 0;                  return 0;
                 break;                  break;
   
         case SSH_SMSG_AUTH_KERBEROS_RESPONSE:          case SSH_SMSG_AUTH_KERBEROS_RESPONSE:
                 /* SSH_SMSG_AUTH_KERBEROS_SUCCESS */                  /* SSH_SMSG_AUTH_KERBEROS_SUCCESS */
                 debug("Kerberos v4 authentication accepted.");                  debug("Kerberos v4 authentication accepted.");
   
                 /* Get server's response. */                  /* Get server's response. */
                 reply = packet_get_string((u_int *) &auth.length);                  reply = packet_get_string((u_int *) &auth.length);
                 memcpy(auth.dat, reply, auth.length);                  memcpy(auth.dat, reply, auth.length);
                 xfree(reply);                  xfree(reply);
   
                 packet_integrity_check(plen, 4 + auth.length, type);                  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
                  * key, and the decrypted checksum fails to match, he's                   * key, and the decrypted checksum fails to match, he's
Line 483 
Line 483 
                 memcpy((char *)&cksum, (char *)msg_data.app_data,                  memcpy((char *)&cksum, (char *)msg_data.app_data,
                     sizeof(cksum));                      sizeof(cksum));
                 cksum = ntohl(cksum);                  cksum = ntohl(cksum);
   
                 /* If it matches, we're golden. */                  /* If it matches, we're golden. */
                 if (cksum == checksum + 1) {                  if (cksum == checksum + 1) {
                         debug("Kerberos v4 challenge successful.");                          debug("Kerberos v4 challenge successful.");
Line 491 
Line 491 
                 } else                  } else
                         packet_disconnect("Kerberos v4 challenge failed!");                          packet_disconnect("Kerberos v4 challenge failed!");
                 break;                  break;
   
         default:          default:
                 packet_disconnect("Protocol error on Kerberos v4 response: %d", type);                  packet_disconnect("Protocol error on Kerberos v4 response: %d", type);
         }          }
Line 513 
Line 513 
         int type, payload_len;          int type, payload_len;
         krb5_ap_rep_enc_part *reply = NULL;          krb5_ap_rep_enc_part *reply = NULL;
         int ret;          int ret;
   
         memset(&ap, 0, sizeof(ap));          memset(&ap, 0, sizeof(ap));
   
         problem = krb5_init_context(context);          problem = krb5_init_context(context);
         if (problem) {          if (problem) {
                 debug("Kerberos v5: krb5_init_context failed");                  debug("Kerberos v5: krb5_init_context failed");
                 ret = 0;                  ret = 0;
                 goto out;                  goto out;
         }          }
   
         tkfile = krb5_cc_default_name(*context);          tkfile = krb5_cc_default_name(*context);
         if (strncmp(tkfile, "FILE:", 5) == 0)          if (strncmp(tkfile, "FILE:", 5) == 0)
                 tkfile += 5;                  tkfile += 5;
   
         if (stat(tkfile, &buf) == 0 && getuid() != buf.st_uid) {          if (stat(tkfile, &buf) == 0 && getuid() != buf.st_uid) {
                 debug("Kerberos v5: could not get default ccache (permission denied).");                  debug("Kerberos v5: could not get default ccache (permission denied).");
                 ret = 0;                  ret = 0;
                 goto out;                  goto out;
         }          }
   
         problem = krb5_cc_default(*context, &ccache);          problem = krb5_cc_default(*context, &ccache);
         if (problem) {          if (problem) {
                 debug("Kerberos v5: krb5_cc_default failed: %s",                  debug("Kerberos v5: krb5_cc_default failed: %s",
Line 540 
Line 540 
                 ret = 0;                  ret = 0;
                 goto out;                  goto out;
         }          }
   
         remotehost = get_canonical_hostname(1);          remotehost = get_canonical_hostname(1);
   
         problem = krb5_mk_req(*context, auth_context, AP_OPTS_MUTUAL_REQUIRED,          problem = krb5_mk_req(*context, auth_context, AP_OPTS_MUTUAL_REQUIRED,
             "host", remotehost, NULL, ccache, &ap);              "host", remotehost, NULL, ccache, &ap);
         if (problem) {          if (problem) {
Line 551 
Line 551 
                 ret = 0;                  ret = 0;
                 goto out;                  goto out;
         }          }
   
         packet_start(SSH_CMSG_AUTH_KERBEROS);          packet_start(SSH_CMSG_AUTH_KERBEROS);
         packet_put_string((char *) ap.data, ap.length);          packet_put_string((char *) ap.data, ap.length);
         packet_send();          packet_send();
         packet_write_wait();          packet_write_wait();
   
         xfree(ap.data);          xfree(ap.data);
         ap.length = 0;          ap.length = 0;
   
         type = packet_read(&payload_len);          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 */
                 debug("Kerberos v5 authentication failed.");                  debug("Kerberos v5 authentication failed.");
                 ret = 0;                  ret = 0;
                 break;                  break;
   
         case SSH_SMSG_AUTH_KERBEROS_RESPONSE:          case SSH_SMSG_AUTH_KERBEROS_RESPONSE:
                 /* SSH_SMSG_AUTH_KERBEROS_SUCCESS */                  /* SSH_SMSG_AUTH_KERBEROS_SUCCESS */
                 debug("Kerberos v5 authentication accepted.");                  debug("Kerberos v5 authentication accepted.");
   
                 /* 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_integrity_check(payload_len, 4 + ap.length, type);                  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);
                 if (problem) {                  if (problem) {
                         ret = 0;                          ret = 0;
                 }                  }
                 ret = 1;                  ret = 1;
                 break;                  break;
   
         default:          default:
                 packet_disconnect("Protocol error on Kerberos v5 response: %d",                  packet_disconnect("Protocol error on Kerberos v5 response: %d",
                     type);                      type);
                 ret = 0;                  ret = 0;
                 break;                  break;
   
         }          }
   
  out:   out:
         if (ccache != NULL)          if (ccache != NULL)
                 krb5_cc_close(*context, ccache);                  krb5_cc_close(*context, ccache);
Line 600 
Line 600 
                 krb5_free_ap_rep_enc_part(*context, reply);                  krb5_free_ap_rep_enc_part(*context, reply);
         if (ap.length > 0)          if (ap.length > 0)
                 krb5_data_free(&ap);                  krb5_data_free(&ap);
   
         return (ret);          return (ret);
 }  }
   
Line 614 
Line 614 
         krb5_creds creds;          krb5_creds creds;
         krb5_kdc_flags flags;          krb5_kdc_flags flags;
         const char *remotehost;          const char *remotehost;
   
         memset(&creds, 0, sizeof(creds));          memset(&creds, 0, sizeof(creds));
         memset(&outbuf, 0, sizeof(outbuf));          memset(&outbuf, 0, sizeof(outbuf));
   
         fd = packet_get_connection_in();          fd = packet_get_connection_in();
   
         problem = krb5_auth_con_setaddrs_from_fd(context, auth_context, &fd);          problem = krb5_auth_con_setaddrs_from_fd(context, auth_context, &fd);
         if (problem)          if (problem)
                 goto out;                  goto out;
   
         problem = krb5_cc_default(context, &ccache);          problem = krb5_cc_default(context, &ccache);
         if (problem)          if (problem)
                 goto out;                  goto out;
   
         problem = krb5_cc_get_principal(context, ccache, &creds.client);          problem = krb5_cc_get_principal(context, ccache, &creds.client);
         if (problem)          if (problem)
                 goto out;                  goto out;
   
         problem = krb5_build_principal(context, &creds.server,          problem = krb5_build_principal(context, &creds.server,
             strlen(creds.client->realm), creds.client->realm,              strlen(creds.client->realm), creds.client->realm,
             "krbtgt", creds.client->realm, NULL);              "krbtgt", creds.client->realm, NULL);
         if (problem)          if (problem)
                 goto out;                  goto out;
   
         creds.times.endtime = 0;          creds.times.endtime = 0;
   
         flags.i = 0;          flags.i = 0;
         flags.b.forwarded = 1;          flags.b.forwarded = 1;
         flags.b.forwardable = krb5_config_get_bool(context,  NULL,          flags.b.forwardable = krb5_config_get_bool(context,  NULL,
             "libdefaults", "forwardable", NULL);              "libdefaults", "forwardable", NULL);
   
         remotehost = get_canonical_hostname(1);          remotehost = get_canonical_hostname(1);
   
         problem = krb5_get_forwarded_creds(context, auth_context,          problem = krb5_get_forwarded_creds(context, auth_context,
             ccache, flags.i, remotehost, &creds, &outbuf);              ccache, flags.i, remotehost, &creds, &outbuf);
         if (problem)          if (problem)
                 goto out;                  goto out;
   
         packet_start(SSH_CMSG_HAVE_KERBEROS_TGT);          packet_start(SSH_CMSG_HAVE_KERBEROS_TGT);
         packet_put_string((char *)outbuf.data, outbuf.length);          packet_put_string((char *)outbuf.data, outbuf.length);
         packet_send();          packet_send();
         packet_write_wait();          packet_write_wait();
   
         type = packet_read(&payload_len);          type = packet_read(&payload_len);
   
         if (type == SSH_SMSG_SUCCESS) {          if (type == SSH_SMSG_SUCCESS) {
                 char *pname;                  char *pname;
   
                 krb5_unparse_name(context, creds.client, &pname);                  krb5_unparse_name(context, creds.client, &pname);
                 debug("Kerberos v5 TGT forwarded (%s).", pname);                  debug("Kerberos v5 TGT forwarded (%s).", pname);
                 xfree(pname);                  xfree(pname);
         } else          } else
                 debug("Kerberos v5 TGT forwarding failed.");                  debug("Kerberos v5 TGT forwarding failed.");
   
         return;          return;
   
  out:   out:
         if (problem)          if (problem)
                 debug("Kerberos v5 TGT forwarding failed: %s",                  debug("Kerberos v5 TGT forwarding failed: %s",
Line 693 
Line 693 
         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, len;          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)
                 return;                  return;
   
         creds = xmalloc(sizeof(*creds));          creds = xmalloc(sizeof(*creds));
   
         problem = krb_get_tf_fullname(TKT_FILE, pname, pinst, prealm);          problem = krb_get_tf_fullname(TKT_FILE, pname, pinst, prealm);
         if (problem)          if (problem)
                 goto out;                  goto out;
   
         problem = krb_get_cred("krbtgt", prealm, prealm, creds);          problem = krb_get_cred("krbtgt", prealm, prealm, creds);
         if (problem)          if (problem)
                 goto out;                  goto out;
   
         if (time(0) > krb_life_to_time(creds->issue_date, creds->lifetime)) {          if (time(0) > krb_life_to_time(creds->issue_date, creds->lifetime)) {
                 problem = RD_AP_EXP;                  problem = RD_AP_EXP;
                 goto out;                  goto out;
         }          }
         creds_to_radix(creds, (u_char *)buffer, sizeof(buffer));          creds_to_radix(creds, (u_char *)buffer, sizeof(buffer));
   
         packet_start(SSH_CMSG_HAVE_KERBEROS_TGT);          packet_start(SSH_CMSG_HAVE_KERBEROS_TGT);
         packet_put_cstring(buffer);          packet_put_cstring(buffer);
         packet_send();          packet_send();
         packet_write_wait();          packet_write_wait();
   
         type = packet_read(&len);          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).",
                     creds->pname, creds->pinst[0] ? "." : "",                      creds->pname, creds->pinst[0] ? "." : "",
                     creds->pinst, creds->realm);                      creds->pinst, creds->realm);
         else          else
                 debug("Kerberos v4 TGT rejected.");                  debug("Kerberos v4 TGT rejected.");
   
         xfree(creds);          xfree(creds);
         return;          return;
   
  out:   out:
         debug("Kerberos v4 TGT passing failed: %s", krb_err_txt[problem]);          debug("Kerberos v4 TGT passing failed: %s", krb_err_txt[problem]);
         xfree(creds);          xfree(creds);
Line 745 
Line 745 
         int i, type, len;          int i, type, len;
         char buf[2048], *p, *server_cell;          char buf[2048], *p, *server_cell;
         char buffer[8192];          char buffer[8192];
   
         /* Move over ktc_GetToken, here's something leaner. */          /* Move over ktc_GetToken, here's something leaner. */
         for (i = 0; i < 100; i++) {     /* just in case */          for (i = 0; i < 100; i++) {     /* just in case */
                 parms.in = (char *) &i;                  parms.in = (char *) &i;
Line 755 
Line 755 
                 if (k_pioctl(0, VIOCGETTOK, &parms, 0) != 0)                  if (k_pioctl(0, VIOCGETTOK, &parms, 0) != 0)
                         break;                          break;
                 p = buf;                  p = buf;
   
                 /* Get secret token. */                  /* Get secret token. */
                 memcpy(&creds.ticket_st.length, p, sizeof(u_int));                  memcpy(&creds.ticket_st.length, p, sizeof(u_int));
                 if (creds.ticket_st.length > MAX_KTXT_LEN)                  if (creds.ticket_st.length > MAX_KTXT_LEN)
Line 763 
Line 763 
                 p += sizeof(u_int);                  p += sizeof(u_int);
                 memcpy(creds.ticket_st.dat, p, creds.ticket_st.length);                  memcpy(creds.ticket_st.dat, p, creds.ticket_st.length);
                 p += creds.ticket_st.length;                  p += creds.ticket_st.length;
   
                 /* Get clear token. */                  /* Get clear token. */
                 memcpy(&len, p, sizeof(len));                  memcpy(&len, p, sizeof(len));
                 if (len != sizeof(struct ClearToken))                  if (len != sizeof(struct ClearToken))
Line 773 
Line 773 
                 p += len;                  p += len;
                 p += sizeof(len);       /* primary flag */                  p += sizeof(len);       /* primary flag */
                 server_cell = p;                  server_cell = p;
   
                 /* Flesh out our credentials. */                  /* Flesh out our credentials. */
                 strlcpy(creds.service, "afs", sizeof(creds.service));                  strlcpy(creds.service, "afs", sizeof(creds.service));
                 creds.instance[0] = '\0';                  creds.instance[0] = '\0';
Line 785 
Line 785 
                 creds.kvno = ct.AuthHandle;                  creds.kvno = ct.AuthHandle;
                 snprintf(creds.pname, sizeof(creds.pname), "AFS ID %d", ct.ViceId);                  snprintf(creds.pname, sizeof(creds.pname), "AFS ID %d", ct.ViceId);
                 creds.pinst[0] = '\0';                  creds.pinst[0] = '\0';
   
                 /* Encode token, ship it off. */                  /* Encode token, ship it off. */
                 if (creds_to_radix(&creds, (u_char *)buffer,                  if (creds_to_radix(&creds, (u_char *)buffer,
                     sizeof(buffer)) <= 0)                      sizeof(buffer)) <= 0)
Line 798 
Line 798 
                 /* Roger, Roger. Clearance, Clarence. What's your vector,                  /* Roger, Roger. Clearance, Clarence. What's your vector,
                    Victor? */                     Victor? */
                 type = packet_read(&len);                  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);
                 else if (type != SSH_SMSG_SUCCESS)                  else if (type != SSH_SMSG_SUCCESS)
Line 842 
Line 842 
                 challenge = packet_get_string(&clen);                  challenge = packet_get_string(&clen);
                 packet_integrity_check(payload_len, (4 + clen), type);                  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);
                 if (i != 0)                  if (i != 0)
                         error("Permission denied, please try again.");                          error("Permission denied, please try again.");
Line 974 
Line 974 
         supported_authentications = packet_get_int();          supported_authentications = packet_get_int();
   
         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(public_key->n), BN_num_bits(host_key->n));              BN_num_bits(public_key->n), BN_num_bits(host_key->n));
   
         packet_integrity_check(payload_len,          packet_integrity_check(payload_len,
                                8 + 4 + sum_len + 0 + 4 + 0 + 0 + 4 + 4 + 4,              8 + 4 + sum_len + 0 + 4 + 0 + 0 + 4 + 4 + 4,
                                SSH_SMSG_PUBLIC_KEY);              SSH_SMSG_PUBLIC_KEY);
         k.type = KEY_RSA1;          k.type = KEY_RSA1;
         k.rsa = host_key;          k.rsa = host_key;
         if (verify_host_key(host, hostaddr, &k) == -1)          if (verify_host_key(host, hostaddr, &k) == -1)
Line 1027 
Line 1027 
                 if (BN_num_bits(host_key->n) <                  if (BN_num_bits(host_key->n) <
                     BN_num_bits(public_key->n) + SSH_KEY_BITS_RESERVED) {                      BN_num_bits(public_key->n) + SSH_KEY_BITS_RESERVED) {
                         fatal("respond_to_rsa_challenge: host_key %d < public_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->n),                              BN_num_bits(host_key->n),
                               BN_num_bits(public_key->n),                              BN_num_bits(public_key->n),
                               SSH_KEY_BITS_RESERVED);                              SSH_KEY_BITS_RESERVED);
                 }                  }
                 rsa_public_encrypt(key, key, public_key);                  rsa_public_encrypt(key, key, public_key);
                 rsa_public_encrypt(key, key, host_key);                  rsa_public_encrypt(key, key, host_key);
Line 1039 
Line 1039 
                 if (BN_num_bits(public_key->n) <                  if (BN_num_bits(public_key->n) <
                     BN_num_bits(host_key->n) + SSH_KEY_BITS_RESERVED) {                      BN_num_bits(host_key->n) + SSH_KEY_BITS_RESERVED) {
                         fatal("respond_to_rsa_challenge: public_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(public_key->n),                              BN_num_bits(public_key->n),
                               BN_num_bits(host_key->n),                              BN_num_bits(host_key->n),
                               SSH_KEY_BITS_RESERVED);                              SSH_KEY_BITS_RESERVED);
                 }                  }
                 rsa_public_encrypt(key, key, host_key);                  rsa_public_encrypt(key, key, host_key);
                 rsa_public_encrypt(key, key, public_key);                  rsa_public_encrypt(key, key, public_key);
Line 1064 
Line 1064 
         /* Check that the selected cipher is supported. */          /* Check that the selected cipher is supported. */
         if (!(supported_ciphers & (1 << options.cipher)))          if (!(supported_ciphers & (1 << options.cipher)))
                 fatal("Selected cipher type %.100s not supported by server.",                  fatal("Selected cipher type %.100s not supported by server.",
                       cipher_name(options.cipher));                      cipher_name(options.cipher));
   
         debug("Encryption type: %.100s", cipher_name(options.cipher));          debug("Encryption type: %.100s", cipher_name(options.cipher));
   
Line 1117 
Line 1117 
 #endif  #endif
         int i, type;          int i, type;
         int payload_len;          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 1139 
Line 1139 
                 goto success;                  goto success;
         if (type != SSH_SMSG_FAILURE)          if (type != SSH_SMSG_FAILURE)
                 packet_disconnect("Protocol error: got %d in response to SSH_CMSG_USER", type);                  packet_disconnect("Protocol error: got %d in response to SSH_CMSG_USER", type);
   
 #ifdef KRB5  #ifdef KRB5
         if ((supported_authentications & (1 << SSH_AUTH_KERBEROS)) &&          if ((supported_authentications & (1 << SSH_AUTH_KERBEROS)) &&
             options.kerberos_authentication) {              options.kerberos_authentication) {
                 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(&payload_len);                          type = packet_read(&payload_len);
                         if (type == SSH_SMSG_SUCCESS)                          if (type == SSH_SMSG_SUCCESS)
Line 1154 
Line 1154 
                 }                  }
         }          }
 #endif /* KRB5 */  #endif /* KRB5 */
   
 #ifdef KRB4  #ifdef KRB4
         if ((supported_authentications & (1 << SSH_AUTH_KERBEROS)) &&          if ((supported_authentications & (1 << SSH_AUTH_KERBEROS)) &&
             options.kerberos_authentication) {              options.kerberos_authentication) {
                 debug("Trying Kerberos v4 authentication.");                  debug("Trying Kerberos v4 authentication.");
   
                 if (try_krb4_authentication()) {                  if (try_krb4_authentication()) {
                         type = packet_read(&payload_len);                          type = packet_read(&payload_len);
                         if (type == SSH_SMSG_SUCCESS)                          if (type == SSH_SMSG_SUCCESS)
Line 1169 
Line 1169 
                 }                  }
         }          }
 #endif /* KRB4 */  #endif /* KRB4 */
   
         /*          /*
          * Use rhosts authentication if running in privileged socket and we           * Use rhosts authentication if running in privileged socket and we
          * do not wish to remain anonymous.           * do not wish to remain anonymous.
Line 1254 
Line 1254 
         if (context)          if (context)
                 krb5_free_context(context);                  krb5_free_context(context);
 #endif  #endif
   
 #ifdef AFS  #ifdef AFS
         /* Try Kerberos v4 TGT passing if the server supports it. */          /* Try Kerberos v4 TGT passing if the server supports it. */
         if ((supported_authentications & (1 << SSH_PASS_KERBEROS_TGT)) &&          if ((supported_authentications & (1 << SSH_PASS_KERBEROS_TGT)) &&
Legend:
Removed from v.1.41  
changed lines
  Added in v.1.42