[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.6

version 1.32, 2000/10/14 12:19:45 version 1.32.2.6, 2002/03/08 17:04: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 "hostfile.h"
   
 #include <openssl/rsa.h>  
 #include <openssl/md5.h>  
   
   
 /* import */  /* import */
 extern ServerOptions options;  extern ServerOptions options;
   
Line 37 
Line 40 
  * 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 63 
 {  {
         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 len;
   
         encrypted_challenge = BN_new();          if ((encrypted_challenge = BN_new()) == NULL)
         challenge = BN_new();                  fatal("auth_rsa_challenge_dialog: BN_new() failed");
           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);
         ctx = BN_CTX_new();          if ((ctx = BN_CTX_new()) == NULL)
                   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 85 
Line 91 
         packet_write_wait();          packet_write_wait();
   
         /* Wait for a response. */          /* Wait for a response. */
         packet_read_expect(&plen, SSH_CMSG_AUTH_RSA_RESPONSE);          packet_read_expect(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 120 
Line 126 
 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;          Key *key;
           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->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 160 
                 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;
   
         pk = RSA_new();          key = key_new(KEY_RSA1);
         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 231 
Line 211 
                         }                          }
                 } 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 (hostfile_read_key(&cp, &bits, key) == 0) {
                         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. */
   
                 /* 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(pk->n, client_n) != 0)                  if (BN_cmp(key->rsa->n, client_n) != 0)
                         continue;                          continue;
   
                 /* check the real bits  */                  /* check the real bits  */
                 if (bits != BN_num_bits(pk->n))                  if (bits != BN_num_bits(key->rsa->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(key->rsa->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(key->rsa)) {
                         /* 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 276 
Line 258 
                  * 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 283 
Line 271 
         restore_uid();          restore_uid();
   
         /* Close the file. */          /* Close the file. */
           xfree(file);
         fclose(f);          fclose(f);
   
         RSA_free(pk);          key_free(key);
   
         if (authenticated)          if (authenticated)
                 packet_send_debug("RSA authentication accepted.");                  packet_send_debug("RSA authentication accepted.");
Legend:
Removed from v.1.32  
changed lines
  Added in v.1.32.2.6