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

Diff for /src/usr.bin/ssh/Attic/auth-rsa.c between version 1.32.2.6 and 1.33

version 1.32.2.6, 2002/03/08 17:04:41 version 1.33, 2000/11/14 23:42:40
Line 16 
Line 16 
 #include "includes.h"  #include "includes.h"
 RCSID("$OpenBSD$");  RCSID("$OpenBSD$");
   
 #include <openssl/rsa.h>  
 #include <openssl/md5.h>  
   
 #include "rsa.h"  #include "rsa.h"
 #include "packet.h"  #include "packet.h"
 #include "xmalloc.h"  #include "xmalloc.h"
 #include "ssh1.h"  #include "ssh.h"
 #include "mpaux.h"  #include "mpaux.h"
 #include "uidswap.h"  #include "uidswap.h"
 #include "match.h"  #include "match.h"
 #include "auth-options.h"  
 #include "pathnames.h"  
 #include "log.h"  
 #include "servconf.h"  #include "servconf.h"
 #include "auth.h"  #include "auth-options.h"
 #include "hostfile.h"  
   
   #include <openssl/rsa.h>
   #include <openssl/md5.h>
   
   
 /* import */  /* import */
 extern ServerOptions options;  extern ServerOptions options;
   
Line 40 
Line 37 
  * Session identifier that is used to bind key exchange and authentication   * Session identifier that is used to bind key exchange and authentication
  * responses to a particular session.   * responses to a particular session.
  */   */
 extern u_char session_id[16];  extern unsigned char session_id[16];
   
 /*  /*
  * The .ssh/authorized_keys file contains public keys, one per line, in the   * The .ssh/authorized_keys file contains public keys, one per line, in the
Line 63 
Line 60 
 {  {
         BIGNUM *challenge, *encrypted_challenge;          BIGNUM *challenge, *encrypted_challenge;
         BN_CTX *ctx;          BN_CTX *ctx;
         u_char buf[32], mdbuf[16], response[16];          unsigned char buf[32], mdbuf[16], response[16];
         MD5_CTX md;          MD5_CTX md;
         u_int i;          unsigned int i;
         int len;          int plen, len;
   
         if ((encrypted_challenge = BN_new()) == NULL)          encrypted_challenge = BN_new();
                 fatal("auth_rsa_challenge_dialog: BN_new() failed");          challenge = BN_new();
         if ((challenge = BN_new()) == NULL)  
                 fatal("auth_rsa_challenge_dialog: BN_new() failed");  
   
         /* Generate a random challenge. */          /* Generate a random challenge. */
         BN_rand(challenge, 256, 0, 0);          BN_rand(challenge, 256, 0, 0);
         if ((ctx = BN_CTX_new()) == NULL)          ctx = BN_CTX_new();
                 fatal("auth_rsa_challenge_dialog: BN_CTX_new() failed");  
         BN_mod(challenge, challenge, pk->n, ctx);          BN_mod(challenge, challenge, pk->n, ctx);
         BN_CTX_free(ctx);          BN_CTX_free(ctx);
   
Line 91 
Line 85 
         packet_write_wait();          packet_write_wait();
   
         /* Wait for a response. */          /* Wait for a response. */
         packet_read_expect(SSH_CMSG_AUTH_RSA_RESPONSE);          packet_read_expect(&plen, SSH_CMSG_AUTH_RSA_RESPONSE);
           packet_integrity_check(plen, 16, SSH_CMSG_AUTH_RSA_RESPONSE);
         for (i = 0; i < 16; i++)          for (i = 0; i < 16; i++)
                 response[i] = packet_get_char();                  response[i] = packet_get_char();
         packet_check_eom();  
   
         /* The response is MD5 of decrypted challenge plus session id. */          /* The response is MD5 of decrypted challenge plus session id. */
         len = BN_num_bytes(challenge);          len = BN_num_bytes(challenge);
