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

version 1.32, 2000/10/14 12:19:45 version 1.32.2.5, 2001/09/27 00:15:41
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 "ssh.h"  #include "ssh1.h"
 #include "mpaux.h"  #include "mpaux.h"
 #include "uidswap.h"  #include "uidswap.h"
 #include "match.h"  #include "match.h"
 #include "servconf.h"  
 #include "auth-options.h"  #include "auth-options.h"
   #include "pathnames.h"
   #include "log.h"
   #include "servconf.h"
   #include "auth.h"
   
 #include <openssl/rsa.h>  
 #include <openssl/md5.h>  
   
   
 /* import */  /* import */
 extern ServerOptions options;  extern ServerOptions options;
   
Line 37 
Line 39 
  * 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 unsigned char session_id[16];  extern u_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 60 
Line 62 
 {  {
         BIGNUM *challenge, *encrypted_challenge;          BIGNUM *challenge, *encrypted_challenge;
         BN_CTX *ctx;          BN_CTX *ctx;
         unsigned char buf[32], mdbuf[16], response[16];          u_char buf[32], mdbuf[16], response[16];
         MD5_CTX md;          MD5_CTX md;
         unsigned int i;          u_int i;
         int plen, len;          int plen, len;
   
         encrypted_challenge = BN_new();          encrypted_challenge = BN_new();
Line 120 
Line 122 
 int  int
 auth_rsa(struct passwd *pw, BIGNUM *client_n)  auth_rsa(struct passwd *pw, BIGNUM *client_n)
 {  {
         char line[8192], file[1024];          char line[8192], *file;
         int authenticated;          int authenticated;
         unsigned int bits;          u_int bits;
         FILE *f;          FILE *f;
         unsigned long linenum = 0;          u_long linenum = 0;
         struct stat st;          struct stat st;
         RSA *pk;          RSA *pk;
   
Line 133 
Line 135 
                 return 0;                  return 0;
   
         /* Temporarily use the user's uid. */          /* Temporarily use the user's uid. */
         temporarily_use_uid(pw->pw_uid);          temporarily_use_uid(pw);
   
         /* The authorized keys. */          /* The authorized keys. */
         snprintf(file, sizeof file, "%.500s/%.100s", pw->pw_dir,          file = authorized_keys_file(pw);
                  SSH_USER_PERMITTED_KEYS);          debug("trying public RSA key file %s", file);
   
         /* 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 152 
Line 155 
                 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 &&
                 int fail = 0;              secure_filename(f, file, pw, line, sizeof(line)) != 0) {
                 char buf[1024];                  xfree(file);
                 /* Check open file in order to avoid open/stat races */                  fclose(f);
                 if (fstat(fileno(f), &st) < 0 ||                  log("Authentication refused: %s", line);
                     (st.st_uid != 0 && st.st_uid != pw->pw_uid) ||                  packet_send_debug("Authentication refused: %s", line);
                     (st.st_mode & 022) != 0) {                  restore_uid();
                         snprintf(buf, sizeof buf, "RSA authentication refused for %.100s: "                  return 0;
                                  "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;
Line 231 
Line 208 
                         }                          }
                 } else                  } else
                         options = NULL;                          options = NULL;
                 /*  
                  * If our options do not allow this key to be used,  
                  * do not send challenge.  
                  */  
                 if (!auth_parse_options(pw, options, linenum))  
                         continue;  
   
                 /* Parse the key from the line. */                  /* Parse the key from the line. */
                 if (!auth_rsa_read_key(&cp, &bits, pk->e, pk->n)) {                  if (!auth_rsa_read_key(&cp, &bits, pk->e, pk->n)) {
                         debug("%.100s, line %lu: bad key syntax",                          debug("%.100s, line %lu: non ssh1 key syntax",
                               SSH_USER_PERMITTED_KEYS, linenum);                              file, 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. */
Line 254 
Line 223 
   
                 /* check the real bits  */                  /* check the real bits  */
                 if (bits != BN_num_bits(pk->n))                  if (bits != BN_num_bits(pk->n))
                         log("Warning: %s, line %ld: keysize mismatch: "                          log("Warning: %s, line %lu: keysize mismatch: "
                             "actual %d vs. announced %d.",                              "actual %d vs. announced %d.",
                             file, linenum, BN_num_bits(pk->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,
                    * do not send challenge.
                    */
                   if (!auth_parse_options(pw, options, file, linenum))
                           continue;
   
                 /* Perform the challenge-response dialog for this key. */                  /* Perform the challenge-response dialog for this key. */
                 if (!auth_rsa_challenge_dialog(pk)) {                  if (!auth_rsa_challenge_dialog(pk)) {
Line 283 
Line 258 
         restore_uid();          restore_uid();
   
         /* Close the file. */          /* Close the file. */
           xfree(file);
         fclose(f);          fclose(f);
   
         RSA_free(pk);          RSA_free(pk);
Legend:
Removed from v.1.32  
changed lines
  Added in v.1.32.2.5