authfile.c

   1 /*
   2  * Author: Tatu Ylonen <ylo@cs.hut.fi>
   3  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
   4  *                    All rights reserved
   5  * This file contains functions for reading and writing identity files, and
   6  * for reading the passphrase from the user.
   7  *
   8  * As far as I am concerned, the code I have written for this software
   9  * can be used freely for any purpose.  Any derived versions of this
  10  * software must be clearly marked as such, and if the derived work is
  11  * incompatible with the protocol description in the RFC file, it must be
  12  * called by a name other than "ssh" or "Secure Shell".
  13  *
  14  *
  15  * Copyright (c) 2000 Markus Friedl.  All rights reserved.
  16  *
  17  * Redistribution and use in source and binary forms, with or without
  18  * modification, are permitted provided that the following conditions
  19  * are met:
  20  * 1. Redistributions of source code must retain the above copyright
  21  *    notice, this list of conditions and the following disclaimer.
  22  * 2. Redistributions in binary form must reproduce the above copyright
  23  *    notice, this list of conditions and the following disclaimer in the
  24  *    documentation and/or other materials provided with the distribution.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  27  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  28  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  29  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  30  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  31  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  32  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  33  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  35  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  */
  37
  38 #include "includes.h"
  39 RCSID("$OpenBSD: authfile.c,v 1.19 2000/09/07 20:27:49 deraadt Exp $");
  40
  41 #include <openssl/bn.h>
  42 #include <openssl/dsa.h>
  43 #include <openssl/rsa.h>
  44 #include <openssl/pem.h>
  45 #include <openssl/evp.h>
  46
  47 #include "xmalloc.h"
  48 #include "buffer.h"
  49 #include "bufaux.h"
  50 #include "cipher.h"
  51 #include "ssh.h"
  52 #include "key.h"
  53
  54 /* Version identification string for identity files. */
  55 #define AUTHFILE_ID_STRING "SSH PRIVATE KEY FILE FORMAT 1.1\n"
  56
  57 /*
  58  * Saves the authentication (private) key in a file, encrypting it with
  59  * passphrase.  The identification of the file (lowest 64 bits of n) will
  60  * precede the key to provide identification of the key without needing a
  61  * passphrase.
  62  */
  63
  64 int
  65 save_private_key_rsa(const char *filename, const char *passphrase,
  66     RSA *key, const char *comment)
  67 {
  68         Buffer buffer, encrypted;
  69         char buf[100], *cp;
  70         int fd, i;
  71         CipherContext cipher;
  72         int cipher_type;
  73         u_int32_t rand;
  74
  75         /*
  76          * If the passphrase is empty, use SSH_CIPHER_NONE to ease converting
  77          * to another cipher; otherwise use SSH_AUTHFILE_CIPHER.
  78          */
  79         if (strcmp(passphrase, "") == 0)
  80                 cipher_type = SSH_CIPHER_NONE;
  81         else
  82                 cipher_type = SSH_AUTHFILE_CIPHER;
  83
  84         /* This buffer is used to built the secret part of the private key. */
  85         buffer_init(&buffer);
  86
  87         /* Put checkbytes for checking passphrase validity. */
  88         rand = arc4random();
  89         buf[0] = rand & 0xff;
  90         buf[1] = (rand >> 8) & 0xff;
  91         buf[2] = buf[0];
  92         buf[3] = buf[1];
  93         buffer_append(&buffer, buf, 4);
  94
  95         /*
  96          * Store the private key (n and e will not be stored because they
  97          * will be stored in plain text, and storing them also in encrypted
  98          * format would just give known plaintext).
  99          */
 100         buffer_put_bignum(&buffer, key->d);
 101         buffer_put_bignum(&buffer, key->iqmp);
 102         buffer_put_bignum(&buffer, key->q);     /* reverse from SSL p */
 103         buffer_put_bignum(&buffer, key->p);     /* reverse from SSL q */
 104
 105         /* Pad the part to be encrypted until its size is a multiple of 8. */
 106         while (buffer_len(&buffer) % 8 != 0)
 107                 buffer_put_char(&buffer, 0);
 108
 109         /* This buffer will be used to contain the data in the file. */
 110         buffer_init(&encrypted);
 111
 112         /* First store keyfile id string. */
 113         cp = AUTHFILE_ID_STRING;
 114         for (i = 0; cp[i]; i++)
 115                 buffer_put_char(&encrypted, cp[i]);
 116         buffer_put_char(&encrypted, 0);
 117
 118         /* Store cipher type. */
 119         buffer_put_char(&encrypted, cipher_type);
 120         buffer_put_int(&encrypted, 0);  /* For future extension */
 121
 122         /* Store public key.  This will be in plain text. */
 123         buffer_put_int(&encrypted, BN_num_bits(key->n));
 124         buffer_put_bignum(&encrypted, key->n);
 125         buffer_put_bignum(&encrypted, key->e);
 126         buffer_put_string(&encrypted, comment, strlen(comment));
 127
 128         /* Allocate space for the private part of the key in the buffer. */
 129         buffer_append_space(&encrypted, &cp, buffer_len(&buffer));
 130
 131         cipher_set_key_string(&cipher, cipher_type, passphrase);
 132         cipher_encrypt(&cipher, (unsigned char *) cp,
 133                        (unsigned char *) buffer_ptr(&buffer),
 134                        buffer_len(&buffer));
 135         memset(&cipher, 0, sizeof(cipher));
 136
 137         /* Destroy temporary data. */
 138         memset(buf, 0, sizeof(buf));
 139         buffer_free(&buffer);
 140
 141         fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0600);
 142         if (fd < 0)
 143                 return 0;
 144         if (write(fd, buffer_ptr(&encrypted), buffer_len(&encrypted)) !=
 145             buffer_len(&encrypted)) {
 146                 debug("Write to key file %.200s failed: %.100s", filename,
 147                       strerror(errno));
 148                 buffer_free(&encrypted);
 149                 close(fd);
 150                 remove(filename);
 151                 return 0;
 152         }
 153         close(fd);
 154         buffer_free(&encrypted);
 155         return 1;
 156 }
 157
 158 /* save DSA key in OpenSSL PEM format */
 159
 160 int
 161 save_private_key_dsa(const char *filename, const char *passphrase,
 162     DSA *dsa, const char *comment)
 163 {
 164         FILE *fp;
 165         int fd;
 166         int success = 1;
 167         int len = strlen(passphrase);
 168
 169         if (len > 0 && len <= 4) {
 170                 error("passphrase too short: %d bytes", len);
 171                 errno = 0;
 172                 return 0;
 173         }
 174         fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0600);
 175         if (fd < 0) {
 176                 debug("open %s failed", filename);
 177                 return 0;
 178         }
 179         fp = fdopen(fd, "w");
 180         if (fp == NULL ) {
 181                 debug("fdopen %s failed", filename);
 182                 close(fd);
 183                 return 0;
 184         }
 185         if (len > 0) {
 186                 if (!PEM_write_DSAPrivateKey(fp, dsa, EVP_des_ede3_cbc(),
 187                     (char *)passphrase, strlen(passphrase), NULL, NULL))
 188                         success = 0;
 189         } else {
 190                 if (!PEM_write_DSAPrivateKey(fp, dsa, NULL,
 191                     NULL, 0, NULL, NULL))
 192                         success = 0;
 193         }
 194         fclose(fp);
 195         return success;
 196 }
 197
 198 int
 199 save_private_key(const char *filename, const char *passphrase, Key *key,
 200     const char *comment)
 201 {
 202         switch (key->type) {
 203         case KEY_RSA:
 204                 return save_private_key_rsa(filename, passphrase, key->rsa, comment);
 205                 break;
 206         case KEY_DSA:
 207                 return save_private_key_dsa(filename, passphrase, key->dsa, comment);
 208                 break;
 209         default:
 210                 break;
 211         }
 212         return 0;
 213 }
 214
 215 /*
 216  * Loads the public part of the key file.  Returns 0 if an error was
 217  * encountered (the file does not exist or is not readable), and non-zero
 218  * otherwise.
 219  */
 220
 221 int
 222 load_public_key_rsa(const char *filename, RSA * pub, char **comment_return)
 223 {
 224         int fd, i;
 225         off_t len;
 226         Buffer buffer;
 227         char *cp;
 228
 229         fd = open(filename, O_RDONLY);
 230         if (fd < 0)
 231                 return 0;
 232         len = lseek(fd, (off_t) 0, SEEK_END);
 233         lseek(fd, (off_t) 0, SEEK_SET);
 234
 235         buffer_init(&buffer);
 236         buffer_append_space(&buffer, &cp, len);
 237
 238         if (read(fd, cp, (size_t) len) != (size_t) len) {
 239                 debug("Read from key file %.200s failed: %.100s", filename,
 240                     strerror(errno));
 241                 buffer_free(&buffer);
 242                 close(fd);
 243                 return 0;
 244         }
 245         close(fd);
 246
 247         /* Check that it is at least big enought to contain the ID string. */
 248         if (len < strlen(AUTHFILE_ID_STRING) + 1) {
 249                 debug("Bad key file %.200s.", filename);
 250                 buffer_free(&buffer);
 251                 return 0;
 252         }
 253         /*
 254          * Make sure it begins with the id string.  Consume the id string
 255          * from the buffer.
 256          */
 257         for (i = 0; i < (unsigned int) strlen(AUTHFILE_ID_STRING) + 1; i++)
 258                 if (buffer_get_char(&buffer) != (u_char) AUTHFILE_ID_STRING[i]) {
 259                         debug("Bad key file %.200s.", filename);
 260                         buffer_free(&buffer);
 261                         return 0;
 262                 }
 263         /* Skip cipher type and reserved data. */
 264         (void) buffer_get_char(&buffer);        /* cipher type */
 265         (void) buffer_get_int(&buffer);         /* reserved */
 266
 267         /* Read the public key from the buffer. */
 268         buffer_get_int(&buffer);
 269         /* XXX alloc */
 270         if (pub->n == NULL)
 271                 pub->n = BN_new();
 272         buffer_get_bignum(&buffer, pub->n);
 273         /* XXX alloc */
 274         if (pub->e == NULL)
 275                 pub->e = BN_new();
 276         buffer_get_bignum(&buffer, pub->e);
 277         if (comment_return)
 278                 *comment_return = buffer_get_string(&buffer, NULL);
 279         /* The encrypted private part is not parsed by this function. */
 280
 281         buffer_free(&buffer);
 282
 283         return 1;
 284 }
 285
 286 /* load public key from private-key file */
 287 int
 288 load_public_key(const char *filename, Key * key, char **comment_return)
 289 {
 290         switch (key->type) {
 291         case KEY_RSA:
 292                 return load_public_key_rsa(filename, key->rsa, comment_return);
 293                 break;
 294         case KEY_DSA:
 295         default:
 296                 break;
 297         }
 298         return 0;
 299 }
 300
 301 /*
 302  * Loads the private key from the file.  Returns 0 if an error is encountered
 303  * (file does not exist or is not readable, or passphrase is bad). This
 304  * initializes the private key.
 305  * Assumes we are called under uid of the owner of the file.
 306  */
 307
 308 int
 309 load_private_key_rsa(int fd, const char *filename,
 310     const char *passphrase, RSA * prv, char **comment_return)
 311 {
 312         int i, check1, check2, cipher_type;
 313         off_t len;
 314         Buffer buffer, decrypted;
 315         char *cp;
 316         CipherContext cipher;
 317         BN_CTX *ctx;
 318         BIGNUM *aux;
 319
 320         len = lseek(fd, (off_t) 0, SEEK_END);
 321         lseek(fd, (off_t) 0, SEEK_SET);
 322
 323         buffer_init(&buffer);
 324         buffer_append_space(&buffer, &cp, len);
 325
 326         if (read(fd, cp, (size_t) len) != (size_t) len) {
 327                 debug("Read from key file %.200s failed: %.100s", filename,
 328                       strerror(errno));
 329                 buffer_free(&buffer);
 330                 close(fd);
 331                 return 0;
 332         }
 333         close(fd);
 334
 335         /* Check that it is at least big enought to contain the ID string. */
 336         if (len < strlen(AUTHFILE_ID_STRING) + 1) {
 337                 debug("Bad key file %.200s.", filename);
 338                 buffer_free(&buffer);
 339                 return 0;
 340         }
 341         /*
 342          * Make sure it begins with the id string.  Consume the id string
 343          * from the buffer.
 344          */
 345         for (i = 0; i < (unsigned int) strlen(AUTHFILE_ID_STRING) + 1; i++)
 346                 if (buffer_get_char(&buffer) != (unsigned char) AUTHFILE_ID_STRING[i]) {
 347                         debug("Bad key file %.200s.", filename);
 348                         buffer_free(&buffer);
 349                         return 0;
 350                 }
 351         /* Read cipher type. */
 352         cipher_type = buffer_get_char(&buffer);
 353         (void) buffer_get_int(&buffer); /* Reserved data. */
 354
 355         /* Read the public key from the buffer. */
 356         buffer_get_int(&buffer);
 357         prv->n = BN_new();
 358         buffer_get_bignum(&buffer, prv->n);
 359         prv->e = BN_new();
 360         buffer_get_bignum(&buffer, prv->e);
 361         if (comment_return)
 362                 *comment_return = buffer_get_string(&buffer, NULL);
 363         else
 364                 xfree(buffer_get_string(&buffer, NULL));
 365
 366         /* Check that it is a supported cipher. */
 367         if (((cipher_mask1() | SSH_CIPHER_NONE | SSH_AUTHFILE_CIPHER) &
 368              (1 << cipher_type)) == 0) {
 369                 debug("Unsupported cipher %.100s used in key file %.200s.",
 370                       cipher_name(cipher_type), filename);
 371                 buffer_free(&buffer);
 372                 goto fail;
 373         }
 374         /* Initialize space for decrypted data. */
 375         buffer_init(&decrypted);
 376         buffer_append_space(&decrypted, &cp, buffer_len(&buffer));
 377
 378         /* Rest of the buffer is encrypted.  Decrypt it using the passphrase. */
 379         cipher_set_key_string(&cipher, cipher_type, passphrase);
 380         cipher_decrypt(&cipher, (unsigned char *) cp,
 381                        (unsigned char *) buffer_ptr(&buffer),
 382                        buffer_len(&buffer));
 383
 384         buffer_free(&buffer);
 385
 386         check1 = buffer_get_char(&decrypted);
 387         check2 = buffer_get_char(&decrypted);
 388         if (check1 != buffer_get_char(&decrypted) ||
 389             check2 != buffer_get_char(&decrypted)) {
 390                 if (strcmp(passphrase, "") != 0)
 391                         debug("Bad passphrase supplied for key file %.200s.", filename);
 392                 /* Bad passphrase. */
 393                 buffer_free(&decrypted);
 394 fail:
 395                 BN_clear_free(prv->n);
 396                 prv->n = NULL;
 397                 BN_clear_free(prv->e);
 398                 prv->e = NULL;
 399                 if (comment_return)
 400                         xfree(*comment_return);
 401                 return 0;
 402         }
 403         /* Read the rest of the private key. */
 404         prv->d = BN_new();
 405         buffer_get_bignum(&decrypted, prv->d);
 406         prv->iqmp = BN_new();
 407         buffer_get_bignum(&decrypted, prv->iqmp);       /* u */
 408         /* in SSL and SSH p and q are exchanged */
 409         prv->q = BN_new();
 410         buffer_get_bignum(&decrypted, prv->q);          /* p */
 411         prv->p = BN_new();
 412         buffer_get_bignum(&decrypted, prv->p);          /* q */
 413
 414         ctx = BN_CTX_new();
 415         aux = BN_new();
 416
 417         BN_sub(aux, prv->q, BN_value_one());
 418         prv->dmq1 = BN_new();
 419         BN_mod(prv->dmq1, prv->d, aux, ctx);
 420
 421         BN_sub(aux, prv->p, BN_value_one());
 422         prv->dmp1 = BN_new();
 423         BN_mod(prv->dmp1, prv->d, aux, ctx);
 424
 425         BN_clear_free(aux);
 426         BN_CTX_free(ctx);
 427
 428         buffer_free(&decrypted);
 429
 430         return 1;
 431 }
 432
 433 int
 434 load_private_key_dsa(int fd, const char *passphrase, Key *k, char **comment_return)
 435 {
 436         DSA *dsa;
 437         BIO *in;
 438         FILE *fp;
 439
 440         in = BIO_new(BIO_s_file());
 441         if (in == NULL) {
 442                 error("BIO_new failed");
 443                 return 0;
 444         }
 445         fp = fdopen(fd, "r");
 446         if (fp == NULL) {
 447                 error("fdopen failed");
 448                 return 0;
 449         }
 450         BIO_set_fp(in, fp, BIO_NOCLOSE);
 451         dsa = PEM_read_bio_DSAPrivateKey(in, NULL, NULL, (char *)passphrase);
 452         if (dsa == NULL) {
 453                 debug("PEM_read_bio_DSAPrivateKey failed");
 454         } else {
 455                 /* replace k->dsa with loaded key */
 456                 DSA_free(k->dsa);
 457                 k->dsa = dsa;
 458         }
 459         BIO_free(in);
 460         fclose(fp);
 461         if (comment_return)
 462                 *comment_return = xstrdup("dsa w/o comment");
 463         debug("read DSA private key done");
 464 #ifdef DEBUG_DSS
 465         DSA_print_fp(stderr, dsa, 8);
 466 #endif
 467         return dsa != NULL ? 1 : 0;
 468 }
 469
 470 int
 471 load_private_key(const char *filename, const char *passphrase, Key *key,
 472     char **comment_return)
 473 {
 474         int fd;
 475         int ret = 0;
 476         struct stat st;
 477
 478         fd = open(filename, O_RDONLY);
 479         if (fd < 0)
 480                 return 0;
 481
 482 #ifndef HAVE_CYGWIN
 483         /*
 484          * check owner and modes.
 485          * This won't work on Windows under all circumstances so we drop
 486          * that check for now.
 487          */
 488         if (fstat(fd, &st) < 0 ||
 489             (st.st_uid != 0 && st.st_uid != getuid()) ||
 490             (st.st_mode & 077) != 0) {
 491                 close(fd);
 492                 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
 493                 error("@         WARNING: UNPROTECTED PRIVATE KEY FILE!          @");
 494                 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
 495                 error("Bad ownership or mode(0%3.3o) for '%s'.",
 496                       st.st_mode & 0777, filename);
 497                 error("It is recommended that your private key files are NOT accessible by others.");
 498                 return 0;
 499         }
 500 #endif
 501         switch (key->type) {
 502         case KEY_RSA:
 503                 if (key->rsa->e != NULL) {
 504                         BN_clear_free(key->rsa->e);
 505                         key->rsa->e = NULL;
 506                 }
 507                 if (key->rsa->n != NULL) {
 508                         BN_clear_free(key->rsa->n);
 509                         key->rsa->n = NULL;
 510                 }
 511                 ret = load_private_key_rsa(fd, filename, passphrase,
 512                      key->rsa, comment_return);
 513                 break;
 514         case KEY_DSA:
 515                 ret = load_private_key_dsa(fd, passphrase, key, comment_return);
 516         default:
 517                 break;
 518         }
 519         close(fd);
 520         return ret;
 521 }
 522
 523 int
 524 do_load_public_key(const char *filename, Key *k, char **commentp)
 525 {
 526         FILE *f;
 527         unsigned int bits;
 528         char line[1024];
 529         char *cp;
 530
 531         f = fopen(filename, "r");
 532         if (f != NULL) {
 533                 while (fgets(line, sizeof(line), f)) {
 534                         line[sizeof(line)-1] = '\0';
 535                         cp = line;
 536                         switch(*cp){
 537                         case '#':
 538                         case '\n':
 539                         case '\0':
 540                                 continue;
 541                         }
 542                         /* Skip leading whitespace. */
 543                         for (; *cp && (*cp == ' ' || *cp == '\t'); cp++)
 544                                 ;
 545                         if (*cp) {
 546                                 bits = key_read(k, &cp);
 547                                 if (bits != 0) {
 548                                         if (commentp)
 549                                                 *commentp=xstrdup(filename);
 550                                         fclose(f);
 551                                         return 1;
 552                                 }
 553                         }
 554                 }
 555                 fclose(f);
 556         }
 557         return 0;
 558 }
 559
 560 /* load public key from pubkey file */
 561 int
 562 try_load_public_key(const char *filename, Key *k, char **commentp)
 563 {
 564         char pub[MAXPATHLEN];
 565
 566         if (do_load_public_key(filename, k, commentp) == 1)
 567                 return 1;
 568         if (strlcpy(pub, filename, sizeof pub) >= MAXPATHLEN)
 569                 return 0;
 570         if (strlcat(pub, ".pub", sizeof pub) >= MAXPATHLEN)
 571                 return 0;
 572         if (do_load_public_key(pub, k, commentp) == 1)
 573                 return 1;
 574         return 0;
 575 }