Line 126 
Line 120 
 int  int
 auth_rsa(struct passwd *pw, BIGNUM *client_n)  auth_rsa(struct passwd *pw, BIGNUM *client_n)
 {  {
         char line[8192], *file;          char line[8192], file[1024];
         int authenticated;          int authenticated;
         u_int bits;          unsigned int bits;
         FILE *f;          FILE *f;
         u_long linenum = 0;          unsigned long linenum = 0;
         struct stat st;          struct stat st;
         Key *key;          RSA *pk;
         char *fp;  
   
         /* no user given */          /* no user given */
         if (pw == NULL)          if (pw == NULL)
                 return 0;                  return 0;
   
         /* Temporarily use the user's uid. */          /* Temporarily use the user's uid. */
         temporarily_use_uid(pw);          temporarily_use_uid(pw->pw_uid);
   
         /* The authorized keys. */          /* The authorized keys. */
         file = authorized_keys_file(pw);          snprintf(file, sizeof file, "%.500s/%.100s", pw->pw_dir,
         debug("trying public RSA key file %s", file);                   SSH_USER_PERMITTED_KEYS);
   
         /* Fail quietly if file does not exist */          /* Fail quietly if file does not exist */
         if (stat(file, &st) < 0) {          if (stat(file, &st) < 0) {
                 /* Restore the privileged uid. */                  /* Restore the privileged uid. */
                 restore_uid();                  restore_uid();
                 xfree(file);  
                 return 0;                  return 0;
         }          }
         /* Open the file containing the authorized keys. */          /* Open the file containing the authorized keys. */
Line 160 
Line 152 
                 restore_uid();                  restore_uid();
                 packet_send_debug("Could not open %.900s for reading.", file);                  packet_send_debug("Could not open %.900s for reading.", file);
                 packet_send_debug("If your home is on an NFS volume, it may need to be world-readable.");                  packet_send_debug("If your home is on an NFS volume, it may need to be world-readable.");
                 xfree(file);  
                 return 0;                  return 0;
         }          }
         if (options.strict_modes &&          if (options.strict_modes) {
             secure_filename(f, file, pw, line, sizeof(line)) != 0) {                  int fail = 0;
                 xfree(file);                  char buf[1024];
                 fclose(f);                  /* Check open file in order to avoid open/stat races */
                 log("Authentication refused: %s", line);                  if (fstat(fileno(f), &st) < 0 ||
                 packet_send_debug("Authentication refused: %s", line);                      (st.st_uid != 0 && st.st_uid != pw->pw_uid) ||
                 restore_uid();                      (st.st_mode & 022) != 0) {
                 return 0;                          snprintf(buf, sizeof buf, "RSA authentication refused for %.100s: "
                                    "bad ownership or modes for '%s'.", pw->pw_name, file);
                           fail = 1;
                   } else {
                           /* Check path to SSH_USER_PERMITTED_KEYS */
                           int i;
                           static const char *check[] = {
                                   "", SSH_USER_DIR, NULL
                           };
                           for (i = 0; check[i]; i++) {
                                   snprintf(line, sizeof line, "%.500s/%.100s", pw->pw_dir, check[i]);
                                   if (stat(line, &st) < 0 ||
                                       (st.st_uid != 0 && st.st_uid != pw->pw_uid) ||
                                       (st.st_mode & 022) != 0) {
                                           snprintf(buf, sizeof buf, "RSA authentication refused for %.100s: "
                                                    "bad ownership or modes for '%s'.", pw->pw_name, line);
                                           fail = 1;
                                           break;
                                   }
                           }
                   }
                   if (fail) {
                           fclose(f);
                           log("%s",buf);
                           packet_send_debug("%s",buf);
                           restore_uid();
                           return 0;
                   }
         }          }
         /* Flag indicating whether authentication has succeeded. */          /* Flag indicating whether authentication has succeeded. */
         authenticated = 0;          authenticated = 0;
   
         key = key_new(KEY_RSA1);          pk = RSA_new();
           pk->e = BN_new();
           pk->n = BN_new();
   
         /*          /*
          * Go though the accepted keys, looking for the current key.  If           * Go though the accepted keys, looking for the current key.  If
Line 213 
Line 233 
                         options = NULL;                          options = NULL;
   
                 /* Parse the key from the line. */                  /* Parse the key from the line. */
                 if (hostfile_read_key(&cp, &bits, key) == 0) {                  if (!auth_rsa_read_key(&cp, &bits, pk->e, pk->n)) {
                         debug("%.100s, line %lu: non ssh1 key syntax",                          debug("%.100s, line %lu: bad key syntax",
                             file, linenum);                                SSH_USER_PERMITTED_KEYS, linenum);
                           packet_send_debug("%.100s, line %lu: bad key syntax",
                                             SSH_USER_PERMITTED_KEYS, linenum);
                         continue;                          continue;
                 }                  }
                 /* cp now points to the comment part. */                  /* cp now points to the comment part. */
   
                 /* Check if the we have found the desired key (identified by its modulus). */                  /* Check if the we have found the desired key (identified by its modulus). */
                 if (BN_cmp(key->rsa->n, client_n) != 0)                  if (BN_cmp(pk->n, client_n) != 0)
                         continue;                          continue;
   
                 /* check the real bits  */                  /* check the real bits  */
                 if (bits != BN_num_bits(key->rsa->n))                  if (bits != BN_num_bits(pk->n))
                         log("Warning: %s, line %lu: keysize mismatch: "                          log("Warning: %s, line %ld: keysize mismatch: "
                             "actual %d vs. announced %d.",                              "actual %d vs. announced %d.",
                             file, linenum, BN_num_bits(key->rsa->n), bits);                              file, linenum, BN_num_bits(pk->n), bits);
   
                 /* We have found the desired key. */                  /* We have found the desired key. */
                 /*                  /*
                  * If our options do not allow this key to be used,                   * If our options do not allow this key to be used,
                  * do not send challenge.                   * do not send challenge.
                  */                   */
                 if (!auth_parse_options(pw, options, file, linenum))                  if (!auth_parse_options(pw, options, linenum))
                         continue;                          continue;
   
                 /* Perform the challenge-response dialog for this key. */                  /* Perform the challenge-response dialog for this key. */
                 if (!auth_rsa_challenge_dialog(key->rsa)) {                  if (!auth_rsa_challenge_dialog(pk)) {
                         /* Wrong response. */                          /* Wrong response. */
                         verbose("Wrong response to RSA authentication challenge.");                          verbose("Wrong response to RSA authentication challenge.");
                         packet_send_debug("Wrong response to RSA authentication challenge.");                          packet_send_debug("Wrong response to RSA authentication challenge.");
                         /*                          continue;
                          * Break out of the loop. Otherwise we might send  
                          * another challenge and break the protocol.  
                          */  
                         break;  
                 }                  }
                 /*                  /*
                  * Correct response.  The client has been successfully                   * Correct response.  The client has been successfully
Line 258 
Line 276 
                  * otherwise continue searching.                   * otherwise continue searching.
                  */                   */
                 authenticated = 1;                  authenticated = 1;
   
                 fp = key_fingerprint(key, SSH_FP_MD5, SSH_FP_HEX);  
                 verbose("Found matching %s key: %s",  
                     key_type(key), fp);  
                 xfree(fp);  
   
                 break;                  break;
         }          }
   
Line 271 
Line 283 
         restore_uid();          restore_uid();
   
         /* Close the file. */          /* Close the file. */
         xfree(file);  
         fclose(f);          fclose(f);
   
         key_free(key);          RSA_free(pk);
   
         if (authenticated)          if (authenticated)
                 packet_send_debug("RSA authentication accepted.");                  packet_send_debug("RSA authentication accepted.");
Legend:
Removed from v.1.32.2.6  
changed lines
  Added in v.1.33