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