[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.31 and 1.31.2.2

version 1.31, 2001/04/17 08:14:01 version 1.31.2.2, 2001/11/15 00:15:19
Line 21 
Line 21 
 #ifdef KRB4  #ifdef KRB4
 #include <krb.h>  #include <krb.h>
 #endif  #endif
   #ifdef KRB5
   #include <krb5.h>
   #endif
 #ifdef AFS  #ifdef AFS
 #include <kafs.h>  #include <kafs.h>
 #include "radix.h"  #include "radix.h"
Line 43 
Line 46 
 #include "readpass.h"  #include "readpass.h"
 #include "cipher.h"  #include "cipher.h"
 #include "canohost.h"  #include "canohost.h"
   #include "auth.h"
   
 /* Session id for the current session. */  /* Session id for the current session. */
 u_char session_id[16];  u_char session_id[16];
Line 55 
Line 59 
  * Checks if the user has an authentication agent, and if so, tries to   * Checks if the user has an authentication agent, and if so, tries to
  * authenticate using the agent.   * authenticate using the agent.
  */   */
 int  static int
 try_agent_authentication(void)  try_agent_authentication(void)
 {  {
         int type;          int type;
Line 155 
Line 159 
  * Computes the proper response to a RSA challenge, and sends the response to   * Computes the proper response to a RSA challenge, and sends the response to
  * the server.   * the server.
  */   */
 void  static void
 respond_to_rsa_challenge(BIGNUM * challenge, RSA * prv)  respond_to_rsa_challenge(BIGNUM * challenge, RSA * prv)
 {  {
         u_char buf[32], response[16];          u_char buf[32], response[16];
Line 200 
Line 204 
  * Checks if the user has authentication file, and if so, tries to authenticate   * Checks if the user has authentication file, and if so, tries to authenticate
  * the user using it.   * the user using it.
  */   */
 int  static int
 try_rsa_authentication(const char *authfile)  try_rsa_authentication(int idx)
 {  {
         BIGNUM *challenge;          BIGNUM *challenge;
         Key *public;          Key *public, *private;
         Key *private;          char buf[300], *passphrase, *comment, *authfile;
         char *passphrase, *comment;          int i, type, quit, plen, clen;
         int type, i;  
         int plen, clen;  
   
         /* Try to load identification for the authentication key. */          public = options.identity_keys[idx];
         /* XXKEYLOAD */          authfile = options.identity_files[idx];
         public = key_load_public_type(KEY_RSA1, authfile, &comment);          comment = xstrdup(authfile);
         if (public == NULL) {  
                 /* Could not load it.  Fail. */  
                 return 0;  
         }  
         debug("Trying RSA authentication with key '%.100s'", comment);          debug("Trying RSA authentication with key '%.100s'", comment);
   
         /* Tell the server that we are willing to authenticate using this key. */          /* Tell the server that we are willing to authenticate using this key. */
Line 225 
Line 224 
         packet_send();          packet_send();
         packet_write_wait();          packet_write_wait();
   
         /* We no longer need the public key. */  
         key_free(public);  
   
         /* Wait for server's response. */          /* Wait for server's response. */
         type = packet_read(&plen);          type = packet_read(&plen);
   
Line 253 
Line 249 
         debug("Received RSA challenge from server.");          debug("Received RSA challenge from server.");
   
         /*          /*
          * Load the private key.  Try first with empty passphrase; if it           * If the key is not stored in external hardware, we have to
            * load the private key.  Try first with empty passphrase; if it
          * fails, ask for a passphrase.           * fails, ask for a passphrase.
          */           */
         private = key_load_private_type(KEY_RSA1, authfile, "", NULL);          if (public->flags && KEY_FLAG_EXT)
         if (private == NULL) {                  private = public;
                 char buf[300];          else
                 snprintf(buf, sizeof buf, "Enter passphrase for RSA key '%.100s': ",                  private = key_load_private_type(KEY_RSA1, authfile, "", NULL);
                     comment);          if (private == NULL && !options.batch_mode) {
                 if (!options.batch_mode)                  snprintf(buf, sizeof(buf),
                       "Enter passphrase for RSA key '%.100s': ", comment);
                   for (i = 0; i < options.number_of_password_prompts; i++) {
                         passphrase = read_passphrase(buf, 0);                          passphrase = read_passphrase(buf, 0);
                 else {                          if (strcmp(passphrase, "") != 0) {
                         debug("Will not query passphrase for %.100s in batch mode.",                                  private = key_load_private_type(KEY_RSA1,
                               comment);                                      authfile, passphrase, NULL);
                         passphrase = xstrdup("");                                  quit = 0;
                 }                          } else {
                                   debug2("no passphrase given, try next key");
                 /* Load the authentication file using the pasphrase. */                                  quit = 1;
                 private = key_load_private_type(KEY_RSA1, authfile, passphrase, NULL);                          }
                 if (private == NULL) {  
                         memset(passphrase, 0, strlen(passphrase));                          memset(passphrase, 0, strlen(passphrase));
                         xfree(passphrase);                          xfree(passphrase);
                         error("Bad passphrase.");                          if (private != NULL || quit)
                                   break;
                         /* Send a dummy response packet to avoid protocol error. */                          debug2("bad passphrase given, try again...");
                         packet_start(SSH_CMSG_AUTH_RSA_RESPONSE);  
                         for (i = 0; i < 16; i++)  
                                 packet_put_char(0);  
                         packet_send();  
                         packet_write_wait();  
   
                         /* Expect the server to reject it... */  
                         packet_read_expect(&plen, SSH_SMSG_FAILURE);  
                         xfree(comment);  
                         BN_clear_free(challenge);  
                         return 0;  
                 }                  }
                 /* Destroy the passphrase. */  
                 memset(passphrase, 0, strlen(passphrase));  
                 xfree(passphrase);  
         }          }
         /* We no longer need the comment. */          /* We no longer need the comment. */
         xfree(comment);          xfree(comment);
   
           if (private == NULL) {
                   if (!options.batch_mode)
                           error("Bad passphrase.");
   
                   /* Send a dummy response packet to avoid protocol error. */
                   packet_start(SSH_CMSG_AUTH_RSA_RESPONSE);
                   for (i = 0; i < 16; i++)
                           packet_put_char(0);
                   packet_send();
                   packet_write_wait();
   
                   /* Expect the server to reject it... */
                   packet_read_expect(&plen, SSH_SMSG_FAILURE);
                   BN_clear_free(challenge);
                   return 0;
           }
   
         /* Compute and send a response to the challenge. */          /* Compute and send a response to the challenge. */
         respond_to_rsa_challenge(challenge, private->rsa);          respond_to_rsa_challenge(challenge, private->rsa);
   
         /* Destroy the private key. */          /* Destroy the private key unless it in external hardware. */
         key_free(private);          if (!(private->flags & KEY_FLAG_EXT))
                   key_free(private);
   
         /* We no longer need the challenge. */          /* We no longer need the challenge. */
         BN_clear_free(challenge);          BN_clear_free(challenge);
Line 321 
Line 323 
  * Tries to authenticate the user using combined rhosts or /etc/hosts.equiv   * Tries to authenticate the user using combined rhosts or /etc/hosts.equiv
  * authentication and RSA host authentication.   * authentication and RSA host authentication.
  */   */
 int  static int
 try_rhosts_rsa_authentication(const char *local_user, Key * host_key)  try_rhosts_rsa_authentication(const char *local_user, Key * host_key)
 {  {
         int type;          int type;
Line 332 
Line 334 
   
         /* Tell the server that we are willing to authenticate using this key. */          /* Tell the server that we are willing to authenticate using this key. */
         packet_start(SSH_CMSG_AUTH_RHOSTS_RSA);          packet_start(SSH_CMSG_AUTH_RHOSTS_RSA);
         packet_put_string(local_user, strlen(local_user));          packet_put_cstring(local_user);
         packet_put_int(BN_num_bits(host_key->rsa->n));          packet_put_int(BN_num_bits(host_key->rsa->n));
         packet_put_bignum(host_key->rsa->e);          packet_put_bignum(host_key->rsa->e);
         packet_put_bignum(host_key->rsa->n);          packet_put_bignum(host_key->rsa->n);
Line 379 
Line 381 
 }  }
   
 #ifdef KRB4  #ifdef KRB4
 int  static int
 try_kerberos_authentication(void)  try_krb4_authentication(void)
 {  {
         KTEXT_ST auth;          /* Kerberos data */          KTEXT_ST auth;          /* Kerberos data */
         char *reply;          char *reply;
Line 398 
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;
   
         strncpy(inst, (char *) krb_get_phost(get_canonical_hostname(1)), INST_SZ);          strlcpy(inst, (char *)krb_get_phost(get_canonical_hostname(1)),
               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));
                 return 0;                  return 0;
         }          }
         /* 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]);
                 return 0;                  return 0;
         }          }
         /* Get session key to decrypt the server's reply with. */          /* Get session key to decrypt the server's reply with. */
Line 421 
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(),
                         (struct sockaddr *) & foreign, &slen) < 0) {              (struct sockaddr *)&foreign, &slen) < 0) {
                 debug("getpeername failed: %s", strerror(errno));                  debug("getpeername failed: %s", strerror(errno));
                 fatal_cleanup();                  fatal_cleanup();
         }          }
Line 449 
Line 452 
         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 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
                  * bogus. Bail out.                   * bogus. Bail out.
                  */                   */
                 r = krb_rd_priv(auth.dat, auth.length, schedule, &cred.session,                  r = krb_rd_priv(auth.dat, auth.length, schedule, &cred.session,
                                 &foreign, &local, &msg_data);                      &foreign, &local, &msg_data);
                 if (r != KSUCCESS) {                  if (r != KSUCCESS) {
                         debug("Kerberos V4 krb_rd_priv failed: %s", krb_err_txt[r]);                          debug("Kerberos v4 krb_rd_priv failed: %s",
                         packet_disconnect("Kerberos V4 challenge failed!");                              krb_err_txt[r]);
                           packet_disconnect("Kerberos v4 challenge failed!");
                 }                  }
                 /* Fetch the (incremented) checksum that we supplied in the request. */                  /* Fetch the (incremented) checksum that we supplied in the request. */
                 (void) memcpy((char *) &cksum, (char *) msg_data.app_data, sizeof(cksum));                  memcpy((char *)&cksum, (char *)msg_data.app_data,
                       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.");
                         return 1;                          return 1;
                 } 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);
         }          }
         return 0;          return 0;
 }  }
   
 #endif /* KRB4 */  #endif /* KRB4 */
   
   #ifdef KRB5
   static int
   try_krb5_authentication(krb5_context *context, krb5_auth_context *auth_context)
   {
           krb5_error_code problem;
           const char *tkfile;
           struct stat buf;
           krb5_ccache ccache = NULL;
           const char *remotehost;
           krb5_data ap;
           int type, payload_len;
           krb5_ap_rep_enc_part *reply = NULL;
           int ret;
   
           memset(&ap, 0, sizeof(ap));
   
           problem = krb5_init_context(context);
           if (problem) {
                   debug("Kerberos v5: krb5_init_context failed");
                   ret = 0;
                   goto out;
           }
   
           tkfile = krb5_cc_default_name(*context);
           if (strncmp(tkfile, "FILE:", 5) == 0)
                   tkfile += 5;
   
           if (stat(tkfile, &buf) == 0 && getuid() != buf.st_uid) {
                   debug("Kerberos v5: could not get default ccache (permission denied).");
                   ret = 0;
                   goto out;
           }
   
           problem = krb5_cc_default(*context, &ccache);
           if (problem) {
                   debug("Kerberos v5: krb5_cc_default failed: %s",
                       krb5_get_err_text(*context, problem));
                   ret = 0;
                   goto out;
           }
   
           remotehost = get_canonical_hostname(1);
   
           problem = krb5_mk_req(*context, auth_context, AP_OPTS_MUTUAL_REQUIRED,
               "host", remotehost, NULL, ccache, &ap);
           if (problem) {
                   debug("Kerberos v5: krb5_mk_req failed: %s",
                       krb5_get_err_text(*context, problem));
                   ret = 0;
                   goto out;
           }
   
           packet_start(SSH_CMSG_AUTH_KERBEROS);
           packet_put_string((char *) ap.data, ap.length);
           packet_send();
           packet_write_wait();
   
           xfree(ap.data);
           ap.length = 0;
   
           type = packet_read(&payload_len);
           switch (type) {
           case SSH_SMSG_FAILURE:
                   /* Should really be SSH_SMSG_AUTH_KERBEROS_FAILURE */
                   debug("Kerberos v5 authentication failed.");
                   ret = 0;
                   break;
   
           case SSH_SMSG_AUTH_KERBEROS_RESPONSE:
                   /* SSH_SMSG_AUTH_KERBEROS_SUCCESS */
                   debug("Kerberos v5 authentication accepted.");
   
                   /* Get server's response. */
                   ap.data = packet_get_string((unsigned int *) &ap.length);
   
                   packet_integrity_check(payload_len, 4 + ap.length, type);
                   /* XXX je to dobre? */
   
                   problem = krb5_rd_rep(*context, *auth_context, &ap, &reply);
                   if (problem) {
                           ret = 0;
                   }
                   ret = 1;
                   break;
   
           default:
                   packet_disconnect("Protocol error on Kerberos v5 response: %d",
                       type);
                   ret = 0;
                   break;
   
           }
   
    out:
           if (ccache != NULL)
                   krb5_cc_close(*context, ccache);
           if (reply != NULL)
                   krb5_free_ap_rep_enc_part(*context, reply);
           if (ap.length > 0)
                   krb5_data_free(&ap);
   
           return (ret);
   }
   
   static void
   send_krb5_tgt(krb5_context context, krb5_auth_context auth_context)
   {
           int fd, type, payload_len;
           krb5_error_code problem;
           krb5_data outbuf;
           krb5_ccache ccache = NULL;
           krb5_creds creds;
           krb5_kdc_flags flags;
           const char *remotehost;
   
           memset(&creds, 0, sizeof(creds));
           memset(&outbuf, 0, sizeof(outbuf));
   
           fd = packet_get_connection_in();
   
           problem = krb5_auth_con_setaddrs_from_fd(context, auth_context, &fd);
           if (problem)
                   goto out;
   
           problem = krb5_cc_default(context, &ccache);
           if (problem)
                   goto out;
   
           problem = krb5_cc_get_principal(context, ccache, &creds.client);
           if (problem)
                   goto out;
   
           problem = krb5_build_principal(context, &creds.server,
               strlen(creds.client->realm), creds.client->realm,
               "krbtgt", creds.client->realm, NULL);
           if (problem)
                   goto out;
   
           creds.times.endtime = 0;
   
           flags.i = 0;
           flags.b.forwarded = 1;
           flags.b.forwardable = krb5_config_get_bool(context,  NULL,
               "libdefaults", "forwardable", NULL);
   
           remotehost = get_canonical_hostname(1);
   
           problem = krb5_get_forwarded_creds(context, auth_context,
               ccache, flags.i, remotehost, &creds, &outbuf);
           if (problem)
                   goto out;
   
           packet_start(SSH_CMSG_HAVE_KERBEROS_TGT);
           packet_put_string((char *)outbuf.data, outbuf.length);
           packet_send();
           packet_write_wait();
   
           type = packet_read(&payload_len);
   
           if (type == SSH_SMSG_SUCCESS) {
                   char *pname;
   
                   krb5_unparse_name(context, creds.client, &pname);
                   debug("Kerberos v5 TGT forwarded (%s).", pname);
                   xfree(pname);
           } else
                   debug("Kerberos v5 TGT forwarding failed.");
   
           return;
   
    out:
           if (problem)
                   debug("Kerberos v5 TGT forwarding failed: %s",
                       krb5_get_err_text(context, problem));
           if (creds.client)
                   krb5_free_principal(context, creds.client);
           if (creds.server)
                   krb5_free_principal(context, creds.server);
           if (ccache)
                   krb5_cc_close(context, ccache);
           if (outbuf.data)
                   xfree(outbuf.data);
   }
   #endif /* KRB5 */
   
 #ifdef AFS  #ifdef AFS
 int  static void
 send_kerberos_tgt(void)  send_krb4_tgt(void)
 {  {
         CREDENTIALS *creds;          CREDENTIALS *creds;
         char pname[ANAME_SZ], pinst[INST_SZ], prealm[REALM_SZ];  
         int r, type, plen;  
         char buffer[8192];  
         struct stat st;          struct stat st;
           char buffer[4096], pname[ANAME_SZ], pinst[INST_SZ], prealm[REALM_SZ];
           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 0;                  return;
   
         creds = xmalloc(sizeof(*creds));          creds = xmalloc(sizeof(*creds));
   
         if ((r = krb_get_tf_fullname(TKT_FILE, pname, pinst, prealm)) != KSUCCESS) {          problem = krb_get_tf_fullname(TKT_FILE, pname, pinst, prealm);
                 debug("Kerberos V4 tf_fullname failed: %s", krb_err_txt[r]);          if (problem)
                 return 0;                  goto out;
         }  
         if ((r = krb_get_cred("krbtgt", prealm, prealm, creds)) != GC_OK) {          problem = krb_get_cred("krbtgt", prealm, prealm, creds);
                 debug("Kerberos V4 get_cred failed: %s", krb_err_txt[r]);          if (problem)
                 return 0;                  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)) {
                 debug("Kerberos V4 ticket expired: %s", TKT_FILE);                  problem = RD_AP_EXP;
                 return 0;                  goto out;
         }          }
         creds_to_radix(creds, (u_char *)buffer, sizeof buffer);          creds_to_radix(creds, (u_char *)buffer, sizeof(buffer));
         xfree(creds);  
   
         packet_start(SSH_CMSG_HAVE_KERBEROS_TGT);          packet_start(SSH_CMSG_HAVE_KERBEROS_TGT);
         packet_put_string(buffer, strlen(buffer));          packet_put_cstring(buffer);
         packet_send();          packet_send();
         packet_write_wait();          packet_write_wait();
   
         type = packet_read(&plen);          type = packet_read(&len);
   
         if (type == SSH_SMSG_FAILURE)          if (type == SSH_SMSG_SUCCESS)
                 debug("Kerberos TGT for realm %s rejected.", prealm);                  debug("Kerberos v4 TGT forwarded (%s%s%s@%s).",
         else if (type != SSH_SMSG_SUCCESS)                      creds->pname, creds->pinst[0] ? "." : "",
                 packet_disconnect("Protocol error on Kerberos TGT response: %d", type);                      creds->pinst, creds->realm);
           else
         return 1;                  debug("Kerberos v4 TGT rejected.");
   
           xfree(creds);
           return;
   
    out:
           debug("Kerberos v4 TGT passing failed: %s", krb_err_txt[problem]);
           xfree(creds);
 }  }
   
 void  static void
 send_afs_tokens(void)  send_afs_tokens(void)
 {  {
         CREDENTIALS creds;          CREDENTIALS creds;
         struct ViceIoctl parms;          struct ViceIoctl parms;
         struct ClearToken ct;          struct ClearToken ct;
         int i, type, len, plen;          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 560 
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 568 
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 578 
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';
                 strlcpy(creds.realm, server_cell, REALM_SZ);                  strlcpy(creds.realm, server_cell, REALM_SZ);
                 memcpy(creds.session, ct.HandShakeKey, DES_KEY_SZ);                  memcpy(creds.session, ct.HandShakeKey, DES_KEY_SZ);
                 creds.issue_date = ct.BeginTimestamp;                  creds.issue_date = ct.BeginTimestamp;
                 creds.lifetime = krb_time_to_life(creds.issue_date, ct.EndTimestamp);                  creds.lifetime = krb_time_to_life(creds.issue_date,
                       ct.EndTimestamp);
                 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, sizeof buffer) <= 0)                  if (creds_to_radix(&creds, (u_char *)buffer,
                       sizeof(buffer)) <= 0)
                         break;                          break;
                 packet_start(SSH_CMSG_HAVE_AFS_TOKEN);                  packet_start(SSH_CMSG_HAVE_AFS_TOKEN);
                 packet_put_string(buffer, strlen(buffer));                  packet_put_cstring(buffer);
                 packet_send();                  packet_send();
                 packet_write_wait();                  packet_write_wait();
   
                 /* Roger, Roger. Clearance, Clarence. What's your vector,                  /* Roger, Roger. Clearance, Clarence. What's your vector,
                    Victor? */                     Victor? */
                 type = packet_read(&plen);                  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 615 
