import.c

   1 /*
   2  * Code for PuTTY to import and export private key files in other
   3  * SSH clients' formats.
   4  */
   5
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <assert.h>
   9 #include <ctype.h>
  10
  11 #include "putty.h"
  12 #include "ssh.h"
  13 #include "misc.h"
  14
  15 int openssh_pem_encrypted(const Filename *filename);
  16 int openssh_new_encrypted(const Filename *filename);
  17 struct ssh2_userkey *openssh_pem_read(const Filename *filename,
  18                                       char *passphrase,
  19                                       const char **errmsg_p);
  20 struct ssh2_userkey *openssh_new_read(const Filename *filename,
  21                                       char *passphrase,
  22                                       const char **errmsg_p);
  23 int openssh_auto_write(const Filename *filename, struct ssh2_userkey *key,
  24                        char *passphrase);
  25 int openssh_pem_write(const Filename *filename, struct ssh2_userkey *key,
  26                       char *passphrase);
  27 int openssh_new_write(const Filename *filename, struct ssh2_userkey *key,
  28                       char *passphrase);
  29
  30 int sshcom_encrypted(const Filename *filename, char **comment);
  31 struct ssh2_userkey *sshcom_read(const Filename *filename, char *passphrase,
  32                                  const char **errmsg_p);
  33 int sshcom_write(const Filename *filename, struct ssh2_userkey *key,
  34                  char *passphrase);
  35
  36 /*
  37  * Given a key type, determine whether we know how to import it.
  38  */
  39 int import_possible(int type)
  40 {
  41     if (type == SSH_KEYTYPE_OPENSSH_PEM)
  42         return 1;
  43     if (type == SSH_KEYTYPE_OPENSSH_NEW)
  44         return 1;
  45     if (type == SSH_KEYTYPE_SSHCOM)
  46         return 1;
  47     return 0;
  48 }
  49
  50 /*
  51  * Given a key type, determine what native key type
  52  * (SSH_KEYTYPE_SSH1 or SSH_KEYTYPE_SSH2) it will come out as once
  53  * we've imported it.
  54  */
  55 int import_target_type(int type)
  56 {
  57     /*
  58      * There are no known foreign SSH-1 key formats.
  59      */
  60     return SSH_KEYTYPE_SSH2;
  61 }
  62
  63 /*
  64  * Determine whether a foreign key is encrypted.
  65  */
  66 int import_encrypted(const Filename *filename, int type, char **comment)
  67 {
  68     if (type == SSH_KEYTYPE_OPENSSH_PEM) {
  69         /* OpenSSH PEM format doesn't contain a key comment at all */
  70         *comment = dupstr(filename_to_str(filename));
  71         return openssh_pem_encrypted(filename);
  72     } else if (type == SSH_KEYTYPE_OPENSSH_NEW) {
  73         /* OpenSSH new format does, but it's inside the encrypted
  74          * section for some reason */
  75         *comment = dupstr(filename_to_str(filename));
  76         return openssh_new_encrypted(filename);
  77     } else if (type == SSH_KEYTYPE_SSHCOM) {
  78         return sshcom_encrypted(filename, comment);
  79     }
  80     return 0;
  81 }
  82
  83 /*
  84  * Import an SSH-1 key.
  85  */
  86 int import_ssh1(const Filename *filename, int type,
  87                 struct RSAKey *key, char *passphrase, const char **errmsg_p)
  88 {
  89     return 0;
  90 }
  91
  92 /*
  93  * Import an SSH-2 key.
  94  */
  95 struct ssh2_userkey *import_ssh2(const Filename *filename, int type,
  96                                  char *passphrase, const char **errmsg_p)
  97 {
  98     if (type == SSH_KEYTYPE_OPENSSH_PEM)
  99         return openssh_pem_read(filename, passphrase, errmsg_p);
 100     else if (type == SSH_KEYTYPE_OPENSSH_NEW)
 101         return openssh_new_read(filename, passphrase, errmsg_p);
 102     if (type == SSH_KEYTYPE_SSHCOM)
 103         return sshcom_read(filename, passphrase, errmsg_p);
 104     return NULL;
 105 }
 106
 107 /*
 108  * Export an SSH-1 key.
 109  */
 110 int export_ssh1(const Filename *filename, int type, struct RSAKey *key,
 111                 char *passphrase)
 112 {
 113     return 0;
 114 }
 115
 116 /*
 117  * Export an SSH-2 key.
 118  */
 119 int export_ssh2(const Filename *filename, int type,
 120                 struct ssh2_userkey *key, char *passphrase)
 121 {
 122     if (type == SSH_KEYTYPE_OPENSSH_AUTO)
 123         return openssh_auto_write(filename, key, passphrase);
 124     if (type == SSH_KEYTYPE_OPENSSH_NEW)
 125         return openssh_new_write(filename, key, passphrase);
 126     if (type == SSH_KEYTYPE_SSHCOM)
 127         return sshcom_write(filename, key, passphrase);
 128     return 0;
 129 }
 130
 131 /*
 132  * Strip trailing CRs and LFs at the end of a line of text.
 133  */
 134 void strip_crlf(char *str)
 135 {
 136     char *p = str + strlen(str);
 137
 138     while (p > str && (p[-1] == '\r' || p[-1] == '\n'))
 139         *--p = '\0';
 140 }
 141
 142 /* ----------------------------------------------------------------------
 143  * Helper routines. (The base64 ones are defined in sshpubk.c.)
 144  */
 145
 146 #define isbase64(c) (    ((c) >= 'A' && (c) <= 'Z') || \
 147                          ((c) >= 'a' && (c) <= 'z') || \
 148                          ((c) >= '0' && (c) <= '9') || \
 149                          (c) == '+' || (c) == '/' || (c) == '=' \
 150                          )
 151
 152 /*
 153  * Read an ASN.1/BER identifier and length pair.
 154  *
 155  * Flags are a combination of the #defines listed below.
 156  *
 157  * Returns -1 if unsuccessful; otherwise returns the number of
 158  * bytes used out of the source data.
 159  */
 160
 161 /* ASN.1 tag classes. */
 162 #define ASN1_CLASS_UNIVERSAL        (0 << 6)
 163 #define ASN1_CLASS_APPLICATION      (1 << 6)
 164 #define ASN1_CLASS_CONTEXT_SPECIFIC (2 << 6)
 165 #define ASN1_CLASS_PRIVATE          (3 << 6)
 166 #define ASN1_CLASS_MASK             (3 << 6)
 167
 168 /* Primitive versus constructed bit. */
 169 #define ASN1_CONSTRUCTED            (1 << 5)
 170
 171 static int ber_read_id_len(void *source, int sourcelen,
 172                            int *id, int *length, int *flags)
 173 {
 174     unsigned char *p = (unsigned char *) source;
 175
 176     if (sourcelen == 0)
 177         return -1;
 178
 179     *flags = (*p & 0xE0);
 180     if ((*p & 0x1F) == 0x1F) {
 181         *id = 0;
 182         while (*p & 0x80) {
 183             p++, sourcelen--;
 184             if (sourcelen == 0)
 185                 return -1;
 186             *id = (*id << 7) | (*p & 0x7F);
 187         }
 188         p++, sourcelen--;
 189     } else {
 190         *id = *p & 0x1F;
 191         p++, sourcelen--;
 192     }
 193
 194     if (sourcelen == 0)
 195         return -1;
 196
 197     if (*p & 0x80) {
 198         int n = *p & 0x7F;
 199         p++, sourcelen--;
 200         if (sourcelen < n)
 201             return -1;
 202         *length = 0;
 203         while (n--)
 204             *length = (*length << 8) | (*p++);
 205         sourcelen -= n;
 206     } else {
 207         *length = *p;
 208         p++, sourcelen--;
 209     }
 210
 211     return p - (unsigned char *) source;
 212 }
 213
 214 /*
 215  * Write an ASN.1/BER identifier and length pair. Returns the
 216  * number of bytes consumed. Assumes dest contains enough space.
 217  * Will avoid writing anything if dest is NULL, but still return
 218  * amount of space required.
 219  */
 220 static int ber_write_id_len(void *dest, int id, int length, int flags)
 221 {
 222     unsigned char *d = (unsigned char *)dest;
 223     int len = 0;
 224
 225     if (id <= 30) {
 226         /*
 227          * Identifier is one byte.
 228          */
 229         len++;
 230         if (d) *d++ = id | flags;
 231     } else {
 232         int n;
 233         /*
 234          * Identifier is multiple bytes: the first byte is 11111
 235          * plus the flags, and subsequent bytes encode the value of
 236          * the identifier, 7 bits at a time, with the top bit of
 237          * each byte 1 except the last one which is 0.
 238          */
 239         len++;
 240         if (d) *d++ = 0x1F | flags;
 241         for (n = 1; (id >> (7*n)) > 0; n++)
 242             continue;                  /* count the bytes */
 243         while (n--) {
 244             len++;
 245             if (d) *d++ = (n ? 0x80 : 0) | ((id >> (7*n)) & 0x7F);
 246         }
 247     }
 248
 249     if (length < 128) {
 250         /*
 251          * Length is one byte.
 252          */
 253         len++;
 254         if (d) *d++ = length;
 255     } else {
 256         int n;
 257         /*
 258          * Length is multiple bytes. The first is 0x80 plus the
 259          * number of subsequent bytes, and the subsequent bytes
 260          * encode the actual length.
 261          */
 262         for (n = 1; (length >> (8*n)) > 0; n++)
 263             continue;                  /* count the bytes */
 264         len++;
 265         if (d) *d++ = 0x80 | n;
 266         while (n--) {
 267             len++;
 268             if (d) *d++ = (length >> (8*n)) & 0xFF;
 269         }
 270     }
 271
 272     return len;
 273 }
 274
 275 static int put_uint32(void *target, unsigned val)
 276 {
 277     unsigned char *d = (unsigned char *)target;
 278
 279     PUT_32BIT(d, val);
 280     return 4;
 281 }
 282
 283 static int put_string(void *target, const void *data, int len)
 284 {
 285     unsigned char *d = (unsigned char *)target;
 286
 287     PUT_32BIT(d, len);
 288     memcpy(d+4, data, len);
 289     return len+4;
 290 }
 291
 292 static int put_string_z(void *target, const char *string)
 293 {
 294     return put_string(target, string, strlen(string));
 295 }
 296
 297 static int put_mp(void *target, void *data, int len)
 298 {
 299     unsigned char *d = (unsigned char *)target;
 300     unsigned char *i = (unsigned char *)data;
 301
 302     if (*i & 0x80) {
 303         PUT_32BIT(d, len+1);
 304         d[4] = 0;
 305         memcpy(d+5, data, len);
 306         return len+5;
 307     } else {
 308         PUT_32BIT(d, len);
 309         memcpy(d+4, data, len);
 310         return len+4;
 311     }
 312 }
 313
 314 /* Simple structure to point to an mp-int within a blob. */
 315 struct mpint_pos { void *start; int bytes; };
 316
 317 static int ssh2_read_mpint(void *data, int len, struct mpint_pos *ret)
 318 {
 319     int bytes;
 320     unsigned char *d = (unsigned char *) data;
 321
 322     if (len < 4)
 323         goto error;
 324     bytes = toint(GET_32BIT(d));
 325     if (bytes < 0 || len-4 < bytes)
 326         goto error;
 327
 328     ret->start = d + 4;
 329     ret->bytes = bytes;
 330     return bytes+4;
 331
 332     error:
 333     ret->start = NULL;
 334     ret->bytes = -1;
 335     return len;                        /* ensure further calls fail as well */
 336 }
 337
 338 /* ----------------------------------------------------------------------
 339  * Code to read and write OpenSSH private keys, in the old-style PEM
 340  * format.
 341  */
 342
 343 typedef enum {
 344     OP_DSA, OP_RSA, OP_ECDSA
 345 } openssh_pem_keytype;
 346 typedef enum {
 347     OP_E_3DES, OP_E_AES
 348 } openssh_pem_enc;
 349
 350 struct openssh_pem_key {
 351     openssh_pem_keytype keytype;
 352     int encrypted;
 353     openssh_pem_enc encryption;
 354     char iv[32];
 355     unsigned char *keyblob;
 356     int keyblob_len, keyblob_size;
 357 };
 358
 359 static struct openssh_pem_key *load_openssh_pem_key(const Filename *filename,
 360                                                     const char **errmsg_p)
 361 {
 362     struct openssh_pem_key *ret;
 363     FILE *fp = NULL;
 364     char *line = NULL;
 365     const char *errmsg;
 366     char *p;
 367     int headers_done;
 368     char base64_bit[4];
 369     int base64_chars = 0;
 370
 371     ret = snew(struct openssh_pem_key);
 372     ret->keyblob = NULL;
 373     ret->keyblob_len = ret->keyblob_size = 0;
 374
 375     fp = f_open(filename, "r", FALSE);
 376     if (!fp) {
 377         errmsg = "unable to open key file";
 378         goto error;
 379     }
 380
 381     if (!(line = fgetline(fp))) {
 382         errmsg = "unexpected end of file";
 383         goto error;
 384     }
 385     strip_crlf(line);
 386     if (0 != strncmp(line, "-----BEGIN ", 11) ||
 387         0 != strcmp(line+strlen(line)-16, "PRIVATE KEY-----")) {
 388         errmsg = "file does not begin with OpenSSH key header";
 389         goto error;
 390     }
 391     /*
 392      * Parse the BEGIN line. For old-format keys, this tells us the
 393      * type of the key; for new-format keys, all it tells us is the
 394      * format, and we'll find out the key type once we parse the
 395      * base64.
 396      */
 397     if (!strcmp(line, "-----BEGIN RSA PRIVATE KEY-----")) {
 398         ret->keytype = OP_RSA;
 399     } else if (!strcmp(line, "-----BEGIN DSA PRIVATE KEY-----")) {
 400         ret->keytype = OP_DSA;
 401     } else if (!strcmp(line, "-----BEGIN EC PRIVATE KEY-----")) {
 402         ret->keytype = OP_ECDSA;
 403     } else if (!strcmp(line, "-----BEGIN OPENSSH PRIVATE KEY-----")) {
 404         errmsg = "this is a new-style OpenSSH key";
 405         goto error;
 406     } else {
 407         errmsg = "unrecognised key type";
 408         goto error;
 409     }
 410     smemclr(line, strlen(line));
 411     sfree(line);
 412     line = NULL;
 413
 414     ret->encrypted = FALSE;
 415     memset(ret->iv, 0, sizeof(ret->iv));
 416
 417     headers_done = 0;
 418     while (1) {
 419         if (!(line = fgetline(fp))) {
 420             errmsg = "unexpected end of file";
 421             goto error;
 422         }
 423         strip_crlf(line);
 424         if (0 == strncmp(line, "-----END ", 9) &&
 425             0 == strcmp(line+strlen(line)-16, "PRIVATE KEY-----")) {
 426             sfree(line);
 427             line = NULL;
 428             break;                     /* done */
 429         }
 430         if ((p = strchr(line, ':')) != NULL) {
 431             if (headers_done) {
 432                 errmsg = "header found in body of key data";
 433                 goto error;
 434             }
 435             *p++ = '\0';
 436             while (*p && isspace((unsigned char)*p)) p++;
 437             if (!strcmp(line, "Proc-Type")) {
 438                 if (p[0] != '4' || p[1] != ',') {
 439                     errmsg = "Proc-Type is not 4 (only 4 is supported)";
 440                     goto error;
 441                 }
 442                 p += 2;
 443                 if (!strcmp(p, "ENCRYPTED"))
 444                     ret->encrypted = TRUE;
 445             } else if (!strcmp(line, "DEK-Info")) {
 446                 int i, j, ivlen;
 447
 448                 if (!strncmp(p, "DES-EDE3-CBC,", 13)) {
 449                     ret->encryption = OP_E_3DES;
 450                     ivlen = 8;
 451                 } else if (!strncmp(p, "AES-128-CBC,", 12)) {
 452                     ret->encryption = OP_E_AES;
 453                     ivlen = 16;
 454                 } else {
 455                     errmsg = "unsupported cipher";
 456                     goto error;
 457                 }
 458                 p = strchr(p, ',') + 1;/* always non-NULL, by above checks */
 459                 for (i = 0; i < ivlen; i++) {
 460                     if (1 != sscanf(p, "%2x", &j)) {
 461                         errmsg = "expected more iv data in DEK-Info";
 462                         goto error;
 463                     }
 464                     ret->iv[i] = j;
 465                     p += 2;
 466                 }
 467                 if (*p) {
 468                     errmsg = "more iv data than expected in DEK-Info";
 469                     goto error;
 470                 }
 471             }
 472         } else {
 473             headers_done = 1;
 474
 475             p = line;
 476             while (isbase64(*p)) {
 477                 base64_bit[base64_chars++] = *p;
 478                 if (base64_chars == 4) {
 479                     unsigned char out[3];
 480                     int len;
 481
 482                     base64_chars = 0;
 483
 484                     len = base64_decode_atom(base64_bit, out);
 485
 486                     if (len <= 0) {
 487                         errmsg = "invalid base64 encoding";
 488                         goto error;
 489                     }
 490
 491                     if (ret->keyblob_len + len > ret->keyblob_size) {
 492                         ret->keyblob_size = ret->keyblob_len + len + 256;
 493                         ret->keyblob = sresize(ret->keyblob, ret->keyblob_size,
 494                                                unsigned char);
 495                     }
 496
 497                     memcpy(ret->keyblob + ret->keyblob_len, out, len);
 498                     ret->keyblob_len += len;
 499
 500                     smemclr(out, sizeof(out));
 501                 }
 502
 503                 p++;
 504             }
 505         }
 506         smemclr(line, strlen(line));
 507         sfree(line);
 508         line = NULL;
 509     }
 510
 511     fclose(fp);
 512     fp = NULL;
 513
 514     if (ret->keyblob_len == 0 || !ret->keyblob) {
 515         errmsg = "key body not present";
 516         goto error;
 517     }
 518
 519     if (ret->encrypted && ret->keyblob_len % 8 != 0) {
 520         errmsg = "encrypted key blob is not a multiple of "
 521             "cipher block size";
 522         goto error;
 523     }
 524
 525     smemclr(base64_bit, sizeof(base64_bit));
 526     if (errmsg_p) *errmsg_p = NULL;
 527     return ret;
 528
 529     error:
 530     if (line) {
 531         smemclr(line, strlen(line));
 532         sfree(line);
 533         line = NULL;
 534     }
 535     smemclr(base64_bit, sizeof(base64_bit));
 536     if (ret) {
 537         if (ret->keyblob) {
 538             smemclr(ret->keyblob, ret->keyblob_size);
 539             sfree(ret->keyblob);
 540         }
 541         smemclr(ret, sizeof(*ret));
 542         sfree(ret);
 543     }
 544     if (errmsg_p) *errmsg_p = errmsg;
 545     if (fp) fclose(fp);
 546     return NULL;
 547 }
 548
 549 int openssh_pem_encrypted(const Filename *filename)
 550 {
 551     struct openssh_pem_key *key = load_openssh_pem_key(filename, NULL);
 552     int ret;
 553
 554     if (!key)
 555         return 0;
 556     ret = key->encrypted;
 557     smemclr(key->keyblob, key->keyblob_size);
 558     sfree(key->keyblob);
 559     smemclr(key, sizeof(*key));
 560     sfree(key);
 561     return ret;
 562 }
 563
 564 struct ssh2_userkey *openssh_pem_read(const Filename *filename,
 565                                       char *passphrase,
 566                                       const char **errmsg_p)
 567 {
 568     struct openssh_pem_key *key = load_openssh_pem_key(filename, errmsg_p);
 569     struct ssh2_userkey *retkey;
 570     unsigned char *p, *q;
 571     int ret, id, len, flags;
 572     int i, num_integers;
 573     struct ssh2_userkey *retval = NULL;
 574     const char *errmsg;
 575     unsigned char *blob;
 576     int blobsize = 0, blobptr, privptr;
 577     char *modptr = NULL;
 578     int modlen = 0;
 579
 580     blob = NULL;
 581
 582     if (!key)
 583         return NULL;
 584
 585     if (key->encrypted) {
 586         /*
 587          * Derive encryption key from passphrase and iv/salt:
 588          *
 589          *  - let block A equal MD5(passphrase || iv)
 590          *  - let block B equal MD5(A || passphrase || iv)
 591          *  - block C would be MD5(B || passphrase || iv) and so on
 592          *  - encryption key is the first N bytes of A || B
 593          *
 594          * (Note that only 8 bytes of the iv are used for key
 595          * derivation, even when the key is encrypted with AES and
 596          * hence there are 16 bytes available.)
 597          */
 598         struct MD5Context md5c;
 599         unsigned char keybuf[32];
 600
 601         MD5Init(&md5c);
 602         MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
 603         MD5Update(&md5c, (unsigned char *)key->iv, 8);
 604         MD5Final(keybuf, &md5c);
 605
 606         MD5Init(&md5c);
 607         MD5Update(&md5c, keybuf, 16);
 608         MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
 609         MD5Update(&md5c, (unsigned char *)key->iv, 8);
 610         MD5Final(keybuf+16, &md5c);
 611
 612         /*
 613          * Now decrypt the key blob.
 614          */
 615         if (key->encryption == OP_E_3DES)
 616             des3_decrypt_pubkey_ossh(keybuf, (unsigned char *)key->iv,
 617                                      key->keyblob, key->keyblob_len);
 618         else {
 619             void *ctx;
 620             assert(key->encryption == OP_E_AES);
 621             ctx = aes_make_context();
 622             aes128_key(ctx, keybuf);
 623             aes_iv(ctx, (unsigned char *)key->iv);
 624             aes_ssh2_decrypt_blk(ctx, key->keyblob, key->keyblob_len);
 625             aes_free_context(ctx);
 626         }
 627
 628         smemclr(&md5c, sizeof(md5c));
 629         smemclr(keybuf, sizeof(keybuf));
 630     }
 631
 632     /*
 633      * Now we have a decrypted key blob, which contains an ASN.1
 634      * encoded private key. We must now untangle the ASN.1.
 635      *
 636      * We expect the whole key blob to be formatted as a SEQUENCE
 637      * (0x30 followed by a length code indicating that the rest of
 638      * the blob is part of the sequence). Within that SEQUENCE we
 639      * expect to see a bunch of INTEGERs. What those integers mean
 640      * depends on the key type:
 641      *
 642      *  - For RSA, we expect the integers to be 0, n, e, d, p, q,
 643      *    dmp1, dmq1, iqmp in that order. (The last three are d mod
 644      *    (p-1), d mod (q-1), inverse of q mod p respectively.)
 645      *
 646      *  - For DSA, we expect them to be 0, p, q, g, y, x in that
 647      *    order.
 648      *
 649      *  - In ECDSA the format is totally different: we see the
 650      *    SEQUENCE, but beneath is an INTEGER 1, OCTET STRING priv
 651      *    EXPLICIT [0] OID curve, EXPLICIT [1] BIT STRING pubPoint
 652      */
 653
 654     p = key->keyblob;
 655
 656     /* Expect the SEQUENCE header. Take its absence as a failure to
 657      * decrypt, if the key was encrypted. */
 658     ret = ber_read_id_len(p, key->keyblob_len, &id, &len, &flags);
 659     p += ret;
 660     if (ret < 0 || id != 16) {
 661         errmsg = "ASN.1 decoding failure";
 662         retval = key->encrypted ? SSH2_WRONG_PASSPHRASE : NULL;
 663         goto error;
 664     }
 665
 666     /* Expect a load of INTEGERs. */
 667     if (key->keytype == OP_RSA)
 668         num_integers = 9;
 669     else if (key->keytype == OP_DSA)
 670         num_integers = 6;
 671     else
 672         num_integers = 0;              /* placate compiler warnings */
 673
 674
 675     if (key->keytype == OP_ECDSA) {
 676         /* And now for something completely different */
 677         unsigned char *priv;
 678         int privlen;
 679         const struct ssh_signkey *alg;
 680         const struct ec_curve *curve;
 681         int algnamelen, curvenamelen;
 682         /* Read INTEGER 1 */
 683         ret = ber_read_id_len(p, key->keyblob+key->keyblob_len-p,
 684                               &id, &len, &flags);
 685         p += ret;
 686         if (ret < 0 || id != 2 || key->keyblob+key->keyblob_len-p < len ||
 687             len != 1 || p[0] != 1) {
 688             errmsg = "ASN.1 decoding failure";
 689             retval = key->encrypted ? SSH2_WRONG_PASSPHRASE : NULL;
 690             goto error;
 691         }
 692         p += 1;
 693         /* Read private key OCTET STRING */
 694         ret = ber_read_id_len(p, key->keyblob+key->keyblob_len-p,
 695                               &id, &len, &flags);
 696         p += ret;
 697         if (ret < 0 || id != 4 || key->keyblob+key->keyblob_len-p < len) {
 698             errmsg = "ASN.1 decoding failure";
 699             retval = key->encrypted ? SSH2_WRONG_PASSPHRASE : NULL;
 700             goto error;
 701         }
 702         priv = p;
 703         privlen = len;
 704         p += len;
 705         /* Read curve OID */
 706         ret = ber_read_id_len(p, key->keyblob+key->keyblob_len-p,
 707                               &id, &len, &flags);
 708         p += ret;
 709         if (ret < 0 || id != 0 || key->keyblob+key->keyblob_len-p < len) {
 710             errmsg = "ASN.1 decoding failure";
 711             retval = key->encrypted ? SSH2_WRONG_PASSPHRASE : NULL;
 712             goto error;
 713         }
 714         ret = ber_read_id_len(p, key->keyblob+key->keyblob_len-p,
 715                               &id, &len, &flags);
 716         p += ret;
 717         if (ret < 0 || id != 6 || key->keyblob+key->keyblob_len-p < len) {
 718             errmsg = "ASN.1 decoding failure";
 719             retval = key->encrypted ? SSH2_WRONG_PASSPHRASE : NULL;
 720             goto error;
 721         }
 722         alg = ec_alg_by_oid(len, p, &curve);
 723         if (!alg) {
 724             errmsg = "Unsupported ECDSA curve.";
 725             retval = NULL;
 726             goto error;
 727         }
 728         p += len;
 729         /* Read BIT STRING point */
 730         ret = ber_read_id_len(p, key->keyblob+key->keyblob_len-p,
 731                               &id, &len, &flags);
 732         p += ret;
 733         if (ret < 0 || id != 1 || key->keyblob+key->keyblob_len-p < len) {
 734             errmsg = "ASN.1 decoding failure";
 735             retval = key->encrypted ? SSH2_WRONG_PASSPHRASE : NULL;
 736             goto error;
 737         }
 738         ret = ber_read_id_len(p, key->keyblob+key->keyblob_len-p,
 739                               &id, &len, &flags);
 740         p += ret;
 741         if (ret < 0 || id != 3 || key->keyblob+key->keyblob_len-p < len ||
 742             len != ((((curve->fieldBits + 7) / 8) * 2) + 2)) {
 743             errmsg = "ASN.1 decoding failure";
 744             retval = key->encrypted ? SSH2_WRONG_PASSPHRASE : NULL;
 745             goto error;
 746         }
 747         p += 1; len -= 1; /* Skip 0x00 before point */
 748
 749         /* Construct the key */
 750         retkey = snew(struct ssh2_userkey);
 751         if (!retkey) {
 752             errmsg = "out of memory";
 753             goto error;
 754         }
 755         retkey->alg = alg;
 756         blob = snewn((4+19 + 4+8 + 4+len) + (4+1+privlen), unsigned char);
 757         if (!blob) {
 758             sfree(retkey);
 759             errmsg = "out of memory";
 760             goto error;
 761         }
 762
 763         q = blob;
 764
 765         algnamelen = strlen(alg->name);
 766         PUT_32BIT(q, algnamelen); q += 4;
 767         memcpy(q, alg->name, algnamelen); q += algnamelen;
 768
 769         curvenamelen = strlen(curve->name);
 770         PUT_32BIT(q, curvenamelen); q += 4;
 771         memcpy(q, curve->name, curvenamelen); q += curvenamelen;
 772
 773         PUT_32BIT(q, len); q += 4;
 774         memcpy(q, p, len); q += len;
 775
 776         /*
 777          * To be acceptable to our createkey(), the private blob must
 778          * contain a valid mpint, i.e. without the top bit set. But
 779          * the input private string may have the top bit set, so we
 780          * prefix a zero byte to ensure createkey() doesn't fail for
 781          * that reason.
 782          */
 783         PUT_32BIT(q, privlen+1);
 784         q[4] = 0;
 785         memcpy(q+5, priv, privlen);
 786
 787         retkey->data = retkey->alg->createkey(retkey->alg,
 788                                               blob, q-blob,
 789                                               q, 5+privlen);
 790
 791         if (!retkey->data) {
 792             sfree(retkey);
 793             errmsg = "unable to create key data structure";
 794             goto error;
 795         }
 796
 797     } else if (key->keytype == OP_RSA || key->keytype == OP_DSA) {
 798
 799         /*
 800          * Space to create key blob in.
 801          */
 802         blobsize = 256+key->keyblob_len;
 803         blob = snewn(blobsize, unsigned char);
 804         PUT_32BIT(blob, 7);
 805         if (key->keytype == OP_DSA)
 806             memcpy(blob+4, "ssh-dss", 7);
 807         else if (key->keytype == OP_RSA)
 808             memcpy(blob+4, "ssh-rsa", 7);
 809         blobptr = 4+7;
 810         privptr = -1;
 811
 812         for (i = 0; i < num_integers; i++) {
 813             ret = ber_read_id_len(p, key->keyblob+key->keyblob_len-p,
 814                                   &id, &len, &flags);
 815             p += ret;
 816             if (ret < 0 || id != 2 ||
 817                 key->keyblob+key->keyblob_len-p < len) {
 818                 errmsg = "ASN.1 decoding failure";
 819                 retval = key->encrypted ? SSH2_WRONG_PASSPHRASE : NULL;
 820                 goto error;
 821             }
 822
 823             if (i == 0) {
 824                 /*
 825                  * The first integer should be zero always (I think
 826                  * this is some sort of version indication).
 827                  */
 828                 if (len != 1 || p[0] != 0) {
 829                     errmsg = "version number mismatch";
 830                     goto error;
 831                 }
 832             } else if (key->keytype == OP_RSA) {
 833                 /*
 834                  * Integers 1 and 2 go into the public blob but in the
 835                  * opposite order; integers 3, 4, 5 and 8 go into the
 836                  * private blob. The other two (6 and 7) are ignored.
 837                  */
 838                 if (i == 1) {
 839                     /* Save the details for after we deal with number 2. */
 840                     modptr = (char *)p;
 841                     modlen = len;
 842                 } else if (i != 6 && i != 7) {
 843                     PUT_32BIT(blob+blobptr, len);
 844                     memcpy(blob+blobptr+4, p, len);
 845                     blobptr += 4+len;
 846                     if (i == 2) {
 847                         PUT_32BIT(blob+blobptr, modlen);
 848                         memcpy(blob+blobptr+4, modptr, modlen);
 849                         blobptr += 4+modlen;
 850                         privptr = blobptr;
 851                     }
 852                 }
 853             } else if (key->keytype == OP_DSA) {
 854                 /*
 855                  * Integers 1-4 go into the public blob; integer 5 goes
 856                  * into the private blob.
 857                  */
 858                 PUT_32BIT(blob+blobptr, len);
 859                 memcpy(blob+blobptr+4, p, len);
 860                 blobptr += 4+len;
 861                 if (i == 4)
 862                     privptr = blobptr;
 863             }
 864
 865             /* Skip past the number. */
 866             p += len;
 867         }
 868
 869         /*
 870          * Now put together the actual key. Simplest way to do this is
 871          * to assemble our own key blobs and feed them to the createkey
 872          * functions; this is a bit faffy but it does mean we get all
 873          * the sanity checks for free.
 874          */
 875         assert(privptr > 0);          /* should have bombed by now if not */
 876         retkey = snew(struct ssh2_userkey);
 877         retkey->alg = (key->keytype == OP_RSA ? &ssh_rsa : &ssh_dss);
 878         retkey->data = retkey->alg->createkey(retkey->alg, blob, privptr,
 879                                               blob+privptr,
 880                                               blobptr-privptr);
 881         if (!retkey->data) {
 882             sfree(retkey);
 883             errmsg = "unable to create key data structure";
 884             goto error;
 885         }
 886
 887     } else {
 888         assert(0 && "Bad key type from load_openssh_pem_key");
 889     }
 890
 891     /*
 892      * The old key format doesn't include a comment in the private
 893      * key file.
 894      */
 895     retkey->comment = dupstr("imported-openssh-key");
 896
 897     errmsg = NULL;                     /* no error */
 898     retval = retkey;
 899
 900     error:
 901     if (blob) {
 902         smemclr(blob, blobsize);
 903         sfree(blob);
 904     }
 905     smemclr(key->keyblob, key->keyblob_size);
 906     sfree(key->keyblob);
 907     smemclr(key, sizeof(*key));
 908     sfree(key);
 909     if (errmsg_p) *errmsg_p = errmsg;
 910     return retval;
 911 }
 912
 913 int openssh_pem_write(const Filename *filename, struct ssh2_userkey *key,
 914                       char *passphrase)
 915 {
 916     unsigned char *pubblob, *privblob, *spareblob;
 917     int publen, privlen, sparelen = 0;
 918     unsigned char *outblob;
 919     int outlen;
 920     struct mpint_pos numbers[9];
 921     int nnumbers, pos, len, seqlen, i;
 922     const char *header, *footer;
 923     char zero[1];
 924     unsigned char iv[8];
 925     int ret = 0;
 926     FILE *fp;
 927
 928     /*
 929      * Fetch the key blobs.
 930      */
 931     pubblob = key->alg->public_blob(key->data, &publen);
 932     privblob = key->alg->private_blob(key->data, &privlen);
 933     spareblob = outblob = NULL;
 934
 935     outblob = NULL;
 936     len = 0;
 937
 938     /*
 939      * Encode the OpenSSH key blob, and also decide on the header
 940      * line.
 941      */
 942     if (key->alg == &ssh_rsa || key->alg == &ssh_dss) {
 943         /*
 944          * The RSA and DSS handlers share some code because the two
 945          * key types have very similar ASN.1 representations, as a
 946          * plain SEQUENCE of big integers. So we set up a list of
 947          * bignums per key type and then construct the actual blob in
 948          * common code after that.
 949          */
 950         if (key->alg == &ssh_rsa) {
 951             int pos;
 952             struct mpint_pos n, e, d, p, q, iqmp, dmp1, dmq1;
 953             Bignum bd, bp, bq, bdmp1, bdmq1;
 954
 955             /*
 956              * These blobs were generated from inside PuTTY, so we needn't
 957              * treat them as untrusted.
 958              */
 959             pos = 4 + GET_32BIT(pubblob);
 960             pos += ssh2_read_mpint(pubblob+pos, publen-pos, &e);
 961             pos += ssh2_read_mpint(pubblob+pos, publen-pos, &n);
 962             pos = 0;
 963             pos += ssh2_read_mpint(privblob+pos, privlen-pos, &d);
 964             pos += ssh2_read_mpint(privblob+pos, privlen-pos, &p);
 965             pos += ssh2_read_mpint(privblob+pos, privlen-pos, &q);
 966             pos += ssh2_read_mpint(privblob+pos, privlen-pos, &iqmp);
 967
 968             assert(e.start && iqmp.start); /* can't go wrong */
 969
 970             /* We also need d mod (p-1) and d mod (q-1). */
 971             bd = bignum_from_bytes(d.start, d.bytes);
 972             bp = bignum_from_bytes(p.start, p.bytes);
 973             bq = bignum_from_bytes(q.start, q.bytes);
 974             decbn(bp);
 975             decbn(bq);
 976             bdmp1 = bigmod(bd, bp);
 977             bdmq1 = bigmod(bd, bq);
 978             freebn(bd);
 979             freebn(bp);
 980             freebn(bq);
 981
 982             dmp1.bytes = (bignum_bitcount(bdmp1)+8)/8;
 983             dmq1.bytes = (bignum_bitcount(bdmq1)+8)/8;
 984             sparelen = dmp1.bytes + dmq1.bytes;
 985             spareblob = snewn(sparelen, unsigned char);
 986             dmp1.start = spareblob;
 987             dmq1.start = spareblob + dmp1.bytes;
 988             for (i = 0; i < dmp1.bytes; i++)
 989                 spareblob[i] = bignum_byte(bdmp1, dmp1.bytes-1 - i);
 990             for (i = 0; i < dmq1.bytes; i++)
 991                 spareblob[i+dmp1.bytes] = bignum_byte(bdmq1, dmq1.bytes-1 - i);
 992             freebn(bdmp1);
 993             freebn(bdmq1);
 994
 995             numbers[0].start = zero; numbers[0].bytes = 1; zero[0] = '\0';
 996             numbers[1] = n;
 997             numbers[2] = e;
 998             numbers[3] = d;
 999             numbers[4] = p;
1000             numbers[5] = q;
1001             numbers[6] = dmp1;
1002             numbers[7] = dmq1;
1003             numbers[8] = iqmp;
1004
1005             nnumbers = 9;
1006             header = "-----BEGIN RSA PRIVATE KEY-----\n";
1007             footer = "-----END RSA PRIVATE KEY-----\n";
1008         } else {                       /* ssh-dss */
1009             int pos;
1010             struct mpint_pos p, q, g, y, x;
1011
1012             /*
1013              * These blobs were generated from inside PuTTY, so we needn't
1014              * treat them as untrusted.
1015              */
1016             pos = 4 + GET_32BIT(pubblob);
1017             pos += ssh2_read_mpint(pubblob+pos, publen-pos, &p);
1018             pos += ssh2_read_mpint(pubblob+pos, publen-pos, &q);
1019             pos += ssh2_read_mpint(pubblob+pos, publen-pos, &g);
1020             pos += ssh2_read_mpint(pubblob+pos, publen-pos, &y);
1021             pos = 0;
1022             pos += ssh2_read_mpint(privblob+pos, privlen-pos, &x);
1023
1024             assert(y.start && x.start); /* can't go wrong */
1025
1026             numbers[0].start = zero; numbers[0].bytes = 1; zero[0] = '\0';
1027             numbers[1] = p;
1028             numbers[2] = q;
1029             numbers[3] = g;
1030             numbers[4] = y;
1031             numbers[5] = x;
1032
1033             nnumbers = 6;
1034             header = "-----BEGIN DSA PRIVATE KEY-----\n";
1035             footer = "-----END DSA PRIVATE KEY-----\n";
1036         }
1037
1038         /*
1039          * Now count up the total size of the ASN.1 encoded integers,
1040          * so as to determine the length of the containing SEQUENCE.
1041          */
1042         len = 0;
1043         for (i = 0; i < nnumbers; i++) {
1044             len += ber_write_id_len(NULL, 2, numbers[i].bytes, 0);
1045             len += numbers[i].bytes;
1046         }
1047         seqlen = len;
1048         /* Now add on the SEQUENCE header. */
1049         len += ber_write_id_len(NULL, 16, seqlen, ASN1_CONSTRUCTED);
1050
1051         /*
1052          * Now we know how big outblob needs to be. Allocate it.
1053          */
1054         outblob = snewn(len, unsigned char);
1055
1056         /*
1057          * And write the data into it.
1058          */
1059         pos = 0;
1060         pos += ber_write_id_len(outblob+pos, 16, seqlen, ASN1_CONSTRUCTED);
1061         for (i = 0; i < nnumbers; i++) {
1062             pos += ber_write_id_len(outblob+pos, 2, numbers[i].bytes, 0);
1063             memcpy(outblob+pos, numbers[i].start, numbers[i].bytes);
1064             pos += numbers[i].bytes;
1065         }
1066     } else if (key->alg == &ssh_ecdsa_nistp256 ||
1067                key->alg == &ssh_ecdsa_nistp384 ||
1068                key->alg == &ssh_ecdsa_nistp521) {
1069         const unsigned char *oid;
1070         int oidlen;
1071         int pointlen;
1072
1073         /*
1074          * Structure of asn1:
1075          * SEQUENCE
1076          *   INTEGER 1
1077          *   OCTET STRING (private key)
1078          *   [0]
1079          *     OID (curve)
1080          *   [1]
1081          *     BIT STRING (0x00 public key point)
1082          */
1083         oid = ec_alg_oid(key->alg, &oidlen);
1084         pointlen = (((struct ec_key *)key->data)->publicKey.curve->fieldBits
1085                     + 7) / 8 * 2;
1086
1087         len = ber_write_id_len(NULL, 2, 1, 0);
1088         len += 1;
1089         len += ber_write_id_len(NULL, 4, privlen - 4, 0);
1090         len+= privlen - 4;
1091         len += ber_write_id_len(NULL, 0, oidlen +
1092                                 ber_write_id_len(NULL, 6, oidlen, 0),
1093                                 ASN1_CLASS_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED);
1094         len += ber_write_id_len(NULL, 6, oidlen, 0);
1095         len += oidlen;
1096         len += ber_write_id_len(NULL, 1, 2 + pointlen +
1097                                 ber_write_id_len(NULL, 3, 2 + pointlen, 0),
1098                                 ASN1_CLASS_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED);
1099         len += ber_write_id_len(NULL, 3, 2 + pointlen, 0);
1100         len += 2 + pointlen;
1101
1102         seqlen = len;
1103         len += ber_write_id_len(NULL, 16, seqlen, ASN1_CONSTRUCTED);
1104
1105         outblob = snewn(len, unsigned char);
1106         assert(outblob);
1107
1108         pos = 0;
1109         pos += ber_write_id_len(outblob+pos, 16, seqlen, ASN1_CONSTRUCTED);
1110         pos += ber_write_id_len(outblob+pos, 2, 1, 0);
1111         outblob[pos++] = 1;
1112         pos += ber_write_id_len(outblob+pos, 4, privlen - 4, 0);
1113         memcpy(outblob+pos, privblob + 4, privlen - 4);
1114         pos += privlen - 4;
1115         pos += ber_write_id_len(outblob+pos, 0, oidlen +
1116                                 ber_write_id_len(NULL, 6, oidlen, 0),
1117                                 ASN1_CLASS_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED);
1118         pos += ber_write_id_len(outblob+pos, 6, oidlen, 0);
1119         memcpy(outblob+pos, oid, oidlen);
1120         pos += oidlen;
1121         pos += ber_write_id_len(outblob+pos, 1, 2 + pointlen +
1122                                 ber_write_id_len(NULL, 3, 2 + pointlen, 0),
1123                                 ASN1_CLASS_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED);
1124         pos += ber_write_id_len(outblob+pos, 3, 2 + pointlen, 0);
1125         outblob[pos++] = 0;
1126         memcpy(outblob+pos, pubblob+39, 1 + pointlen);
1127         pos += 1 + pointlen;
1128
1129         header = "-----BEGIN EC PRIVATE KEY-----\n";
1130         footer = "-----END EC PRIVATE KEY-----\n";
1131     } else {
1132         assert(0);                     /* zoinks! */
1133         exit(1); /* XXX: GCC doesn't understand assert() on some systems. */
1134     }
1135
1136     /*
1137      * Encrypt the key.
1138      *
1139      * For the moment, we still encrypt our OpenSSH keys using
1140      * old-style 3DES.
1141      */
1142     if (passphrase) {
1143         struct MD5Context md5c;
1144         unsigned char keybuf[32];
1145
1146         /*
1147          * Round up to the cipher block size, ensuring we have at
1148          * least one byte of padding (see below).
1149          */
1150         outlen = (len+8) &~ 7;
1151         {
1152             unsigned char *tmp = snewn(outlen, unsigned char);
1153             memcpy(tmp, outblob, len);
1154             smemclr(outblob, len);
1155             sfree(outblob);
1156             outblob = tmp;
1157         }
1158
1159         /*
1160          * Padding on OpenSSH keys is deterministic. The number of
1161          * padding bytes is always more than zero, and always at most
1162          * the cipher block length. The value of each padding byte is
1163          * equal to the number of padding bytes. So a plaintext that's
1164          * an exact multiple of the block size will be padded with 08
1165          * 08 08 08 08 08 08 08 (assuming a 64-bit block cipher); a
1166          * plaintext one byte less than a multiple of the block size
1167          * will be padded with just 01.
1168          *
1169          * This enables the OpenSSL key decryption function to strip
1170          * off the padding algorithmically and return the unpadded
1171          * plaintext to the next layer: it looks at the final byte, and
1172          * then expects to find that many bytes at the end of the data
1173          * with the same value. Those are all removed and the rest is
1174          * returned.
1175          */
1176         assert(pos == len);
1177         while (pos < outlen) {
1178             outblob[pos++] = outlen - len;
1179         }
1180
1181         /*
1182          * Invent an iv. Then derive encryption key from passphrase
1183          * and iv/salt:
1184          *
1185          *  - let block A equal MD5(passphrase || iv)
1186          *  - let block B equal MD5(A || passphrase || iv)
1187          *  - block C would be MD5(B || passphrase || iv) and so on
1188          *  - encryption key is the first N bytes of A || B
1189          */
1190         for (i = 0; i < 8; i++) iv[i] = random_byte();
1191
1192         MD5Init(&md5c);
1193         MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
1194         MD5Update(&md5c, iv, 8);
1195         MD5Final(keybuf, &md5c);
1196
1197         MD5Init(&md5c);
1198         MD5Update(&md5c, keybuf, 16);
1199         MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
1200         MD5Update(&md5c, iv, 8);
1201         MD5Final(keybuf+16, &md5c);
1202
1203         /*
1204          * Now encrypt the key blob.
1205          */
1206         des3_encrypt_pubkey_ossh(keybuf, iv, outblob, outlen);
1207
1208         smemclr(&md5c, sizeof(md5c));
1209         smemclr(keybuf, sizeof(keybuf));
1210     } else {
1211         /*
1212          * If no encryption, the blob has exactly its original
1213          * cleartext size.
1214          */
1215         outlen = len;
1216     }
1217
1218     /*
1219      * And save it. We'll use Unix line endings just in case it's
1220      * subsequently transferred in binary mode.
1221      */
1222     fp = f_open(filename, "wb", TRUE);      /* ensure Unix line endings */
1223     if (!fp)
1224         goto error;
1225     fputs(header, fp);
1226     if (passphrase) {
1227         fprintf(fp, "Proc-Type: 4,ENCRYPTED\nDEK-Info: DES-EDE3-CBC,");
1228         for (i = 0; i < 8; i++)
1229             fprintf(fp, "%02X", iv[i]);
1230         fprintf(fp, "\n\n");
1231     }
1232     base64_encode(fp, outblob, outlen, 64);
1233     fputs(footer, fp);
1234     fclose(fp);
1235     ret = 1;
1236
1237     error:
1238     if (outblob) {
1239         smemclr(outblob, outlen);
1240         sfree(outblob);
1241     }
1242     if (spareblob) {
1243         smemclr(spareblob, sparelen);
1244         sfree(spareblob);
1245     }
1246     if (privblob) {
1247         smemclr(privblob, privlen);
1248         sfree(privblob);
1249     }
1250     if (pubblob) {
1251         smemclr(pubblob, publen);
1252         sfree(pubblob);
1253     }
1254     return ret;
1255 }
1256
1257 /* ----------------------------------------------------------------------
1258  * Code to read and write OpenSSH private keys in the new-style format.
1259  */
1260
1261 typedef enum {
1262     ON_E_NONE, ON_E_AES256CBC
1263 } openssh_new_cipher;
1264 typedef enum {
1265     ON_K_NONE, ON_K_BCRYPT
1266 } openssh_new_kdf;
1267
1268 struct openssh_new_key {
1269     openssh_new_cipher cipher;
1270     openssh_new_kdf kdf;
1271     union {
1272         struct {
1273             int rounds;
1274             /* This points to a position within keyblob, not a
1275              * separately allocated thing */
1276             const unsigned char *salt;
1277             int saltlen;
1278         } bcrypt;
1279     } kdfopts;
1280     int nkeys, key_wanted;
1281     /* This too points to a position within keyblob */
1282     unsigned char *privatestr;
1283     int privatelen;
1284
1285     unsigned char *keyblob;
1286     int keyblob_len, keyblob_size;
1287 };
1288
1289 static struct openssh_new_key *load_openssh_new_key(const Filename *filename,
1290                                                     const char **errmsg_p)
1291 {
1292     struct openssh_new_key *ret;
1293     FILE *fp = NULL;
1294     char *line = NULL;
1295     const char *errmsg;
1296     char *p;
1297     char base64_bit[4];
1298     int base64_chars = 0;
1299     const void *filedata;
1300     int filelen;
1301     const void *string, *kdfopts, *bcryptsalt, *pubkey;
1302     int stringlen, kdfoptlen, bcryptsaltlen, pubkeylen;
1303     unsigned bcryptrounds, nkeys, key_index;
1304
1305     ret = snew(struct openssh_new_key);
1306     ret->keyblob = NULL;
1307     ret->keyblob_len = ret->keyblob_size = 0;
1308
1309     fp = f_open(filename, "r", FALSE);
1310     if (!fp) {
1311         errmsg = "unable to open key file";
1312         goto error;
1313     }
1314
1315     if (!(line = fgetline(fp))) {
1316         errmsg = "unexpected end of file";
1317         goto error;
1318     }
1319     strip_crlf(line);
1320     if (0 != strcmp(line, "-----BEGIN OPENSSH PRIVATE KEY-----")) {
1321         errmsg = "file does not begin with OpenSSH new-style key header";
1322         goto error;
1323     }
1324     smemclr(line, strlen(line));
1325     sfree(line);
1326     line = NULL;
1327
1328     while (1) {
1329         if (!(line = fgetline(fp))) {
1330             errmsg = "unexpected end of file";
1331             goto error;
1332         }
1333         strip_crlf(line);
1334         if (0 == strcmp(line, "-----END OPENSSH PRIVATE KEY-----")) {
1335             sfree(line);
1336             line = NULL;
1337             break;                     /* done */
1338         }
1339
1340         p = line;
1341         while (isbase64(*p)) {
1342             base64_bit[base64_chars++] = *p;
1343             if (base64_chars == 4) {
1344                 unsigned char out[3];
1345                 int len;
1346
1347                 base64_chars = 0;
1348
1349                 len = base64_decode_atom(base64_bit, out);
1350
1351                 if (len <= 0) {
1352                     errmsg = "invalid base64 encoding";
1353                     goto error;
1354                 }
1355
1356                 if (ret->keyblob_len + len > ret->keyblob_size) {
1357                     ret->keyblob_size = ret->keyblob_len + len + 256;
1358                     ret->keyblob = sresize(ret->keyblob, ret->keyblob_size,
1359                                            unsigned char);
1360                 }
1361
1362                 memcpy(ret->keyblob + ret->keyblob_len, out, len);
1363                 ret->keyblob_len += len;
1364
1365                 smemclr(out, sizeof(out));
1366             }
1367
1368             p++;
1369         }
1370         smemclr(line, strlen(line));
1371         sfree(line);
1372         line = NULL;
1373     }
1374
1375     fclose(fp);
1376     fp = NULL;
1377
1378     if (ret->keyblob_len == 0 || !ret->keyblob) {
1379         errmsg = "key body not present";
1380         goto error;
1381     }
1382
1383     filedata = ret->keyblob;
1384     filelen = ret->keyblob_len;
1385
1386     if (filelen < 15 || 0 != memcmp(filedata, "openssh-key-v1\0", 15)) {
1387         errmsg = "new-style OpenSSH magic number missing\n";
1388         goto error;
1389     }
1390     filedata = (const char *)filedata + 15;
1391     filelen -= 15;
1392
1393     if (!(string = get_ssh_string(&filelen, &filedata, &stringlen))) {
1394         errmsg = "encountered EOF before cipher name\n";
1395         goto error;
1396     }
1397     if (match_ssh_id(stringlen, string, "none")) {
1398         ret->cipher = ON_E_NONE;
1399     } else if (match_ssh_id(stringlen, string, "aes256-cbc")) {
1400         ret->cipher = ON_E_AES256CBC;
1401     } else {
1402         errmsg = "unrecognised cipher name\n";
1403         goto error;
1404     }
1405
1406     if (!(string = get_ssh_string(&filelen, &filedata, &stringlen))) {
1407         errmsg = "encountered EOF before kdf name\n";
1408         goto error;
1409     }
1410     if (match_ssh_id(stringlen, string, "none")) {
1411         ret->kdf = ON_K_NONE;
1412     } else if (match_ssh_id(stringlen, string, "bcrypt")) {
1413         ret->kdf = ON_K_BCRYPT;
1414     } else {
1415         errmsg = "unrecognised kdf name\n";
1416         goto error;
1417     }
1418
1419     if (!(kdfopts = get_ssh_string(&filelen, &filedata, &kdfoptlen))) {
1420         errmsg = "encountered EOF before kdf options\n";
1421         goto error;
1422     }
1423     switch (ret->kdf) {
1424       case ON_K_NONE:
1425         if (kdfoptlen != 0) {
1426             errmsg = "expected empty options string for 'none' kdf";
1427             goto error;
1428         }
1429         break;
1430       case ON_K_BCRYPT:
1431         if (!(bcryptsalt = get_ssh_string(&kdfoptlen, &kdfopts,
1432                                           &bcryptsaltlen))) {
1433             errmsg = "bcrypt options string did not contain salt\n";
1434             goto error;
1435         }
1436         if (!get_ssh_uint32(&kdfoptlen, &kdfopts, &bcryptrounds)) {
1437             errmsg = "bcrypt options string did not contain round count\n";
1438             goto error;
1439         }
1440         ret->kdfopts.bcrypt.salt = bcryptsalt;
1441         ret->kdfopts.bcrypt.saltlen = bcryptsaltlen;
1442         ret->kdfopts.bcrypt.rounds = bcryptrounds;
1443         break;
1444     }
1445
1446     /*
1447      * At this point we expect a uint32 saying how many keys are
1448      * stored in this file. OpenSSH new-style key files can
1449      * contain more than one. Currently we don't have any user
1450      * interface to specify which one we're trying to extract, so
1451      * we just bomb out with an error if more than one is found in
1452      * the file. However, I've put in all the mechanism here to
1453      * extract the nth one for a given n, in case we later connect
1454      * up some UI to that mechanism. Just arrange that the
1455      * 'key_wanted' field is set to a value in the range [0,
1456      * nkeys) by some mechanism.
1457      */
1458     if (!get_ssh_uint32(&filelen, &filedata, &nkeys)) {
1459         errmsg = "encountered EOF before key count\n";
1460         goto error;
1461     }
1462     if (nkeys != 1) {
1463         errmsg = "multiple keys in new-style OpenSSH key file "
1464             "not supported\n";
1465         goto error;
1466     }
1467     ret->nkeys = nkeys;
1468     ret->key_wanted = 0;
1469
1470     for (key_index = 0; key_index < nkeys; key_index++) {
1471         if (!(pubkey = get_ssh_string(&filelen, &filedata, &pubkeylen))) {
1472             errmsg = "encountered EOF before kdf options\n";
1473             goto error;
1474         }
1475     }
1476
1477     /*
1478      * Now we expect a string containing the encrypted part of the
1479      * key file.
1480      */
1481     if (!(string = get_ssh_string(&filelen, &filedata, &stringlen))) {
1482         errmsg = "encountered EOF before private key container\n";
1483         goto error;
1484     }
1485     ret->privatestr = (unsigned char *)string;
1486     ret->privatelen = stringlen;
1487
1488     /*
1489      * And now we're done, until asked to actually decrypt.
1490      */
1491
1492     smemclr(base64_bit, sizeof(base64_bit));
1493     if (errmsg_p) *errmsg_p = NULL;
1494     return ret;
1495
1496     error:
1497     if (line) {
1498         smemclr(line, strlen(line));
1499         sfree(line);
1500         line = NULL;
1501     }
1502     smemclr(base64_bit, sizeof(base64_bit));
1503     if (ret) {
1504         if (ret->keyblob) {
1505             smemclr(ret->keyblob, ret->keyblob_size);
1506             sfree(ret->keyblob);
1507         }
1508         smemclr(ret, sizeof(*ret));
1509         sfree(ret);
1510     }
1511     if (errmsg_p) *errmsg_p = errmsg;
1512     if (fp) fclose(fp);
1513     return NULL;
1514 }
1515
1516 int openssh_new_encrypted(const Filename *filename)
1517 {
1518     struct openssh_new_key *key = load_openssh_new_key(filename, NULL);
1519     int ret;
1520
1521     if (!key)
1522         return 0;
1523     ret = (key->cipher != ON_E_NONE);
1524     smemclr(key->keyblob, key->keyblob_size);
1525     sfree(key->keyblob);
1526     smemclr(key, sizeof(*key));
1527     sfree(key);
1528     return ret;
1529 }
1530
1531 struct ssh2_userkey *openssh_new_read(const Filename *filename,
1532                                       char *passphrase,
1533                                       const char **errmsg_p)
1534 {
1535     struct openssh_new_key *key = load_openssh_new_key(filename, errmsg_p);
1536     struct ssh2_userkey *retkey;
1537     int i;
1538     struct ssh2_userkey *retval = NULL;
1539     const char *errmsg;
1540     unsigned char *blob;
1541     int blobsize = 0;
1542     unsigned checkint0, checkint1;
1543     const void *priv, *string;
1544     int privlen, stringlen, key_index;
1545     const struct ssh_signkey *alg;
1546
1547     blob = NULL;
1548
1549     if (!key)
1550         return NULL;
1551
1552     if (key->cipher != ON_E_NONE) {
1553         unsigned char keybuf[48];
1554         int keysize;
1555
1556         /*
1557          * Construct the decryption key, and decrypt the string.
1558          */
1559         switch (key->cipher) {
1560           case ON_E_NONE:
1561             keysize = 0;
1562             break;
1563           case ON_E_AES256CBC:
1564             keysize = 48;              /* 32 byte key + 16 byte IV */
1565             break;
1566           default:
1567             assert(0 && "Bad cipher enumeration value");
1568         }
1569         assert(keysize <= sizeof(keybuf));
1570         switch (key->kdf) {
1571           case ON_K_NONE:
1572             memset(keybuf, 0, keysize);
1573             break;
1574           case ON_K_BCRYPT:
1575             openssh_bcrypt(passphrase,
1576                            key->kdfopts.bcrypt.salt,
1577                            key->kdfopts.bcrypt.saltlen,
1578                            key->kdfopts.bcrypt.rounds,
1579                            keybuf, keysize);
1580             break;
1581           default:
1582             assert(0 && "Bad kdf enumeration value");
1583         }
1584         switch (key->cipher) {
1585           case ON_E_NONE:
1586             break;
1587           case ON_E_AES256CBC:
1588             if (key->privatelen % 16 != 0) {
1589                 errmsg = "private key container length is not a"
1590                     " multiple of AES block size\n";
1591                 goto error;
1592             }
1593             {
1594                 void *ctx = aes_make_context();
1595                 aes256_key(ctx, keybuf);
1596                 aes_iv(ctx, keybuf + 32);
1597                 aes_ssh2_decrypt_blk(ctx, key->privatestr,
1598                                      key->privatelen);
1599                 aes_free_context(ctx);
1600             }
1601             break;
1602           default:
1603             assert(0 && "Bad cipher enumeration value");
1604         }
1605     }
1606
1607     /*
1608      * Now parse the entire encrypted section, and extract the key
1609      * identified by key_wanted.
1610      */
1611     priv = key->privatestr;
1612     privlen = key->privatelen;
1613
1614     if (!get_ssh_uint32(&privlen, &priv, &checkint0) ||
1615         !get_ssh_uint32(&privlen, &priv, &checkint1) ||
1616         checkint0 != checkint1) {
1617         errmsg = "decryption check failed";
1618         goto error;
1619     }
1620
1621     retkey = NULL;
1622     for (key_index = 0; key_index < key->nkeys; key_index++) {
1623         const unsigned char *thiskey;
1624         int thiskeylen;
1625
1626         /*
1627          * Read the key type, which will tell us how to scan over
1628          * the key to get to the next one.
1629          */
1630         if (!(string = get_ssh_string(&privlen, &priv, &stringlen))) {
1631             errmsg = "expected key type in private string";
1632             goto error;
1633         }
1634
1635         /*
1636          * Preliminary key type identification, and decide how
1637          * many pieces of key we expect to see. Currently
1638          * (conveniently) all key types can be seen as some number
1639          * of strings, so we just need to know how many of them to
1640          * skip over. (The numbers below exclude the key comment.)
1641          */
1642         {
1643             /* find_pubkey_alg needs a zero-terminated copy of the
1644              * algorithm name */
1645             char *name_zt = dupprintf("%.*s", stringlen, (char *)string);
1646             alg = find_pubkey_alg(name_zt);
1647             sfree(name_zt);
1648         }
1649
1650         if (!alg) {
1651             errmsg = "private key type not recognised\n";
1652             goto error;
1653         }
1654
1655         thiskey = priv;
1656
1657         /*
1658          * Skip over the pieces of key.
1659          */
1660         for (i = 0; i < alg->openssh_private_npieces; i++) {
1661             if (!(string = get_ssh_string(&privlen, &priv, &stringlen))) {
1662                 errmsg = "ran out of data in mid-private-key";
1663                 goto error;
1664             }
1665         }
1666
1667         thiskeylen = (int)((const unsigned char *)priv -
1668                            (const unsigned char *)thiskey);
1669         if (key_index == key->key_wanted) {
1670             retkey = snew(struct ssh2_userkey);
1671             retkey->alg = alg;
1672             retkey->data = alg->openssh_createkey(alg, &thiskey, &thiskeylen);
1673             if (!retkey->data) {
1674                 sfree(retkey);
1675                 errmsg = "unable to create key data structure";
1676                 goto error;
1677             }
1678         }
1679
1680         /*
1681          * Read the key comment.
1682          */
1683         if (!(string = get_ssh_string(&privlen, &priv, &stringlen))) {
1684             errmsg = "ran out of data at key comment";
1685             goto error;
1686         }
1687         if (key_index == key->key_wanted) {
1688             assert(retkey);
1689             retkey->comment = dupprintf("%.*s", stringlen,
1690                                         (const char *)string);
1691         }
1692     }
1693
1694     if (!retkey) {
1695         errmsg = "key index out of range";
1696         goto error;
1697     }
1698
1699     /*
1700      * Now we expect nothing left but padding.
1701      */
1702     for (i = 0; i < privlen; i++) {
1703         if (((const unsigned char *)priv)[i] != (unsigned char)(i+1)) {
1704             errmsg = "padding at end of private string did not match";
1705             goto error;
1706         }
1707     }
1708
1709     errmsg = NULL;                     /* no error */
1710     retval = retkey;
1711
1712     error:
1713     if (blob) {
1714         smemclr(blob, blobsize);
1715         sfree(blob);
1716     }
1717     smemclr(key->keyblob, key->keyblob_size);
1718     sfree(key->keyblob);
1719     smemclr(key, sizeof(*key));
1720     sfree(key);
1721     if (errmsg_p) *errmsg_p = errmsg;
1722     return retval;
1723 }
1724
1725 int openssh_new_write(const Filename *filename, struct ssh2_userkey *key,
1726                       char *passphrase)
1727 {
1728     unsigned char *pubblob, *privblob, *outblob, *p;
1729     unsigned char *private_section_start, *private_section_length_field;
1730     int publen, privlen, commentlen, maxsize, padvalue, i;
1731     unsigned checkint;
1732     int ret = 0;
1733     unsigned char bcrypt_salt[16];
1734     const int bcrypt_rounds = 16;
1735     FILE *fp;
1736
1737     /*
1738      * Fetch the key blobs and find out the lengths of things.
1739      */
1740     pubblob = key->alg->public_blob(key->data, &publen);
1741     i = key->alg->openssh_fmtkey(key->data, NULL, 0);
1742     privblob = snewn(i, unsigned char);
1743     privlen = key->alg->openssh_fmtkey(key->data, privblob, i);
1744     assert(privlen == i);
1745     commentlen = strlen(key->comment);
1746
1747     /*
1748      * Allocate enough space for the full binary key format. No need
1749      * to be absolutely precise here.
1750      */
1751     maxsize = (16 +                    /* magic number */
1752                32 +                    /* cipher name string */
1753                32 +                    /* kdf name string */
1754                64 +                    /* kdf options string */
1755                4 +                     /* key count */
1756                4+publen +              /* public key string */
1757                4 +                     /* string header for private section */
1758                8 +                     /* checkint x 2 */
1759                4+strlen(key->alg->name) + /* key type string */
1760                privlen +               /* private blob */
1761                4+commentlen +          /* comment string */
1762                16);                    /* padding at end of private section */
1763     outblob = snewn(maxsize, unsigned char);
1764
1765     /*
1766      * Construct the cleartext version of the blob.
1767      */
1768     p = outblob;
1769
1770     /* Magic number. */
1771     memcpy(p, "openssh-key-v1\0", 15);
1772     p += 15;
1773
1774     /* Cipher and kdf names, and kdf options. */
1775     if (!passphrase) {
1776         memset(bcrypt_salt, 0, sizeof(bcrypt_salt)); /* prevent warnings */
1777         p += put_string_z(p, "none");
1778         p += put_string_z(p, "none");
1779         p += put_string_z(p, "");
1780     } else {
1781         unsigned char *q;
1782         for (i = 0; i < (int)sizeof(bcrypt_salt); i++)
1783             bcrypt_salt[i] = random_byte();
1784         p += put_string_z(p, "aes256-cbc");
1785         p += put_string_z(p, "bcrypt");
1786         q = p;
1787         p += 4;
1788         p += put_string(p, bcrypt_salt, sizeof(bcrypt_salt));
1789         p += put_uint32(p, bcrypt_rounds);
1790         PUT_32BIT_MSB_FIRST(q, (unsigned)(p - (q+4)));
1791     }
1792
1793     /* Number of keys. */
1794     p += put_uint32(p, 1);
1795
1796     /* Public blob. */
1797     p += put_string(p, pubblob, publen);
1798
1799     /* Begin private section. */
1800     private_section_length_field = p;
1801     p += 4;
1802     private_section_start = p;
1803
1804     /* checkint. */
1805     checkint = 0;
1806     for (i = 0; i < 4; i++)
1807         checkint = (checkint << 8) + random_byte();
1808     p += put_uint32(p, checkint);
1809     p += put_uint32(p, checkint);
1810
1811     /* Private key. The main private blob goes inline, with no string
1812      * wrapper. */
1813     p += put_string_z(p, key->alg->name);
1814     memcpy(p, privblob, privlen);
1815     p += privlen;
1816
1817     /* Comment. */
1818     p += put_string_z(p, key->comment);
1819
1820     /* Pad out the encrypted section. */
1821     padvalue = 1;
1822     do {
1823         *p++ = padvalue++;
1824     } while ((p - private_section_start) & 15);
1825
1826     assert(p - outblob < maxsize);
1827
1828     /* Go back and fill in the length field for the private section. */
1829     PUT_32BIT_MSB_FIRST(private_section_length_field,
1830                         p - private_section_start);
1831
1832     if (passphrase) {
1833         /*
1834          * Encrypt the private section. We need 48 bytes of key
1835          * material: 32 bytes AES key + 16 bytes iv.
1836          */
1837         unsigned char keybuf[48];
1838         void *ctx;
1839
1840         openssh_bcrypt(passphrase,
1841                        bcrypt_salt, sizeof(bcrypt_salt), bcrypt_rounds,
1842                        keybuf, sizeof(keybuf));
1843
1844         ctx = aes_make_context();
1845         aes256_key(ctx, keybuf);
1846         aes_iv(ctx, keybuf + 32);
1847         aes_ssh2_encrypt_blk(ctx, private_section_start,
1848                              p - private_section_start);
1849         aes_free_context(ctx);
1850
1851         smemclr(keybuf, sizeof(keybuf));
1852     }
1853
1854     /*
1855      * And save it. We'll use Unix line endings just in case it's
1856      * subsequently transferred in binary mode.
1857      */
1858     fp = f_open(filename, "wb", TRUE);      /* ensure Unix line endings */
1859     if (!fp)
1860         goto error;
1861     fputs("-----BEGIN OPENSSH PRIVATE KEY-----\n", fp);
1862     base64_encode(fp, outblob, p - outblob, 64);
1863     fputs("-----END OPENSSH PRIVATE KEY-----\n", fp);
1864     fclose(fp);
1865     ret = 1;
1866
1867     error:
1868     if (outblob) {
1869         smemclr(outblob, maxsize);
1870         sfree(outblob);
1871     }
1872     if (privblob) {
1873         smemclr(privblob, privlen);
1874         sfree(privblob);
1875     }
1876     if (pubblob) {
1877         smemclr(pubblob, publen);
1878         sfree(pubblob);
1879     }
1880     return ret;
1881 }
1882
1883 /* ----------------------------------------------------------------------
1884  * The switch function openssh_auto_write(), which chooses one of the
1885  * concrete OpenSSH output formats based on the key type.
1886  */
1887 int openssh_auto_write(const Filename *filename, struct ssh2_userkey *key,
1888                        char *passphrase)
1889 {
1890     /*
1891      * The old OpenSSH format supports a fixed list of key types. We
1892      * assume that anything not in that fixed list is newer, and hence
1893      * will use the new format.
1894      */
1895     if (key->alg == &ssh_dss ||
1896         key->alg == &ssh_rsa ||
1897         key->alg == &ssh_ecdsa_nistp256 ||
1898         key->alg == &ssh_ecdsa_nistp384 ||
1899         key->alg == &ssh_ecdsa_nistp521)
1900         return openssh_pem_write(filename, key, passphrase);
1901     else
1902         return openssh_new_write(filename, key, passphrase);
1903 }
1904
1905 /* ----------------------------------------------------------------------
1906  * Code to read ssh.com private keys.
1907  */
1908
1909 /*
1910  * The format of the base64 blob is largely SSH-2-packet-formatted,
1911  * except that mpints are a bit different: they're more like the
1912  * old SSH-1 mpint. You have a 32-bit bit count N, followed by
1913  * (N+7)/8 bytes of data.
1914  *
1915  * So. The blob contains:
1916  *
1917  *  - uint32 0x3f6ff9eb       (magic number)
1918  *  - uint32 size             (total blob size)
1919  *  - string key-type         (see below)
1920  *  - string cipher-type      (tells you if key is encrypted)
1921  *  - string encrypted-blob
1922  *
1923  * (The first size field includes the size field itself and the
1924  * magic number before it. All other size fields are ordinary SSH-2
1925  * strings, so the size field indicates how much data is to
1926  * _follow_.)
1927  *
1928  * The encrypted blob, once decrypted, contains a single string
1929  * which in turn contains the payload. (This allows padding to be
1930  * added after that string while still making it clear where the
1931  * real payload ends. Also it probably makes for a reasonable
1932  * decryption check.)
1933  *
1934  * The payload blob, for an RSA key, contains:
1935  *  - mpint e
1936  *  - mpint d
1937  *  - mpint n  (yes, the public and private stuff is intermixed)
1938  *  - mpint u  (presumably inverse of p mod q)
1939  *  - mpint p  (p is the smaller prime)
1940  *  - mpint q  (q is the larger)
1941  *
1942  * For a DSA key, the payload blob contains:
1943  *  - uint32 0
1944  *  - mpint p
1945  *  - mpint g
1946  *  - mpint q
1947  *  - mpint y
1948  *  - mpint x
1949  *
1950  * Alternatively, if the parameters are `predefined', that
1951  * (0,p,g,q) sequence can be replaced by a uint32 1 and a string
1952  * containing some predefined parameter specification. *shudder*,
1953  * but I doubt we'll encounter this in real life.
1954  *
1955  * The key type strings are ghastly. The RSA key I looked at had a
1956  * type string of
1957  *
1958  *   `if-modn{sign{rsa-pkcs1-sha1},encrypt{rsa-pkcs1v2-oaep}}'
1959  *
1960  * and the DSA key wasn't much better:
1961  *
1962  *   `dl-modp{sign{dsa-nist-sha1},dh{plain}}'
1963  *
1964  * It isn't clear that these will always be the same. I think it
1965  * might be wise just to look at the `if-modn{sign{rsa' and
1966  * `dl-modp{sign{dsa' prefixes.
1967  *
1968  * Finally, the encryption. The cipher-type string appears to be
1969  * either `none' or `3des-cbc'. Looks as if this is SSH-2-style
1970  * 3des-cbc (i.e. outer cbc rather than inner). The key is created
1971  * from the passphrase by means of yet another hashing faff:
1972  *
1973  *  - first 16 bytes are MD5(passphrase)
1974  *  - next 16 bytes are MD5(passphrase || first 16 bytes)
1975  *  - if there were more, they'd be MD5(passphrase || first 32),
1976  *    and so on.
1977  */
1978
1979 #define SSHCOM_MAGIC_NUMBER 0x3f6ff9eb
1980
1981 struct sshcom_key {
1982     char comment[256];                 /* allowing any length is overkill */
1983     unsigned char *keyblob;
1984     int keyblob_len, keyblob_size;
1985 };
1986
1987 static struct sshcom_key *load_sshcom_key(const Filename *filename,
1988                                           const char **errmsg_p)
1989 {
1990     struct sshcom_key *ret;
1991     FILE *fp;
1992     char *line = NULL;
1993     int hdrstart, len;
1994     const char *errmsg;
1995     char *p;
1996     int headers_done;
1997     char base64_bit[4];
1998     int base64_chars = 0;
1999
2000     ret = snew(struct sshcom_key);
2001     ret->comment[0] = '\0';
2002     ret->keyblob = NULL;
2003     ret->keyblob_len = ret->keyblob_size = 0;
2004
2005     fp = f_open(filename, "r", FALSE);
2006     if (!fp) {
2007         errmsg = "unable to open key file";
2008         goto error;
2009     }
2010     if (!(line = fgetline(fp))) {
2011         errmsg = "unexpected end of file";
2012         goto error;
2013     }
2014     strip_crlf(line);
2015     if (0 != strcmp(line, "---- BEGIN SSH2 ENCRYPTED PRIVATE KEY ----")) {
2016         errmsg = "file does not begin with ssh.com key header";
2017         goto error;
2018     }
2019     smemclr(line, strlen(line));
2020     sfree(line);
2021     line = NULL;
2022
2023     headers_done = 0;
2024     while (1) {
2025         if (!(line = fgetline(fp))) {
2026             errmsg = "unexpected end of file";
2027             goto error;
2028         }
2029         strip_crlf(line);
2030         if (!strcmp(line, "---- END SSH2 ENCRYPTED PRIVATE KEY ----")) {
2031             sfree(line);
2032             line = NULL;
2033             break;                     /* done */
2034         }
2035         if ((p = strchr(line, ':')) != NULL) {
2036             if (headers_done) {
2037                 errmsg = "header found in body of key data";
2038                 goto error;
2039             }
2040             *p++ = '\0';
2041             while (*p && isspace((unsigned char)*p)) p++;
2042             hdrstart = p - line;
2043
2044             /*
2045              * Header lines can end in a trailing backslash for
2046              * continuation.
2047              */
2048             len = hdrstart + strlen(line+hdrstart);
2049             assert(!line[len]);
2050             while (line[len-1] == '\\') {
2051                 char *line2;
2052                 int line2len;
2053
2054                 line2 = fgetline(fp);
2055                 if (!line2) {
2056                     errmsg = "unexpected end of file";
2057                     goto error;
2058                 }
2059                 strip_crlf(line2);
2060
2061                 line2len = strlen(line2);
2062                 line = sresize(line, len + line2len + 1, char);
2063                 strcpy(line + len - 1, line2);
2064                 len += line2len - 1;
2065                 assert(!line[len]);
2066
2067                 smemclr(line2, strlen(line2));
2068                 sfree(line2);
2069                 line2 = NULL;
2070             }
2071             p = line + hdrstart;
2072             strip_crlf(p);
2073             if (!strcmp(line, "Comment")) {
2074                 /* Strip quotes in comment if present. */
2075                 if (p[0] == '"' && p[strlen(p)-1] == '"') {
2076                     p++;
2077                     p[strlen(p)-1] = '\0';
2078                 }
2079                 strncpy(ret->comment, p, sizeof(ret->comment));
2080                 ret->comment[sizeof(ret->comment)-1] = '\0';
2081             }
2082         } else {
2083             headers_done = 1;
2084
2085             p = line;
2086             while (isbase64(*p)) {
2087                 base64_bit[base64_chars++] = *p;
2088                 if (base64_chars == 4) {
2089                     unsigned char out[3];
2090
2091                     base64_chars = 0;
2092
2093                     len = base64_decode_atom(base64_bit, out);
2094
2095                     if (len <= 0) {
2096                         errmsg = "invalid base64 encoding";
2097                         goto error;
2098                     }
2099
2100                     if (ret->keyblob_len + len > ret->keyblob_size) {
2101                         ret->keyblob_size = ret->keyblob_len + len + 256;
2102                         ret->keyblob = sresize(ret->keyblob, ret->keyblob_size,
2103                                                unsigned char);
2104                     }
2105
2106                     memcpy(ret->keyblob + ret->keyblob_len, out, len);
2107                     ret->keyblob_len += len;
2108                 }
2109
2110                 p++;
2111             }
2112         }
2113         smemclr(line, strlen(line));
2114         sfree(line);
2115         line = NULL;
2116     }
2117
2118     if (ret->keyblob_len == 0 || !ret->keyblob) {
2119         errmsg = "key body not present";
2120         goto error;
2121     }
2122
2123     fclose(fp);
2124     if (errmsg_p) *errmsg_p = NULL;
2125     return ret;
2126
2127     error:
2128     if (fp)
2129         fclose(fp);
2130
2131     if (line) {
2132         smemclr(line, strlen(line));
2133         sfree(line);
2134         line = NULL;
2135     }
2136     if (ret) {
2137         if (ret->keyblob) {
2138             smemclr(ret->keyblob, ret->keyblob_size);
2139             sfree(ret->keyblob);
2140         }
2141         smemclr(ret, sizeof(*ret));
2142         sfree(ret);
2143     }
2144     if (errmsg_p) *errmsg_p = errmsg;
2145     return NULL;
2146 }
2147
2148 int sshcom_encrypted(const Filename *filename, char **comment)
2149 {
2150     struct sshcom_key *key = load_sshcom_key(filename, NULL);
2151     int pos, len, answer;
2152
2153     answer = 0;
2154
2155     *comment = NULL;
2156     if (!key)
2157         goto done;
2158
2159     /*
2160      * Check magic number.
2161      */
2162     if (GET_32BIT(key->keyblob) != 0x3f6ff9eb) {
2163         goto done;                     /* key is invalid */
2164     }
2165
2166     /*
2167      * Find the cipher-type string.
2168      */
2169     pos = 8;
2170     if (key->keyblob_len < pos+4)
2171         goto done;                     /* key is far too short */
2172     len = toint(GET_32BIT(key->keyblob + pos));
2173     if (len < 0 || len > key->keyblob_len - pos - 4)
2174         goto done;                     /* key is far too short */
2175     pos += 4 + len;                    /* skip key type */
2176     len = toint(GET_32BIT(key->keyblob + pos)); /* find cipher-type length */
2177     if (len < 0 || len > key->keyblob_len - pos - 4)
2178         goto done;                     /* cipher type string is incomplete */
2179     if (len != 4 || 0 != memcmp(key->keyblob + pos + 4, "none", 4))
2180         answer = 1;
2181
2182     done:
2183     if (key) {
2184         *comment = dupstr(key->comment);
2185         smemclr(key->keyblob, key->keyblob_size);
2186         sfree(key->keyblob);
2187         smemclr(key, sizeof(*key));
2188         sfree(key);
2189     } else {
2190         *comment = dupstr("");
2191     }
2192     return answer;
2193 }
2194
2195 static int sshcom_read_mpint(void *data, int len, struct mpint_pos *ret)
2196 {
2197     unsigned bits, bytes;
2198     unsigned char *d = (unsigned char *) data;
2199
2200     if (len < 4)
2201         goto error;
2202     bits = GET_32BIT(d);
2203
2204     bytes = (bits + 7) / 8;
2205     if (len < 4+bytes)
2206         goto error;
2207
2208     ret->start = d + 4;
2209     ret->bytes = bytes;
2210     return bytes+4;
2211
2212     error:
2213     ret->start = NULL;
2214     ret->bytes = -1;
2215     return len;                        /* ensure further calls fail as well */
2216 }
2217
2218 static int sshcom_put_mpint(void *target, void *data, int len)
2219 {
2220     unsigned char *d = (unsigned char *)target;
2221     unsigned char *i = (unsigned char *)data;
2222     int bits = len * 8 - 1;
2223
2224     while (bits > 0) {
2225         if (*i & (1 << (bits & 7)))
2226             break;
2227         if (!(bits-- & 7))
2228             i++, len--;
2229     }
2230
2231     PUT_32BIT(d, bits+1);
2232     memcpy(d+4, i, len);
2233     return len+4;
2234 }
2235
2236 struct ssh2_userkey *sshcom_read(const Filename *filename, char *passphrase,
2237                                  const char **errmsg_p)
2238 {
2239     struct sshcom_key *key = load_sshcom_key(filename, errmsg_p);
2240     const char *errmsg;
2241     int pos, len;
2242     const char prefix_rsa[] = "if-modn{sign{rsa";
2243     const char prefix_dsa[] = "dl-modp{sign{dsa";
2244     enum { RSA, DSA } type;
2245     int encrypted;
2246     char *ciphertext;
2247     int cipherlen;
2248     struct ssh2_userkey *ret = NULL, *retkey;
2249     const struct ssh_signkey *alg;
2250     unsigned char *blob = NULL;
2251     int blobsize = 0, publen, privlen;
2252
2253     if (!key)
2254         return NULL;
2255
2256     /*
2257      * Check magic number.
2258      */
2259     if (GET_32BIT(key->keyblob) != SSHCOM_MAGIC_NUMBER) {
2260         errmsg = "key does not begin with magic number";
2261         goto error;
2262     }
2263
2264     /*
2265      * Determine the key type.
2266      */
2267     pos = 8;
2268     if (key->keyblob_len < pos+4 ||
2269         (len = toint(GET_32BIT(key->keyblob + pos))) < 0 ||
2270         len > key->keyblob_len - pos - 4) {
2271         errmsg = "key blob does not contain a key type string";
2272         goto error;
2273     }
2274     if (len > sizeof(prefix_rsa) - 1 &&
2275         !memcmp(key->keyblob+pos+4, prefix_rsa, sizeof(prefix_rsa) - 1)) {
2276         type = RSA;
2277     } else if (len > sizeof(prefix_dsa) - 1 &&
2278         !memcmp(key->keyblob+pos+4, prefix_dsa, sizeof(prefix_dsa) - 1)) {
2279         type = DSA;
2280     } else {
2281         errmsg = "key is of unknown type";
2282         goto error;
2283     }
2284     pos += 4+len;
2285
2286     /*
2287      * Determine the cipher type.
2288      */
2289     if (key->keyblob_len < pos+4 ||
2290         (len = toint(GET_32BIT(key->keyblob + pos))) < 0 ||
2291         len > key->keyblob_len - pos - 4) {
2292         errmsg = "key blob does not contain a cipher type string";
2293         goto error;
2294     }
2295     if (len == 4 && !memcmp(key->keyblob+pos+4, "none", 4))
2296         encrypted = 0;
2297     else if (len == 8 && !memcmp(key->keyblob+pos+4, "3des-cbc", 8))
2298         encrypted = 1;
2299     else {
2300         errmsg = "key encryption is of unknown type";
2301         goto error;
2302     }
2303     pos += 4+len;
2304
2305     /*
2306      * Get hold of the encrypted part of the key.
2307      */
2308     if (key->keyblob_len < pos+4 ||
2309         (len = toint(GET_32BIT(key->keyblob + pos))) < 0 ||
2310         len > key->keyblob_len - pos - 4) {
2311         errmsg = "key blob does not contain actual key data";
2312         goto error;
2313     }
2314     ciphertext = (char *)key->keyblob + pos + 4;
2315     cipherlen = len;
2316     if (cipherlen == 0) {
2317         errmsg = "length of key data is zero";
2318         goto error;
2319     }
2320
2321     /*
2322      * Decrypt it if necessary.
2323      */
2324     if (encrypted) {
2325         /*
2326          * Derive encryption key from passphrase and iv/salt:
2327          *
2328          *  - let block A equal MD5(passphrase)
2329          *  - let block B equal MD5(passphrase || A)
2330          *  - block C would be MD5(passphrase || A || B) and so on
2331          *  - encryption key is the first N bytes of A || B
2332          */
2333         struct MD5Context md5c;
2334         unsigned char keybuf[32], iv[8];
2335
2336         if (cipherlen % 8 != 0) {
2337             errmsg = "encrypted part of key is not a multiple of cipher block"
2338                 " size";
2339             goto error;
2340         }
2341
2342         MD5Init(&md5c);
2343         MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
2344         MD5Final(keybuf, &md5c);
2345
2346         MD5Init(&md5c);
2347         MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
2348         MD5Update(&md5c, keybuf, 16);
2349         MD5Final(keybuf+16, &md5c);
2350
2351         /*
2352          * Now decrypt the key blob.
2353          */
2354         memset(iv, 0, sizeof(iv));
2355         des3_decrypt_pubkey_ossh(keybuf, iv, (unsigned char *)ciphertext,
2356                                  cipherlen);
2357
2358         smemclr(&md5c, sizeof(md5c));
2359         smemclr(keybuf, sizeof(keybuf));
2360
2361         /*
2362          * Hereafter we return WRONG_PASSPHRASE for any parsing
2363          * error. (But only if we've just tried to decrypt it!
2364          * Returning WRONG_PASSPHRASE for an unencrypted key is
2365          * automatic doom.)
2366          */
2367         if (encrypted)
2368             ret = SSH2_WRONG_PASSPHRASE;
2369     }
2370
2371     /*
2372      * Strip away the containing string to get to the real meat.
2373      */
2374     len = toint(GET_32BIT(ciphertext));
2375     if (len < 0 || len > cipherlen-4) {
2376         errmsg = "containing string was ill-formed";
2377         goto error;
2378     }
2379     ciphertext += 4;
2380     cipherlen = len;
2381
2382     /*
2383      * Now we break down into RSA versus DSA. In either case we'll
2384      * construct public and private blobs in our own format, and
2385      * end up feeding them to alg->createkey().
2386      */
2387     blobsize = cipherlen + 256;
2388     blob = snewn(blobsize, unsigned char);
2389     privlen = 0;
2390     if (type == RSA) {
2391         struct mpint_pos n, e, d, u, p, q;
2392         int pos = 0;
2393         pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &e);
2394         pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &d);
2395         pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &n);
2396         pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &u);
2397         pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &p);
2398         pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &q);
2399         if (!q.start) {
2400             errmsg = "key data did not contain six integers";
2401             goto error;
2402         }
2403
2404         alg = &ssh_rsa;
2405         pos = 0;
2406         pos += put_string(blob+pos, "ssh-rsa", 7);
2407         pos += put_mp(blob+pos, e.start, e.bytes);
2408         pos += put_mp(blob+pos, n.start, n.bytes);
2409         publen = pos;
2410         pos += put_string(blob+pos, d.start, d.bytes);
2411         pos += put_mp(blob+pos, q.start, q.bytes);
2412         pos += put_mp(blob+pos, p.start, p.bytes);
2413         pos += put_mp(blob+pos, u.start, u.bytes);
2414         privlen = pos - publen;
2415     } else {
2416         struct mpint_pos p, q, g, x, y;
2417         int pos = 4;
2418
2419         assert(type == DSA); /* the only other option from the if above */
2420
2421         if (GET_32BIT(ciphertext) != 0) {
2422             errmsg = "predefined DSA parameters not supported";
2423             goto error;
2424         }
2425         pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &p);
2426         pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &g);
2427         pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &q);
2428         pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &y);
2429         pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &x);
2430         if (!x.start) {
2431             errmsg = "key data did not contain five integers";
2432             goto error;
2433         }
2434
2435         alg = &ssh_dss;
2436         pos = 0;
2437         pos += put_string(blob+pos, "ssh-dss", 7);
2438         pos += put_mp(blob+pos, p.start, p.bytes);
2439         pos += put_mp(blob+pos, q.start, q.bytes);
2440         pos += put_mp(blob+pos, g.start, g.bytes);
2441         pos += put_mp(blob+pos, y.start, y.bytes);
2442         publen = pos;
2443         pos += put_mp(blob+pos, x.start, x.bytes);
2444         privlen = pos - publen;
2445     }
2446
2447     assert(privlen > 0);               /* should have bombed by now if not */
2448
2449     retkey = snew(struct ssh2_userkey);
2450     retkey->alg = alg;
2451     retkey->data = alg->createkey(alg, blob, publen, blob+publen, privlen);
2452     if (!retkey->data) {
2453         sfree(retkey);
2454         errmsg = "unable to create key data structure";
2455         goto error;
2456     }
2457     retkey->comment = dupstr(key->comment);
2458
2459     errmsg = NULL; /* no error */
2460     ret = retkey;
2461
2462     error:
2463     if (blob) {
2464         smemclr(blob, blobsize);
2465         sfree(blob);
2466     }
2467     smemclr(key->keyblob, key->keyblob_size);
2468     sfree(key->keyblob);
2469     smemclr(key, sizeof(*key));
2470     sfree(key);
2471     if (errmsg_p) *errmsg_p = errmsg;
2472     return ret;
2473 }
2474
2475 int sshcom_write(const Filename *filename, struct ssh2_userkey *key,
2476                  char *passphrase)
2477 {
2478     unsigned char *pubblob, *privblob;
2479     int publen, privlen;
2480     unsigned char *outblob;
2481     int outlen;
2482     struct mpint_pos numbers[6];
2483     int nnumbers, initial_zero, pos, lenpos, i;
2484     const char *type;
2485     char *ciphertext;
2486     int cipherlen;
2487     int ret = 0;
2488     FILE *fp;
2489
2490     /*
2491      * Fetch the key blobs.
2492      */
2493     pubblob = key->alg->public_blob(key->data, &publen);
2494     privblob = key->alg->private_blob(key->data, &privlen);
2495     outblob = NULL;
2496
2497     /*
2498      * Find the sequence of integers to be encoded into the OpenSSH
2499      * key blob, and also decide on the header line.
2500      */
2501     if (key->alg == &ssh_rsa) {
2502         int pos;
2503         struct mpint_pos n, e, d, p, q, iqmp;
2504
2505         /*
2506          * These blobs were generated from inside PuTTY, so we needn't
2507          * treat them as untrusted.
2508          */
2509         pos = 4 + GET_32BIT(pubblob);
2510         pos += ssh2_read_mpint(pubblob+pos, publen-pos, &e);
2511         pos += ssh2_read_mpint(pubblob+pos, publen-pos, &n);
2512         pos = 0;
2513         pos += ssh2_read_mpint(privblob+pos, privlen-pos, &d);
2514         pos += ssh2_read_mpint(privblob+pos, privlen-pos, &p);
2515         pos += ssh2_read_mpint(privblob+pos, privlen-pos, &q);
2516         pos += ssh2_read_mpint(privblob+pos, privlen-pos, &iqmp);
2517
2518         assert(e.start && iqmp.start); /* can't go wrong */
2519
2520         numbers[0] = e;
2521         numbers[1] = d;
2522         numbers[2] = n;
2523         numbers[3] = iqmp;
2524         numbers[4] = q;
2525         numbers[5] = p;
2526
2527         nnumbers = 6;
2528         initial_zero = 0;
2529         type = "if-modn{sign{rsa-pkcs1-sha1},encrypt{rsa-pkcs1v2-oaep}}";
2530     } else if (key->alg == &ssh_dss) {
2531         int pos;
2532         struct mpint_pos p, q, g, y, x;
2533
2534         /*
2535          * These blobs were generated from inside PuTTY, so we needn't
2536          * treat them as untrusted.
2537          */
2538         pos = 4 + GET_32BIT(pubblob);
2539         pos += ssh2_read_mpint(pubblob+pos, publen-pos, &p);
2540         pos += ssh2_read_mpint(pubblob+pos, publen-pos, &q);
2541         pos += ssh2_read_mpint(pubblob+pos, publen-pos, &g);
2542         pos += ssh2_read_mpint(pubblob+pos, publen-pos, &y);
2543         pos = 0;
2544         pos += ssh2_read_mpint(privblob+pos, privlen-pos, &x);
2545
2546         assert(y.start && x.start); /* can't go wrong */
2547
2548         numbers[0] = p;
2549         numbers[1] = g;
2550         numbers[2] = q;
2551         numbers[3] = y;
2552         numbers[4] = x;
2553
2554         nnumbers = 5;
2555         initial_zero = 1;
2556         type = "dl-modp{sign{dsa-nist-sha1},dh{plain}}";
2557     } else {
2558         assert(0);                     /* zoinks! */
2559         exit(1); /* XXX: GCC doesn't understand assert() on some systems. */
2560     }
2561
2562     /*
2563      * Total size of key blob will be somewhere under 512 plus
2564      * combined length of integers. We'll calculate the more
2565      * precise size as we construct the blob.
2566      */
2567     outlen = 512;
2568     for (i = 0; i < nnumbers; i++)
2569         outlen += 4 + numbers[i].bytes;
2570     outblob = snewn(outlen, unsigned char);
2571
2572     /*
2573      * Create the unencrypted key blob.
2574      */
2575     pos = 0;
2576     PUT_32BIT(outblob+pos, SSHCOM_MAGIC_NUMBER); pos += 4;
2577     pos += 4;                          /* length field, fill in later */
2578     pos += put_string(outblob+pos, type, strlen(type));
2579     {
2580         const char *ciphertype = passphrase ? "3des-cbc" : "none";
2581         pos += put_string(outblob+pos, ciphertype, strlen(ciphertype));
2582     }
2583     lenpos = pos;                      /* remember this position */
2584     pos += 4;                          /* encrypted-blob size */
2585     pos += 4;                          /* encrypted-payload size */
2586     if (initial_zero) {
2587         PUT_32BIT(outblob+pos, 0);
2588         pos += 4;
2589     }
2590     for (i = 0; i < nnumbers; i++)
2591         pos += sshcom_put_mpint(outblob+pos,
2592                                 numbers[i].start, numbers[i].bytes);
2593     /* Now wrap up the encrypted payload. */
2594     PUT_32BIT(outblob+lenpos+4, pos - (lenpos+8));
2595     /* Pad encrypted blob to a multiple of cipher block size. */
2596     if (passphrase) {
2597         int padding = -(pos - (lenpos+4)) & 7;
2598         while (padding--)
2599             outblob[pos++] = random_byte();
2600     }
2601     ciphertext = (char *)outblob+lenpos+4;
2602     cipherlen = pos - (lenpos+4);
2603     assert(!passphrase || cipherlen % 8 == 0);
2604     /* Wrap up the encrypted blob string. */
2605     PUT_32BIT(outblob+lenpos, cipherlen);
2606     /* And finally fill in the total length field. */
2607     PUT_32BIT(outblob+4, pos);
2608
2609     assert(pos < outlen);
2610
2611     /*
2612      * Encrypt the key.
2613      */
2614     if (passphrase) {
2615         /*
2616          * Derive encryption key from passphrase and iv/salt:
2617          *
2618          *  - let block A equal MD5(passphrase)
2619          *  - let block B equal MD5(passphrase || A)
2620          *  - block C would be MD5(passphrase || A || B) and so on
2621          *  - encryption key is the first N bytes of A || B
2622          */
2623         struct MD5Context md5c;
2624         unsigned char keybuf[32], iv[8];
2625
2626         MD5Init(&md5c);
2627         MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
2628         MD5Final(keybuf, &md5c);
2629
2630         MD5Init(&md5c);
2631         MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
2632         MD5Update(&md5c, keybuf, 16);
2633         MD5Final(keybuf+16, &md5c);
2634
2635         /*
2636          * Now decrypt the key blob.
2637          */
2638         memset(iv, 0, sizeof(iv));
2639         des3_encrypt_pubkey_ossh(keybuf, iv, (unsigned char *)ciphertext,
2640                                  cipherlen);
2641
2642         smemclr(&md5c, sizeof(md5c));
2643         smemclr(keybuf, sizeof(keybuf));
2644     }
2645
2646     /*
2647      * And save it. We'll use Unix line endings just in case it's
2648      * subsequently transferred in binary mode.
2649      */
2650     fp = f_open(filename, "wb", TRUE);      /* ensure Unix line endings */
2651     if (!fp)
2652         goto error;
2653     fputs("---- BEGIN SSH2 ENCRYPTED PRIVATE KEY ----\n", fp);
2654     fprintf(fp, "Comment: \"");
2655     /*
2656      * Comment header is broken with backslash-newline if it goes
2657      * over 70 chars. Although it's surrounded by quotes, it
2658      * _doesn't_ escape backslashes or quotes within the string.
2659      * Don't ask me, I didn't design it.
2660      */
2661     {
2662         int slen = 60;                 /* starts at 60 due to "Comment: " */
2663         char *c = key->comment;
2664         while ((int)strlen(c) > slen) {
2665             fprintf(fp, "%.*s\\\n", slen, c);
2666             c += slen;
2667             slen = 70;                 /* allow 70 chars on subsequent lines */
2668         }
2669         fprintf(fp, "%s\"\n", c);
2670     }
2671     base64_encode(fp, outblob, pos, 70);
2672     fputs("---- END SSH2 ENCRYPTED PRIVATE KEY ----\n", fp);
2673     fclose(fp);
2674     ret = 1;
2675
2676     error:
2677     if (outblob) {
2678         smemclr(outblob, outlen);
2679         sfree(outblob);
2680     }
2681     if (privblob) {
2682         smemclr(privblob, privlen);
2683         sfree(privblob);
2684     }
2685     if (pubblob) {
2686         smemclr(pubblob, publen);
2687         sfree(pubblob);
2688     }
2689     return ret;
2690 }