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

Diff for /src/usr.bin/ssh/authfile.c between version 1.16 and 1.16.2.3

version 1.16, 2000/04/26 21:28:32 version 1.16.2.3, 2001/03/12 15:44:08
Line 1 
Line 1 
 /*  /*
  *  
  * authfile.c  
  *  
  * Author: Tatu Ylonen <ylo@cs.hut.fi>   * Author: Tatu Ylonen <ylo@cs.hut.fi>
  *  
  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland   * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
  *                    All rights reserved   *                    All rights reserved
  *  
  * Created: Mon Mar 27 03:52:05 1995 ylo  
  *  
  * This file contains functions for reading and writing identity files, and   * This file contains functions for reading and writing identity files, and
  * for reading the passphrase from the user.   * for reading the passphrase from the user.
  *   *
    * As far as I am concerned, the code I have written for this software
    * can be used freely for any purpose.  Any derived versions of this
    * software must be clearly marked as such, and if the derived work is
    * incompatible with the protocol description in the RFC file, it must be
    * called by a name other than "ssh" or "Secure Shell".
    *
    *
    * Copyright (c) 2000 Markus Friedl.  All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions
    * are met:
    * 1. Redistributions of source code must retain the above copyright
    *    notice, this list of conditions and the following disclaimer.
    * 2. Redistributions in binary form must reproduce the above copyright
    *    notice, this list of conditions and the following disclaimer in the
    *    documentation and/or other materials provided with the distribution.
    *
    * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
    * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
    * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
    * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
    * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
    * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
    * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */   */
   
 #include "includes.h"  #include "includes.h"
 RCSID("$Id$");  RCSID("$OpenBSD$");
   
 #include <openssl/bn.h>  #include <openssl/err.h>
 #include <openssl/dsa.h>  
 #include <openssl/rsa.h>  
 #include <openssl/pem.h>  
 #include <openssl/evp.h>  #include <openssl/evp.h>
   #include <openssl/pem.h>
   
   #include "cipher.h"
 #include "xmalloc.h"  #include "xmalloc.h"
 #include "buffer.h"  #include "buffer.h"
 #include "bufaux.h"  #include "bufaux.h"
 #include "cipher.h"  
 #include "ssh.h"  
 #include "key.h"  #include "key.h"
   #include "ssh.h"
   #include "log.h"
   #include "authfile.h"
   
 /* Version identification string for identity files. */  /* Version identification string for identity files. */
 #define AUTHFILE_ID_STRING "SSH PRIVATE KEY FILE FORMAT 1.1\n"  static const char authfile_id_string[] =
       "SSH PRIVATE KEY FILE FORMAT 1.1\n";
   
 /*  /*
  * Saves the authentication (private) key in a file, encrypting it with   * Saves the authentication (private) key in a file, encrypting it with
Line 41 
Line 63 
  */   */
   
 int  int
 save_private_key_rsa(const char *filename, const char *passphrase,  save_private_key_rsa1(const char *filename, const char *passphrase,
     RSA *key, const char *comment)      RSA *key, const char *comment)
 {  {
         Buffer buffer, encrypted;          Buffer buffer, encrypted;
         char buf[100], *cp;          char buf[100], *cp;
         int fd, i;          int fd, i;
         CipherContext cipher;          CipherContext ciphercontext;
         int cipher_type;          Cipher *cipher;
         u_int32_t rand;          u_int32_t rand;
   
         /*          /*
Line 56 
Line 78 
          * to another cipher; otherwise use SSH_AUTHFILE_CIPHER.           * to another cipher; otherwise use SSH_AUTHFILE_CIPHER.
          */           */
         if (strcmp(passphrase, "") == 0)          if (strcmp(passphrase, "") == 0)
                 cipher_type = SSH_CIPHER_NONE;                  cipher = cipher_by_number(SSH_CIPHER_NONE);
         else          else
                 cipher_type = SSH_AUTHFILE_CIPHER;                  cipher = cipher_by_number(SSH_AUTHFILE_CIPHER);
           if (cipher == NULL)
                   fatal("save_private_key_rsa: bad cipher");
   
         /* This buffer is used to built the secret part of the private key. */          /* This buffer is used to built the secret part of the private key. */
         buffer_init(&buffer);          buffer_init(&buffer);
Line 89 
Line 113 
         buffer_init(&encrypted);          buffer_init(&encrypted);
   
         /* First store keyfile id string. */          /* First store keyfile id string. */
         cp = AUTHFILE_ID_STRING;          for (i = 0; authfile_id_string[i]; i++)
         for (i = 0; cp[i]; i++)                  buffer_put_char(&encrypted, authfile_id_string[i]);
                 buffer_put_char(&encrypted, cp[i]);  
         buffer_put_char(&encrypted, 0);          buffer_put_char(&encrypted, 0);
   
         /* Store cipher type. */          /* Store cipher type. */
         buffer_put_char(&encrypted, cipher_type);          buffer_put_char(&encrypted, cipher->number);
         buffer_put_int(&encrypted, 0);  /* For future extension */          buffer_put_int(&encrypted, 0);  /* For future extension */
   
         /* Store public key.  This will be in plain text. */          /* Store public key.  This will be in plain text. */
Line 107 
Line 130 
         /* Allocate space for the private part of the key in the buffer. */          /* Allocate space for the private part of the key in the buffer. */
         buffer_append_space(&encrypted, &cp, buffer_len(&buffer));          buffer_append_space(&encrypted, &cp, buffer_len(&buffer));
   
         cipher_set_key_string(&cipher, cipher_type, passphrase);          cipher_set_key_string(&ciphercontext, cipher, passphrase);
         cipher_encrypt(&cipher, (unsigned char *) cp,          cipher_encrypt(&ciphercontext, (u_char *) cp,
                        (unsigned char *) buffer_ptr(&buffer),              (u_char *) buffer_ptr(&buffer), buffer_len(&buffer));
                        buffer_len(&buffer));          memset(&ciphercontext, 0, sizeof(ciphercontext));
         memset(&cipher, 0, sizeof(cipher));  
   
         /* Destroy temporary data. */          /* Destroy temporary data. */
         memset(buf, 0, sizeof(buf));          memset(buf, 0, sizeof(buf));
Line 126 
Line 148 
                       strerror(errno));                        strerror(errno));
                 buffer_free(&encrypted);                  buffer_free(&encrypted);
                 close(fd);                  close(fd);
                 remove(filename);                  unlink(filename);
                 return 0;                  return 0;
         }          }
         close(fd);          close(fd);