Line 812 
  * Tries to authenticate with any string-based challenge/response system.   * Tries to authenticate with any string-based challenge/response system.
  * Note that the client code is not tied to s/key or TIS.   * Note that the client code is not tied to s/key or TIS.
  */   */
 int  static int
 try_challenge_reponse_authentication(void)  try_challenge_response_authentication(void)
 {  {
         int type, i;          int type, i;
         int payload_len;          int payload_len;
Line 624 
Line 821 
         char prompt[1024];          char prompt[1024];
         char *challenge, *response;          char *challenge, *response;
   
         debug("Doing challenge reponse authentication.");          debug("Doing challenge response authentication.");
   
         for (i = 0; i < options.number_of_password_prompts; i++) {          for (i = 0; i < options.number_of_password_prompts; i++) {
                 /* request a challenge */                  /* request a challenge */
Line 677 
Line 874 
 /*  /*
  * Tries to authenticate with plain passwd authentication.   * Tries to authenticate with plain passwd authentication.
  */   */
 int  static int
 try_password_authentication(char *prompt)  try_password_authentication(char *prompt)
 {  {
         int type, i, payload_len;          int type, i, payload_len;
Line 784 
Line 981 
                                SSH_SMSG_PUBLIC_KEY);                                 SSH_SMSG_PUBLIC_KEY);
         k.type = KEY_RSA1;          k.type = KEY_RSA1;
         k.rsa = host_key;          k.rsa = host_key;
         check_host_key(host, hostaddr, &k,          if (verify_host_key(host, hostaddr, &k) == -1)
             options.user_hostfile, options.system_hostfile);                  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;
   
Line 914 
Line 1111 
 ssh_userauth1(const char *local_user, const char *server_user, char *host,  ssh_userauth1(const char *local_user, const char *server_user, char *host,
     Key **keys, int nkeys)      Key **keys, int nkeys)
 {  {
   #ifdef KRB5
           krb5_context context = NULL;
           krb5_auth_context auth_context = NULL;
   #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");
   
         /* Send the name of the user to log in as on the server. */          /* Send the name of the user to log in as on the server. */
         packet_start(SSH_CMSG_USER);          packet_start(SSH_CMSG_USER);
         packet_put_string(server_user, strlen(server_user));          packet_put_cstring(server_user);
         packet_send();          packet_send();
         packet_write_wait();          packet_write_wait();
   
Line 935 
Line 1136 
   
         /* 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)
                 return;                  goto success;
         if (type != SSH_SMSG_FAILURE)          if (type != SSH_SMSG_FAILURE)
                 packet_disconnect("Protocol error: got %d in response to SSH_CMSG_USER",                  packet_disconnect("Protocol error: got %d in response to SSH_CMSG_USER", type);
                                   type);  
   #ifdef KRB5
 #ifdef AFS          if ((supported_authentications & (1 << SSH_AUTH_KERBEROS)) &&
         /* Try Kerberos tgt passing if the server supports it. */              options.kerberos_authentication) {
         if ((supported_authentications & (1 << SSH_PASS_KERBEROS_TGT)) &&                  debug("Trying Kerberos v5 authentication.");
             options.kerberos_tgt_passing) {  
                 if (options.cipher == SSH_CIPHER_NONE)                  if (try_krb5_authentication(&context, &auth_context)) {
                         log("WARNING: Encryption is disabled! Ticket will be transmitted in the clear!");                          type = packet_read(&payload_len);
                 (void) send_kerberos_tgt();                          if (type == SSH_SMSG_SUCCESS)
                                   goto success;
                           if (type != SSH_SMSG_FAILURE)
                                   packet_disconnect("Protocol error: got %d in response to Kerberos v5 auth", type);
                   }
         }          }
         /* Try AFS token passing if the server supports it. */  #endif /* KRB5 */
         if ((supported_authentications & (1 << SSH_PASS_AFS_TOKEN)) &&  
             options.afs_token_passing && k_hasafs()) {  
                 if (options.cipher == SSH_CIPHER_NONE)  
                         log("WARNING: Encryption is disabled! Token will be transmitted in the clear!");  
                 send_afs_tokens();  
         }  
 #endif /* AFS */  
   
 #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 authentication.");                  debug("Trying Kerberos v4 authentication.");
                 if (try_kerberos_authentication()) {  
                         /* The server should respond with success or failure. */                  if (try_krb4_authentication()) {
                         type = packet_read(&payload_len);                          type = packet_read(&payload_len);
                         if (type == SSH_SMSG_SUCCESS)                          if (type == SSH_SMSG_SUCCESS)
                                 return;                                  goto success;
                         if (type != SSH_SMSG_FAILURE)                          if (type != SSH_SMSG_FAILURE)
                                 packet_disconnect("Protocol error: got %d in response to Kerberos auth", type);                                  packet_disconnect("Protocol error: got %d in response to Kerberos v4 auth", type);
                 }                  }
         }          }
 #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 980 
Line 1178 
             options.rhosts_authentication) {              options.rhosts_authentication) {
                 debug("Trying rhosts authentication.");                  debug("Trying rhosts authentication.");
                 packet_start(SSH_CMSG_AUTH_RHOSTS);                  packet_start(SSH_CMSG_AUTH_RHOSTS);
                 packet_put_string(local_user, strlen(local_user));                  packet_put_cstring(local_user);
                 packet_send();                  packet_send();
                 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(&payload_len);                  type = packet_read(&payload_len);
                 if (type == SSH_SMSG_SUCCESS)                  if (type == SSH_SMSG_SUCCESS)
                         return;                          goto success;
                 if (type != SSH_SMSG_FAILURE)                  if (type != SSH_SMSG_FAILURE)
                         packet_disconnect("Protocol error: got %d in response to rhosts auth",                          packet_disconnect("Protocol error: got %d in response to rhosts auth",
                                           type);                                            type);
Line 1001 
Line 1199 
                 for (i = 0; i < nkeys; i++) {                  for (i = 0; i < nkeys; i++) {
                         if (keys[i] != NULL && keys[i]->type == KEY_RSA1 &&                          if (keys[i] != NULL && keys[i]->type == KEY_RSA1 &&
                             try_rhosts_rsa_authentication(local_user, keys[i]))                              try_rhosts_rsa_authentication(local_user, keys[i]))
                                 return;                                  goto success;
                 }                  }
         }          }
         /* Try RSA authentication if the server supports it. */          /* Try RSA authentication if the server supports it. */
Line 1013 
Line 1211 
                  * it, whereas identity files may require passphrases.                   * it, whereas identity files may require passphrases.
                  */                   */
                 if (try_agent_authentication())                  if (try_agent_authentication())
                         return;                          goto success;
   
                 /* Try RSA authentication for each identity. */                  /* Try RSA authentication for each identity. */
                 for (i = 0; i < options.num_identity_files; i++)                  for (i = 0; i < options.num_identity_files; i++)
                         if (options.identity_keys[i] != NULL &&                          if (options.identity_keys[i] != NULL &&
                             options.identity_keys[i]->type == KEY_RSA1 &&                              options.identity_keys[i]->type == KEY_RSA1 &&
                             try_rsa_authentication(options.identity_files[i]))                              try_rsa_authentication(i))
                                 return;                                  goto success;
         }          }
         /* Try challenge response authentication if the server supports it. */          /* Try challenge response authentication if the server supports it. */
         if ((supported_authentications & (1 << SSH_AUTH_TIS)) &&          if ((supported_authentications & (1 << SSH_AUTH_TIS)) &&
             options.challenge_reponse_authentication && !options.batch_mode) {              options.challenge_response_authentication && !options.batch_mode) {
                 if (try_challenge_reponse_authentication())                  if (try_challenge_response_authentication())
                         return;                          goto success;
         }          }
         /* Try password authentication if the server supports it. */          /* Try password authentication if the server supports it. */
         if ((supported_authentications & (1 << SSH_AUTH_PASSWORD)) &&          if ((supported_authentications & (1 << SSH_AUTH_PASSWORD)) &&
Line 1036 
Line 1234 
                 snprintf(prompt, sizeof(prompt), "%.30s@%.128s's password: ",                  snprintf(prompt, sizeof(prompt), "%.30s@%.128s's password: ",
                     server_user, host);                      server_user, host);
                 if (try_password_authentication(prompt))                  if (try_password_authentication(prompt))
                         return;                          goto success;
         }          }
         /* All authentication methods have failed.  Exit with an error message. */          /* All authentication methods have failed.  Exit with an error message. */
         fatal("Permission denied.");          fatal("Permission denied.");
         /* NOTREACHED */          /* NOTREACHED */
   
    success:
   #ifdef KRB5
           /* Try Kerberos v5 TGT passing. */
           if ((supported_authentications & (1 << SSH_PASS_KERBEROS_TGT)) &&
               options.kerberos_tgt_passing && context && auth_context) {
                   if (options.cipher == SSH_CIPHER_NONE)
                           log("WARNING: Encryption is disabled! Ticket will be transmitted in the clear!");
                   send_krb5_tgt(context, auth_context);
           }
           if (auth_context)
                   krb5_auth_con_free(context, auth_context);
           if (context)
                   krb5_free_context(context);
   #endif
   
   #ifdef AFS
           /* Try Kerberos v4 TGT passing if the server supports it. */
           if ((supported_authentications & (1 << SSH_PASS_KERBEROS_TGT)) &&
               options.kerberos_tgt_passing) {
                   if (options.cipher == SSH_CIPHER_NONE)
                           log("WARNING: Encryption is disabled! Ticket will be transmitted in the clear!");
                   send_krb4_tgt();
           }
           /* Try AFS token passing if the server supports it. */
           if ((supported_authentications & (1 << SSH_PASS_AFS_TOKEN)) &&
               options.afs_token_passing && k_hasafs()) {
                   if (options.cipher == SSH_CIPHER_NONE)
                           log("WARNING: Encryption is disabled! Token will be transmitted in the clear!");
                   send_afs_tokens();
           }
   #endif /* AFS */
   
           return; /* need statement after label */
 }  }
Legend:
Removed from v.1.31  
changed lines
  Added in v.1.31.2.2