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
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42
  43 #include <openssl/err.h>
  44 #include <openssl/evp.h>
  45 #include <openssl/pem.h>
  46
  47 #include "cipher.h"
  48 #include "xmalloc.h"
  49 #include "buffer.h"
  50 #include "bufaux.h"
  51 #include "key.h"
  52 #include "ssh.h"
  53 #include "log.h"
  54 #include "authfile.h"
  55 #include "rsa.h"
  56 #include "misc.h"
  57 #include "atomicio.h"
  58
  59 /* Version identification string for SSH v1 identity files. */
  60 static const char authfile_id_string[] =
  61     "SSH PRIVATE KEY FILE FORMAT 1.1\n";
  62
  63 /*
  64  * Saves the authentication (private) key in a file, encrypting it with
  65  * passphrase.  The identification of the file (lowest 64 bits of n) will
  66  * precede the key to provide identification of the key without needing a
  67  * passphrase.
  68  */
  69
  70 static int
  71 key_save_private_rsa1(Key *key, const char *filename, const char *passphrase,
  72     const char *comment)
  73 {
  74         Buffer buffer, encrypted;
  75         u_char buf[100], *cp;
  76         int fd, i, cipher_num;
  77         CipherContext ciphercontext;
  78         Cipher *cipher;
  79         u_int32_t rnd;
  80
  81         /*
  82          * If the passphrase is empty, use SSH_CIPHER_NONE to ease converting
  83          * to another cipher; otherwise use SSH_AUTHFILE_CIPHER.
  84          */
  85         cipher_num = (strcmp(passphrase, "") == 0) ?
  86             SSH_CIPHER_NONE : SSH_AUTHFILE_CIPHER;
  87         if ((cipher = cipher_by_number(cipher_num)) == NULL)
  88                 fatal("save_private_key_rsa: bad cipher");
  89
  90         /* This buffer is used to built the secret part of the private key. */
  91         buffer_init(&buffer);
  92
  93         /* Put checkbytes for checking passphrase validity. */
  94         rnd = arc4random();
  95         buf[0] = rnd & 0xff;
  96         buf[1] = (rnd >> 8) & 0xff;
  97         buf[2] = buf[0];
  98         buf[3] = buf[1];
  99         buffer_append(&buffer, buf, 4);
 100
 101         /*
 102          * Store the private key (n and e will not be stored because they
 103          * will be stored in plain text, and storing them also in encrypted
 104          * format would just give known plaintext).
 105          */
 106         buffer_put_bignum(&buffer, key->rsa->d);
 107         buffer_put_bignum(&buffer, key->rsa->iqmp);
 108         buffer_put_bignum(&buffer, key->rsa->q);        /* reverse from SSL p */
 109         buffer_put_bignum(&buffer, key->rsa->p);        /* reverse from SSL q */
 110
 111         /* Pad the part to be encrypted until its size is a multiple of 8. */
 112         while (buffer_len(&buffer) % 8 != 0)
 113                 buffer_put_char(&buffer, 0);
 114
 115         /* This buffer will be used to contain the data in the file. */
 116         buffer_init(&encrypted);
 117
 118         /* First store keyfile id string. */
 119         for (i = 0; authfile_id_string[i]; i++)
 120                 buffer_put_char(&encrypted, authfile_id_string[i]);
 121         buffer_put_char(&encrypted, 0);
 122
 123         /* Store cipher type. */
 124         buffer_put_char(&encrypted, cipher_num);
 125         buffer_put_int(&encrypted, 0);  /* For future extension */
 126
 127         /* Store public key.  This will be in plain text. */
 128         buffer_put_int(&encrypted, BN_num_bits(key->rsa->n));
 129         buffer_put_bignum(&encrypted, key->rsa->n);
 130         buffer_put_bignum(&encrypted, key->rsa->e);
 131         buffer_put_cstring(&encrypted, comment);
 132
 133         /* Allocate space for the private part of the key in the buffer. */
 134         cp = buffer_append_space(&encrypted, buffer_len(&buffer));
 135
 136         cipher_set_key_string(&ciphercontext, cipher, passphrase,
 137             CIPHER_ENCRYPT);
 138         cipher_crypt(&ciphercontext, cp,
 139             buffer_ptr(&buffer), buffer_len(&buffer));
 140         cipher_cleanup(&ciphercontext);
 141         memset(&ciphercontext, 0, sizeof(ciphercontext));
 142
 143         /* Destroy temporary data. */
 144         memset(buf, 0, sizeof(buf));
 145         buffer_free(&buffer);
 146
 147         fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0600);
 148         if (fd < 0) {
 149                 error("open %s failed: %s.", filename, strerror(errno));
 150                 buffer_free(&encrypted);
 151                 return 0;
 152         }
 153         if (atomicio(vwrite, fd, buffer_ptr(&encrypted),
 154             buffer_len(&encrypted)) != buffer_len(&encrypted)) {
 155                 error("write to key file %s failed: %s", filename,
 156                     strerror(errno));
 157                 buffer_free(&encrypted);
 158                 close(fd);
 159                 unlink(filename);
 160                 return 0;
 161         }
 162         close(fd);
 163         buffer_free(&encrypted);
 164         return 1;
 165 }
 166
 167 /* save SSH v2 key in OpenSSL PEM format */
 168 static int
 169 key_save_private_pem(Key *key, const char *filename, const char *_passphrase,
 170     const char *comment)
 171 {
 172         FILE *fp;
 173         int fd;
 174         int success = 0;
 175         int len = strlen(_passphrase);
 176         u_char *passphrase = (len > 0) ? (u_char *)_passphrase : NULL;
 177         const EVP_CIPHER *cipher = (len > 0) ? EVP_des_ede3_cbc() : NULL;
 178
 179         if (len > 0 && len <= 4) {
 180                 error("passphrase too short: have %d bytes, need > 4", len);
 181                 return 0;
 182         }
 183         fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0600);
 184         if (fd < 0) {
 185                 error("open %s failed: %s.", filename, strerror(errno));
 186                 return 0;
 187         }
 188         fp = fdopen(fd, "w");
 189         if (fp == NULL ) {
 190                 error("fdopen %s failed: %s.", filename, strerror(errno));
 191                 close(fd);
 192                 return 0;
 193         }
 194         switch (key->type) {
 195         case KEY_DSA:
 196                 success = PEM_write_DSAPrivateKey(fp, key->dsa,
 197                     cipher, passphrase, len, NULL, NULL);
 198                 break;
 199         case KEY_RSA:
 200                 success = PEM_write_RSAPrivateKey(fp, key->rsa,
 201                     cipher, passphrase, len, NULL, NULL);
 202                 break;
 203         }
 204         fclose(fp);
 205         return success;
 206 }
 207
 208 int
 209 key_save_private(Key *key, const char *filename, const char *passphrase,
 210     const char *comment)
 211 {
 212         switch (key->type) {
 213         case KEY_RSA1:
 214                 return key_save_private_rsa1(key, filename, passphrase,
 215                     comment);
 216                 break;
 217         case KEY_DSA:
 218         case KEY_RSA:
 219                 return key_save_private_pem(key, filename, passphrase,
 220                     comment);
 221                 break;
 222         default:
 223                 break;
 224         }
 225         error("key_save_private: cannot save key type %d", key->type);
 226         return 0;
 227 }
 228
 229 /*
 230  * Loads the public part of the ssh v1 key file.  Returns NULL if an error was
 231  * encountered (the file does not exist or is not readable), and the key
 232  * otherwise.
 233  */
 234
 235 static Key *
 236 key_load_public_rsa1(int fd, const char *filename, char **commentp)
 237 {
 238         Buffer buffer;
 239         Key *pub;
 240         struct stat st;
 241         char *cp;
 242         u_int i;
 243         size_t len;
 244
 245         if (fstat(fd, &st) < 0) {
 246                 error("fstat for key file %.200s failed: %.100s",
 247                     filename, strerror(errno));
 248                 return NULL;
 249         }
 250         if (st.st_size > 1*1024*1024) {
 251                 error("key file %.200s too large", filename);
 252                 return NULL;
 253         }
 254         len = (size_t)st.st_size;               /* truncated */
 255
 256         buffer_init(&buffer);
 257         cp = buffer_append_space(&buffer, len);
 258
 259         if (atomicio(read, fd, cp, len) != len) {
 260                 debug("Read from key file %.200s failed: %.100s", filename,
 261                     strerror(errno));
 262                 buffer_free(&buffer);
 263                 return NULL;
 264         }
 265
 266         /* Check that it is at least big enough to contain the ID string. */
 267         if (len < sizeof(authfile_id_string)) {
 268                 debug3("Not a RSA1 key file %.200s.", filename);
 269                 buffer_free(&buffer);
 270                 return NULL;
 271         }
 272         /*
 273          * Make sure it begins with the id string.  Consume the id string
 274          * from the buffer.
 275          */
 276         for (i = 0; i < sizeof(authfile_id_string); i++)
 277                 if (buffer_get_char(&buffer) != authfile_id_string[i]) {
 278                         debug3("Not a RSA1 key file %.200s.", filename);
 279                         buffer_free(&buffer);
 280                         return NULL;
 281                 }
 282         /* Skip cipher type and reserved data. */
 283         (void) buffer_get_char(&buffer);        /* cipher type */
 284         (void) buffer_get_int(&buffer);         /* reserved */
 285
 286         /* Read the public key from the buffer. */
 287         (void) buffer_get_int(&buffer);
 288         pub = key_new(KEY_RSA1);
 289         buffer_get_bignum(&buffer, pub->rsa->n);
 290         buffer_get_bignum(&buffer, pub->rsa->e);
 291         if (commentp)
 292                 *commentp = buffer_get_string(&buffer, NULL);
 293         /* The encrypted private part is not parsed by this function. */
 294
 295         buffer_free(&buffer);
 296         return pub;
 297 }
 298
 299 /* load public key from private-key file, works only for SSH v1 */
 300 Key *
 301 key_load_public_type(int type, const char *filename, char **commentp)
 302 {
 303         Key *pub;
 304         int fd;
 305
 306         if (type == KEY_RSA1) {
 307                 fd = open(filename, O_RDONLY);
 308                 if (fd < 0)
 309                         return NULL;
 310                 pub = key_load_public_rsa1(fd, filename, commentp);
 311                 close(fd);
 312                 return pub;
 313         }
 314         return NULL;
 315 }
 316
 317 /*
 318  * Loads the private key from the file.  Returns 0 if an error is encountered
 319  * (file does not exist or is not readable, or passphrase is bad). This
 320  * initializes the private key.
 321  * Assumes we are called under uid of the owner of the file.
 322  */
 323
 324 static Key *
 325 key_load_private_rsa1(int fd, const char *filename, const char *passphrase,
 326     char **commentp)
 327 {
 328         u_int i;
 329         int check1, check2, cipher_type;
 330         size_t len;
 331         Buffer buffer, decrypted;
 332         u_char *cp;
 333         CipherContext ciphercontext;
 334         Cipher *cipher;
 335         Key *prv = NULL;
 336         struct stat st;
 337
 338         if (fstat(fd, &st) < 0) {
 339                 error("fstat for key file %.200s failed: %.100s",
 340                     filename, strerror(errno));
 341                 close(fd);
 342                 return NULL;
 343         }
 344         if (st.st_size > 1*1024*1024) {
 345                 error("key file %.200s too large", filename);
 346                 close(fd);
 347                 return (NULL);
 348         }
 349         len = (size_t)st.st_size;               /* truncated */
 350
 351         buffer_init(&buffer);
 352         cp = buffer_append_space(&buffer, len);
 353
 354         if (atomicio(read, fd, cp, len) != len) {
 355                 debug("Read from key file %.200s failed: %.100s", filename,
 356                     strerror(errno));
 357                 buffer_free(&buffer);
 358                 close(fd);
 359                 return NULL;
 360         }
 361
 362         /* Check that it is at least big enough to contain the ID string. */
 363         if (len < sizeof(authfile_id_string)) {
 364                 debug3("Not a RSA1 key file %.200s.", filename);
 365                 buffer_free(&buffer);
 366                 close(fd);
 367                 return NULL;
 368         }
 369         /*
 370          * Make sure it begins with the id string.  Consume the id string
 371          * from the buffer.
 372          */
 373         for (i = 0; i < sizeof(authfile_id_string); i++)
 374                 if (buffer_get_char(&buffer) != authfile_id_string[i]) {
 375                         debug3("Not a RSA1 key file %.200s.", filename);
 376                         buffer_free(&buffer);
 377                         close(fd);
 378                         return NULL;
 379                 }
 380
 381         /* Read cipher type. */
 382         cipher_type = buffer_get_char(&buffer);
 383         (void) buffer_get_int(&buffer); /* Reserved data. */
 384
 385         /* Read the public key from the buffer. */
 386         (void) buffer_get_int(&buffer);
 387         prv = key_new_private(KEY_RSA1);
 388
 389         buffer_get_bignum(&buffer, prv->rsa->n);
 390         buffer_get_bignum(&buffer, prv->rsa->e);
 391         if (commentp)
 392                 *commentp = buffer_get_string(&buffer, NULL);
 393         else
 394                 xfree(buffer_get_string(&buffer, NULL));
 395
 396         /* Check that it is a supported cipher. */
 397         cipher = cipher_by_number(cipher_type);
 398         if (cipher == NULL) {
 399                 debug("Unsupported cipher %d used in key file %.200s.",
 400                     cipher_type, filename);
 401                 buffer_free(&buffer);
 402                 goto fail;
 403         }
 404         /* Initialize space for decrypted data. */
 405         buffer_init(&decrypted);
 406         cp = buffer_append_space(&decrypted, buffer_len(&buffer));
 407
 408         /* Rest of the buffer is encrypted.  Decrypt it using the passphrase. */
 409         cipher_set_key_string(&ciphercontext, cipher, passphrase,
 410             CIPHER_DECRYPT);
 411         cipher_crypt(&ciphercontext, cp,
 412             buffer_ptr(&buffer), buffer_len(&buffer));
 413         cipher_cleanup(&ciphercontext);
 414         memset(&ciphercontext, 0, sizeof(ciphercontext));
 415         buffer_free(&buffer);
 416
 417         check1 = buffer_get_char(&decrypted);
 418         check2 = buffer_get_char(&decrypted);
 419         if (check1 != buffer_get_char(&decrypted) ||
 420             check2 != buffer_get_char(&decrypted)) {
 421                 if (strcmp(passphrase, "") != 0)
 422                         debug("Bad passphrase supplied for key file %.200s.",
 423                             filename);
 424                 /* Bad passphrase. */
 425                 buffer_free(&decrypted);
 426                 goto fail;
 427         }
 428         /* Read the rest of the private key. */
 429         buffer_get_bignum(&decrypted, prv->rsa->d);
 430         buffer_get_bignum(&decrypted, prv->rsa->iqmp);          /* u */
 431         /* in SSL and SSH v1 p and q are exchanged */
 432         buffer_get_bignum(&decrypted, prv->rsa->q);             /* p */
 433         buffer_get_bignum(&decrypted, prv->rsa->p);             /* q */
 434
 435         /* calculate p-1 and q-1 */
 436         rsa_generate_additional_parameters(prv->rsa);
 437
 438         buffer_free(&decrypted);
 439
 440         /* enable blinding */
 441         if (RSA_blinding_on(prv->rsa, NULL) != 1) {
 442                 error("key_load_private_rsa1: RSA_blinding_on failed");
 443                 goto fail;
 444         }
 445         close(fd);
 446         return prv;
 447
 448 fail:
 449         if (commentp)
 450                 xfree(*commentp);
 451         close(fd);
 452         key_free(prv);
 453         return NULL;
 454 }
 455
 456 Key *
 457 key_load_private_pem(int fd, int type, const char *passphrase,
 458     char **commentp)
 459 {
 460         FILE *fp;
 461         EVP_PKEY *pk = NULL;
 462         Key *prv = NULL;
 463         char *name = "<no key>";
 464
 465         fp = fdopen(fd, "r");
 466         if (fp == NULL) {
 467                 error("fdopen failed: %s", strerror(errno));
 468                 close(fd);
 469                 return NULL;
 470         }
 471         pk = PEM_read_PrivateKey(fp, NULL, NULL, (char *)passphrase);
 472         if (pk == NULL) {
 473                 debug("PEM_read_PrivateKey failed");
 474                 (void)ERR_get_error();
 475         } else if (pk->type == EVP_PKEY_RSA &&
 476             (type == KEY_UNSPEC||type==KEY_RSA)) {
 477                 prv = key_new(KEY_UNSPEC);
 478                 prv->rsa = EVP_PKEY_get1_RSA(pk);
 479                 prv->type = KEY_RSA;
 480                 name = "rsa w/o comment";
 481 #ifdef DEBUG_PK
 482                 RSA_print_fp(stderr, prv->rsa, 8);
 483 #endif
 484                 if (RSA_blinding_on(prv->rsa, NULL) != 1) {
 485                         error("key_load_private_pem: RSA_blinding_on failed");
 486                         key_free(prv);
 487                         prv = NULL;
 488                 }
 489         } else if (pk->type == EVP_PKEY_DSA &&
 490             (type == KEY_UNSPEC||type==KEY_DSA)) {
 491                 prv = key_new(KEY_UNSPEC);
 492                 prv->dsa = EVP_PKEY_get1_DSA(pk);
 493                 prv->type = KEY_DSA;
 494                 name = "dsa w/o comment";
 495 #ifdef DEBUG_PK
 496                 DSA_print_fp(stderr, prv->dsa, 8);
 497 #endif
 498         } else {
 499                 error("PEM_read_PrivateKey: mismatch or "
 500                     "unknown EVP_PKEY save_type %d", pk->save_type);
 501         }
 502         fclose(fp);
 503         if (pk != NULL)
 504                 EVP_PKEY_free(pk);
 505         if (prv != NULL && commentp)
 506                 *commentp = xstrdup(name);
 507         debug("read PEM private key done: type %s",
 508             prv ? key_type(prv) : "<unknown>");
 509         return prv;
 510 }
 511
 512 int
 513 key_perm_ok(int fd, const char *filename)
 514 {
 515         struct stat st;
 516
 517         if (fstat(fd, &st) < 0)
 518                 return 0;
 519         /*
 520          * if a key owned by the user is accessed, then we check the
 521          * permissions of the file. if the key owned by a different user,
 522          * then we don't care.
 523          */
 524 #ifdef HAVE_CYGWIN
 525         if (check_ntsec(filename))
 526 #endif
 527         if ((st.st_uid == getuid()) && (st.st_mode & 077) != 0) {
 528                 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
 529                 error("@         WARNING: UNPROTECTED PRIVATE KEY FILE!          @");
 530                 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
 531                 error("Permissions 0%3.3o for '%s' are too open.",
 532                     (u_int)st.st_mode & 0777, filename);
 533                 error("It is recommended that your private key files are NOT accessible by others.");
 534                 error("This private key will be ignored.");
 535                 return 0;
 536         }
 537         return 1;
 538 }
 539
 540 Key *
 541 key_load_private_type(int type, const char *filename, const char *passphrase,
 542     char **commentp)
 543 {
 544         int fd;
 545
 546         fd = open(filename, O_RDONLY);
 547         if (fd < 0)
 548                 return NULL;
 549         if (!key_perm_ok(fd, filename)) {
 550                 error("bad permissions: ignore key: %s", filename);
 551                 close(fd);
 552                 return NULL;
 553         }
 554         switch (type) {
 555         case KEY_RSA1:
 556                 return key_load_private_rsa1(fd, filename, passphrase,
 557                     commentp);
 558                 /* closes fd */
 559                 break;
 560         case KEY_DSA:
 561         case KEY_RSA:
 562         case KEY_UNSPEC:
 563                 return key_load_private_pem(fd, type, passphrase, commentp);
 564                 /* closes fd */
 565                 break;
 566         default:
 567                 close(fd);
 568                 break;
 569         }
 570         return NULL;
 571 }
 572
 573 Key *
 574 key_load_private(const char *filename, const char *passphrase,
 575     char **commentp)
 576 {
 577         Key *pub, *prv;
 578         int fd;
 579
 580         fd = open(filename, O_RDONLY);
 581         if (fd < 0)
 582                 return NULL;
 583         if (!key_perm_ok(fd, filename)) {
 584                 error("bad permissions: ignore key: %s", filename);
 585                 close(fd);
 586                 return NULL;
 587         }
 588         pub = key_load_public_rsa1(fd, filename, commentp);
 589         lseek(fd, (off_t) 0, SEEK_SET);         /* rewind */
 590         if (pub == NULL) {
 591                 /* closes fd */
 592                 prv = key_load_private_pem(fd, KEY_UNSPEC, passphrase, NULL);
 593                 /* use the filename as a comment for PEM */
 594                 if (commentp && prv)
 595                         *commentp = xstrdup(filename);
 596         } else {
 597                 /* it's a SSH v1 key if the public key part is readable */
 598                 key_free(pub);
 599                 /* closes fd */
 600                 prv = key_load_private_rsa1(fd, filename, passphrase, NULL);
 601         }
 602         return prv;
 603 }
 604
 605 static int
 606 key_try_load_public(Key *k, const char *filename, char **commentp)
 607 {
 608         FILE *f;
 609         char line[SSH_MAX_PUBKEY_BYTES];
 610         char *cp;
 611         u_long linenum = 0;
 612
 613         f = fopen(filename, "r");
 614         if (f != NULL) {
 615                 while (read_keyfile_line(f, filename, line, sizeof(line),
 616                             &linenum) != -1) {
 617                         cp = line;
 618                         switch (*cp) {
 619                         case '#':
 620                         case '\n':
 621                         case '\0':
 622                                 continue;
 623                         }
 624                         /* Skip leading whitespace. */
 625                         for (; *cp && (*cp == ' ' || *cp == '\t'); cp++)
 626                                 ;
 627                         if (*cp) {
 628                                 if (key_read(k, &cp) == 1) {
 629                                         if (commentp)
 630                                                 *commentp=xstrdup(filename);
 631                                         fclose(f);
 632                                         return 1;
 633                                 }
 634                         }
 635                 }
 636                 fclose(f);
 637         }
 638         return 0;
 639 }
 640
 641 /* load public key from ssh v1 private or any pubkey file */
 642 Key *
 643 key_load_public(const char *filename, char **commentp)
 644 {
 645         Key *pub;
 646         char file[MAXPATHLEN];
 647
 648         /* try rsa1 private key */
 649         pub = key_load_public_type(KEY_RSA1, filename, commentp);
 650         if (pub != NULL)
 651                 return pub;
 652
 653         /* try rsa1 public key */
 654         pub = key_new(KEY_RSA1);
 655         if (key_try_load_public(pub, filename, commentp) == 1)
 656                 return pub;
 657         key_free(pub);
 658
 659         /* try ssh2 public key */
 660         pub = key_new(KEY_UNSPEC);
 661         if (key_try_load_public(pub, filename, commentp) == 1)
 662                 return pub;
 663         if ((strlcpy(file, filename, sizeof file) < sizeof(file)) &&
 664             (strlcat(file, ".pub", sizeof file) < sizeof(file)) &&
 665             (key_try_load_public(pub, file, commentp) == 1))
 666                 return pub;
 667         key_free(pub);
 668         return NULL;
 669 }