Line 134 
Line 156 
         return 1;          return 1;
 }  }
   
 /* save DSA key in OpenSSL PEM format */  /* save SSH2 key in OpenSSL PEM format */
   
 int  int
 save_private_key_dsa(const char *filename, const char *passphrase,  save_private_key_ssh2(const char *filename, const char *_passphrase,
     DSA *dsa, const char *comment)      Key *key, const char *comment)
 {  {
         FILE *fp;          FILE *fp;
         int fd;          int fd;
         int success = 1;          int success = 0;
         int len = strlen(passphrase);          int len = strlen(_passphrase);
           char *passphrase = (len > 0) ? (char *)_passphrase : NULL;
           EVP_CIPHER *cipher = (len > 0) ? EVP_des_ede3_cbc() : NULL;
   
         if (len > 0 && len <= 4) {          if (len > 0 && len <= 4) {
                 error("passphrase too short: %d bytes", len);                  error("passphrase too short: %d bytes", len);
Line 161 
Line 184 
                 close(fd);                  close(fd);
                 return 0;                  return 0;
         }          }
         if (len > 0) {          switch (key->type) {
                 if (!PEM_write_DSAPrivateKey(fp, dsa, EVP_des_ede3_cbc(),                  case KEY_DSA:
                     (char *)passphrase, strlen(passphrase), NULL, NULL))                          success = PEM_write_DSAPrivateKey(fp, key->dsa,
                         success = 0;                              cipher, passphrase, len, NULL, NULL);
         } else {                          break;
                 if (!PEM_write_DSAPrivateKey(fp, dsa, NULL,                  case KEY_RSA:
                     NULL, 0, NULL, NULL))                          success = PEM_write_RSAPrivateKey(fp, key->rsa,
                         success = 0;                              cipher, passphrase, len, NULL, NULL);
                           break;
         }          }
         fclose(fp);          fclose(fp);
         return success;          return success;
Line 179 
Line 203 
     const char *comment)      const char *comment)
 {  {
         switch (key->type) {          switch (key->type) {
         case KEY_RSA:          case KEY_RSA1:
                 return save_private_key_rsa(filename, passphrase, key->rsa, comment);                  return save_private_key_rsa1(filename, passphrase, key->rsa, comment);
                 break;                  break;
         case KEY_DSA:          case KEY_DSA:
                 return save_private_key_dsa(filename, passphrase, key->dsa, comment);          case KEY_RSA:
                   return save_private_key_ssh2(filename, passphrase, key, comment);
                 break;                  break;
         default:          default:
                 break;                  break;
Line 223 
Line 248 
         }          }
         close(fd);          close(fd);
   
         /* Check that it is at least big enought to contain the ID string. */          /* Check that it is at least big enough to contain the ID string. */
         if (len < strlen(AUTHFILE_ID_STRING) + 1) {          if (len < sizeof(authfile_id_string)) {
                 debug("Bad key file %.200s.", filename);                  debug3("Bad RSA1 key file %.200s.", filename);
                 buffer_free(&buffer);                  buffer_free(&buffer);
                 return 0;                  return 0;
         }          }
Line 233 
Line 258 
          * Make sure it begins with the id string.  Consume the id string           * Make sure it begins with the id string.  Consume the id string
          * from the buffer.           * from the buffer.
          */           */
         for (i = 0; i < (unsigned int) strlen(AUTHFILE_ID_STRING) + 1; i++)          for (i = 0; i < sizeof(authfile_id_string); i++)
                 if (buffer_get_char(&buffer) != (u_char) AUTHFILE_ID_STRING[i]) {                  if (buffer_get_char(&buffer) != authfile_id_string[i]) {
                         debug("Bad key file %.200s.", filename);                          debug3("Bad RSA1 key file %.200s.", filename);
                         buffer_free(&buffer);                          buffer_free(&buffer);
                         return 0;                          return 0;
                 }                  }
Line 262 
Line 287 
         return 1;          return 1;
 }  }
   
   /* load public key from private-key file */
 int  int
 load_public_key(const char *filename, Key * key, char **comment_return)  load_public_key(const char *filename, Key * key, char **comment_return)
 {  {
         switch (key->type) {          switch (key->type) {
         case KEY_RSA:          case KEY_RSA1:
                 return load_public_key_rsa(filename, key->rsa, comment_return);                  return load_public_key_rsa(filename, key->rsa, comment_return);
                 break;                  break;
         case KEY_DSA:          case KEY_DSA:
           case KEY_RSA:
         default:          default:
                 break;                  break;
         }          }
Line 284 
Line 311 
  */   */
   
 int  int
 load_private_key_rsa(int fd, const char *filename,  load_private_key_rsa1(int fd, const char *filename,
     const char *passphrase, RSA * prv, char **comment_return)      const char *passphrase, RSA * prv, char **comment_return)
 {  {
         int i, check1, check2, cipher_type;          int i, check1, check2, cipher_type;
         off_t len;          off_t len;
         Buffer buffer, decrypted;          Buffer buffer, decrypted;
         char *cp;          char *cp;
         CipherContext cipher;          CipherContext ciphercontext;
           Cipher *cipher;
         BN_CTX *ctx;          BN_CTX *ctx;
         BIGNUM *aux;          BIGNUM *aux;
   
Line 303 
Line 331 
   
         if (read(fd, cp, (size_t) len) != (size_t) len) {          if (read(fd, cp, (size_t) len) != (size_t) len) {
                 debug("Read from key file %.200s failed: %.100s", filename,                  debug("Read from key file %.200s failed: %.100s", filename,
                       strerror(errno));                      strerror(errno));
                 buffer_free(&buffer);                  buffer_free(&buffer);
                 close(fd);                  close(fd);
                 return 0;                  return 0;
         }          }
         close(fd);          close(fd);
   
         /* Check that it is at least big enought to contain the ID string. */          /* Check that it is at least big enough to contain the ID string. */
         if (len < strlen(AUTHFILE_ID_STRING) + 1) {          if (len < sizeof(authfile_id_string)) {
                 debug("Bad key file %.200s.", filename);                  debug3("Bad RSA1 key file %.200s.", filename);
                 buffer_free(&buffer);                  buffer_free(&buffer);
                 return 0;                  return 0;
         }          }
Line 320 
Line 348 
          * Make sure it begins with the id string.  Consume the id string           * Make sure it begins with the id string.  Consume the id string
          * from the buffer.           * from the buffer.
          */           */
         for (i = 0; i < (unsigned int) strlen(AUTHFILE_ID_STRING) + 1; i++)          for (i = 0; i < sizeof(authfile_id_string); i++)
                 if (buffer_get_char(&buffer) != (unsigned char) AUTHFILE_ID_STRING[i]) {                  if (buffer_get_char(&buffer) != authfile_id_string[i]) {
                         debug("Bad key file %.200s.", filename);                          debug3("Bad RSA1 key file %.200s.", filename);
                         buffer_free(&buffer);                          buffer_free(&buffer);
                         return 0;                          return 0;
                 }                  }
Line 342 
Line 370 
                 xfree(buffer_get_string(&buffer, NULL));                  xfree(buffer_get_string(&buffer, NULL));
   
         /* Check that it is a supported cipher. */          /* Check that it is a supported cipher. */
         if (((cipher_mask1() | SSH_CIPHER_NONE | SSH_AUTHFILE_CIPHER) &          cipher = cipher_by_number(cipher_type);
              (1 << cipher_type)) == 0) {          if (cipher == NULL) {
                 debug("Unsupported cipher %.100s used in key file %.200s.",                  debug("Unsupported cipher %d used in key file %.200s.",
                       cipher_name(cipher_type), filename);                      cipher_type, filename);
                 buffer_free(&buffer);                  buffer_free(&buffer);
                 goto fail;                  goto fail;
         }          }
Line 354 
Line 382 
         buffer_append_space(&decrypted, &cp, buffer_len(&buffer));          buffer_append_space(&decrypted, &cp, buffer_len(&buffer));
   
         /* Rest of the buffer is encrypted.  Decrypt it using the passphrase. */          /* Rest of the buffer is encrypted.  Decrypt it using the passphrase. */
         cipher_set_key_string(&cipher, cipher_type, passphrase);          cipher_set_key_string(&ciphercontext, cipher, passphrase);
         cipher_decrypt(&cipher, (unsigned char *) cp,          cipher_decrypt(&ciphercontext, (u_char *) cp,
                        (unsigned char *) buffer_ptr(&buffer),              (u_char *) buffer_ptr(&buffer), buffer_len(&buffer));
                        buffer_len(&buffer));          memset(&ciphercontext, 0, sizeof(ciphercontext));
   
         buffer_free(&buffer);          buffer_free(&buffer);
   
         check1 = buffer_get_char(&decrypted);          check1 = buffer_get_char(&decrypted);
Line 409 
Line 436 
 }  }
   
 int  int
 load_private_key_dsa(int fd, const char *passphrase, Key *k, char **comment_return)  load_private_key_ssh2(int fd, const char *passphrase, Key *k, char **comment_return)
 {  {
         DSA *dsa;  
         BIO *in;  
         FILE *fp;          FILE *fp;
           int success = 0;
           EVP_PKEY *pk = NULL;
           char *name = "<no key>";
   
         in = BIO_new(BIO_s_file());  
         if (in == NULL) {  
                 error("BIO_new failed");  
                 return 0;  
         }  
         fp = fdopen(fd, "r");          fp = fdopen(fd, "r");
         if (fp == NULL) {          if (fp == NULL) {
                 error("fdopen failed");                  error("fdopen failed");
                 return 0;                  return 0;
         }          }
         BIO_set_fp(in, fp, BIO_NOCLOSE);          pk = PEM_read_PrivateKey(fp, NULL, NULL, (char *)passphrase);
         dsa = PEM_read_bio_DSAPrivateKey(in, NULL, NULL, (char *)passphrase);          if (pk == NULL) {
         if (dsa == NULL) {                  debug("PEM_read_PrivateKey failed");
                 debug("PEM_read_bio_DSAPrivateKey failed");                  (void)ERR_get_error();
         } else {          } else if (pk->type == EVP_PKEY_RSA) {
                   /* replace k->rsa with loaded key */
                   if (k->type == KEY_RSA || k->type == KEY_UNSPEC) {
                           if (k->rsa != NULL)
                                   RSA_free(k->rsa);
                           k->rsa = EVP_PKEY_get1_RSA(pk);
                           k->type = KEY_RSA;
                           name = "rsa w/o comment";
                           success = 1;
   #ifdef DEBUG_PK
                           RSA_print_fp(stderr, k->rsa, 8);
   #endif
                   }
           } else if (pk->type == EVP_PKEY_DSA) {
                 /* replace k->dsa with loaded key */                  /* replace k->dsa with loaded key */
                 DSA_free(k->dsa);                  if (k->type == KEY_DSA || k->type == KEY_UNSPEC) {
                 k->dsa = dsa;                          if (k->dsa != NULL)
                                   DSA_free(k->dsa);
                           k->dsa = EVP_PKEY_get1_DSA(pk);
                           k->type = KEY_DSA;
                           name = "dsa w/o comment";
   #ifdef DEBUG_PK
                           DSA_print_fp(stderr, k->dsa, 8);
   #endif
                           success = 1;
                   }
           } else {
                   error("PEM_read_PrivateKey: mismatch or "
                       "unknown EVP_PKEY save_type %d", pk->save_type);
         }          }
         BIO_free(in);  
         fclose(fp);          fclose(fp);
         if (comment_return)          if (pk != NULL)
                 *comment_return = xstrdup("dsa w/o comment");                  EVP_PKEY_free(pk);
         debug("read DSA private key done");          if (success && comment_return)
 #ifdef DEBUG_DSS                  *comment_return = xstrdup(name);
         DSA_print_fp(stderr, dsa, 8);          debug("read SSH2 private key done: name %s success %d", name, success);
 #endif          return success;
         return dsa != NULL ? 1 : 0;  
 }  }
   
 int  int
Line 459 
Line 505 
   
         /* check owner and modes */          /* check owner and modes */
         if (fstat(fd, &st) < 0 ||          if (fstat(fd, &st) < 0 ||
             (st.st_uid != 0 && st.st_uid != getuid()) ||              (st.st_uid != 0 && getuid() != 0 && st.st_uid != getuid()) ||
             (st.st_mode & 077) != 0) {              (st.st_mode & 077) != 0) {
                 close(fd);                  close(fd);
                 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");                  error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
Line 471 
Line 517 
                 return 0;                  return 0;
         }          }
         switch (key->type) {          switch (key->type) {
         case KEY_RSA:          case KEY_RSA1:
                 if (key->rsa->e != NULL) {                  if (key->rsa->e != NULL) {
                         BN_clear_free(key->rsa->e);                          BN_clear_free(key->rsa->e);
                         key->rsa->e = NULL;                          key->rsa->e = NULL;
Line 480 
Line 526 
                         BN_clear_free(key->rsa->n);                          BN_clear_free(key->rsa->n);
                         key->rsa->n = NULL;                          key->rsa->n = NULL;
                 }                  }
                 ret = load_private_key_rsa(fd, filename, passphrase,                  ret = load_private_key_rsa1(fd, filename, passphrase,
                      key->rsa, comment_return);                       key->rsa, comment_return);
                 break;                  break;
         case KEY_DSA:          case KEY_DSA:
                 ret = load_private_key_dsa(fd, passphrase, key, comment_return);          case KEY_RSA:
           case KEY_UNSPEC:
                   ret = load_private_key_ssh2(fd, passphrase, key, comment_return);
         default:          default:
                 break;                  break;
         }          }
         close(fd);          close(fd);
         return ret;          return ret;
   }
   
   int
   do_load_public_key(const char *filename, Key *k, char **commentp)
   {
           FILE *f;
           char line[1024];
           char *cp;
   
           f = fopen(filename, "r");
           if (f != NULL) {
                   while (fgets(line, sizeof(line), f)) {
                           line[sizeof(line)-1] = '\0';
                           cp = line;
                           switch(*cp){
                           case '#':
                           case '\n':
                           case '\0':
                                   continue;
                           }
                           /* Skip leading whitespace. */
                           for (; *cp && (*cp == ' ' || *cp == '\t'); cp++)
                                   ;
                           if (*cp) {
                                   if (key_read(k, &cp) == 1) {
                                           if (commentp)
                                                   *commentp=xstrdup(filename);
                                           fclose(f);
                                           return 1;
                                   }
                           }
                   }
                   fclose(f);
           }
           return 0;
   }
   
   /* load public key from pubkey file */
   int
   try_load_public_key(const char *filename, Key *k, char **commentp)
   {
           char pub[MAXPATHLEN];
   
           if (do_load_public_key(filename, k, commentp) == 1)
                   return 1;
           if (strlcpy(pub, filename, sizeof pub) >= MAXPATHLEN)
                   return 0;
           if (strlcat(pub, ".pub", sizeof pub) >= MAXPATHLEN)
                   return 0;
           if (do_load_public_key(pub, k, commentp) == 1)
                   return 1;
           return 0;
 }  }
Legend:
Removed from v.1.16  
changed lines
  Added in v.1.16.2.3