]> asedeno.scripts.mit.edu Git - PuTTY.git/blob - sshpubk.c
Support public keys using the "ssh-ed25519" method.
[PuTTY.git] / sshpubk.c
1 /*
2  * Generic SSH public-key handling operations. In particular,
3  * reading of SSH public-key files, and also the generic `sign'
4  * operation for SSH-2 (which checks the type of the key and
5  * dispatches to the appropriate key-type specific function).
6  */
7
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <assert.h>
11
12 #include "putty.h"
13 #include "ssh.h"
14 #include "misc.h"
15
16 #define rsa_signature "SSH PRIVATE KEY FILE FORMAT 1.1\n"
17
18 #define BASE64_TOINT(x) ( (x)-'A'<26 ? (x)-'A'+0 :\
19                           (x)-'a'<26 ? (x)-'a'+26 :\
20                           (x)-'0'<10 ? (x)-'0'+52 :\
21                           (x)=='+' ? 62 : \
22                           (x)=='/' ? 63 : 0 )
23
24 static int loadrsakey_main(FILE * fp, struct RSAKey *key, int pub_only,
25                            char **commentptr, char *passphrase,
26                            const char **error)
27 {
28     unsigned char buf[16384];
29     unsigned char keybuf[16];
30     int len;
31     int i, j, ciphertype;
32     int ret = 0;
33     struct MD5Context md5c;
34     char *comment;
35
36     *error = NULL;
37
38     /* Slurp the whole file (minus the header) into a buffer. */
39     len = fread(buf, 1, sizeof(buf), fp);
40     fclose(fp);
41     if (len < 0 || len == sizeof(buf)) {
42         *error = "error reading file";
43         goto end;                      /* file too big or not read */
44     }
45
46     i = 0;
47     *error = "file format error";
48
49     /*
50      * A zero byte. (The signature includes a terminating NUL.)
51      */
52     if (len - i < 1 || buf[i] != 0)
53         goto end;
54     i++;
55
56     /* One byte giving encryption type, and one reserved uint32. */
57     if (len - i < 1)
58         goto end;
59     ciphertype = buf[i];
60     if (ciphertype != 0 && ciphertype != SSH_CIPHER_3DES)
61         goto end;
62     i++;
63     if (len - i < 4)
64         goto end;                      /* reserved field not present */
65     if (buf[i] != 0 || buf[i + 1] != 0 || buf[i + 2] != 0
66         || buf[i + 3] != 0) goto end;  /* reserved field nonzero, panic! */
67     i += 4;
68
69     /* Now the serious stuff. An ordinary SSH-1 public key. */
70     j = makekey(buf + i, len - i, key, NULL, 1);
71     if (j < 0)
72         goto end;                      /* overran */
73     i += j;
74
75     /* Next, the comment field. */
76     j = toint(GET_32BIT(buf + i));
77     i += 4;
78     if (j < 0 || len - i < j)
79         goto end;
80     comment = snewn(j + 1, char);
81     if (comment) {
82         memcpy(comment, buf + i, j);
83         comment[j] = '\0';
84     }
85     i += j;
86     if (commentptr)
87         *commentptr = dupstr(comment);
88     if (key)
89         key->comment = comment;
90     else
91         sfree(comment);
92
93     if (pub_only) {
94         ret = 1;
95         goto end;
96     }
97
98     if (!key) {
99         ret = ciphertype != 0;
100         *error = NULL;
101         goto end;
102     }
103
104     /*
105      * Decrypt remainder of buffer.
106      */
107     if (ciphertype) {
108         MD5Init(&md5c);
109         MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
110         MD5Final(keybuf, &md5c);
111         des3_decrypt_pubkey(keybuf, buf + i, (len - i + 7) & ~7);
112         smemclr(keybuf, sizeof(keybuf));        /* burn the evidence */
113     }
114
115     /*
116      * We are now in the secret part of the key. The first four
117      * bytes should be of the form a, b, a, b.
118      */
119     if (len - i < 4)
120         goto end;
121     if (buf[i] != buf[i + 2] || buf[i + 1] != buf[i + 3]) {
122         *error = "wrong passphrase";
123         ret = -1;
124         goto end;
125     }
126     i += 4;
127
128     /*
129      * After that, we have one further bignum which is our
130      * decryption exponent, and then the three auxiliary values
131      * (iqmp, q, p).
132      */
133     j = makeprivate(buf + i, len - i, key);
134     if (j < 0) goto end;
135     i += j;
136     j = ssh1_read_bignum(buf + i, len - i, &key->iqmp);
137     if (j < 0) goto end;
138     i += j;
139     j = ssh1_read_bignum(buf + i, len - i, &key->q);
140     if (j < 0) goto end;
141     i += j;
142     j = ssh1_read_bignum(buf + i, len - i, &key->p);
143     if (j < 0) goto end;
144     i += j;
145
146     if (!rsa_verify(key)) {
147         *error = "rsa_verify failed";
148         freersakey(key);
149         ret = 0;
150     } else
151         ret = 1;
152
153   end:
154     smemclr(buf, sizeof(buf));       /* burn the evidence */
155     return ret;
156 }
157
158 int loadrsakey(const Filename *filename, struct RSAKey *key, char *passphrase,
159                const char **errorstr)
160 {
161     FILE *fp;
162     char buf[64];
163     int ret = 0;
164     const char *error = NULL;
165
166     fp = f_open(filename, "rb", FALSE);
167     if (!fp) {
168         error = "can't open file";
169         goto end;
170     }
171
172     /*
173      * Read the first line of the file and see if it's a v1 private
174      * key file.
175      */
176     if (fgets(buf, sizeof(buf), fp) && !strcmp(buf, rsa_signature)) {
177         /*
178          * This routine will take care of calling fclose() for us.
179          */
180         ret = loadrsakey_main(fp, key, FALSE, NULL, passphrase, &error);
181         fp = NULL;
182         goto end;
183     }
184
185     /*
186      * Otherwise, we have nothing. Return empty-handed.
187      */
188     error = "not an SSH-1 RSA file";
189
190   end:
191     if (fp)
192         fclose(fp);
193     if ((ret != 1) && errorstr)
194         *errorstr = error;
195     return ret;
196 }
197
198 /*
199  * See whether an RSA key is encrypted. Return its comment field as
200  * well.
201  */
202 int rsakey_encrypted(const Filename *filename, char **comment)
203 {
204     FILE *fp;
205     char buf[64];
206
207     fp = f_open(filename, "rb", FALSE);
208     if (!fp)
209         return 0;                      /* doesn't even exist */
210
211     /*
212      * Read the first line of the file and see if it's a v1 private
213      * key file.
214      */
215     if (fgets(buf, sizeof(buf), fp) && !strcmp(buf, rsa_signature)) {
216         const char *dummy;
217         /*
218          * This routine will take care of calling fclose() for us.
219          */
220         return loadrsakey_main(fp, NULL, FALSE, comment, NULL, &dummy);
221     }
222     fclose(fp);
223     return 0;                          /* wasn't the right kind of file */
224 }
225
226 /*
227  * Return a malloc'ed chunk of memory containing the public blob of
228  * an RSA key, as given in the agent protocol (modulus bits,
229  * exponent, modulus).
230  */
231 int rsakey_pubblob(const Filename *filename, void **blob, int *bloblen,
232                    char **commentptr, const char **errorstr)
233 {
234     FILE *fp;
235     char buf[64];
236     struct RSAKey key;
237     int ret;
238     const char *error = NULL;
239
240     /* Default return if we fail. */
241     *blob = NULL;
242     *bloblen = 0;
243     ret = 0;
244
245     fp = f_open(filename, "rb", FALSE);
246     if (!fp) {
247         error = "can't open file";
248         goto end;
249     }
250
251     /*
252      * Read the first line of the file and see if it's a v1 private
253      * key file.
254      */
255     if (fgets(buf, sizeof(buf), fp) && !strcmp(buf, rsa_signature)) {
256         memset(&key, 0, sizeof(key));
257         if (loadrsakey_main(fp, &key, TRUE, commentptr, NULL, &error)) {
258             *blob = rsa_public_blob(&key, bloblen);
259             freersakey(&key);
260             ret = 1;
261         }
262         fp = NULL; /* loadrsakey_main unconditionally closes fp */
263     } else {
264         error = "not an SSH-1 RSA file";
265     }
266
267   end:
268     if (fp)
269         fclose(fp);
270     if ((ret != 1) && errorstr)
271         *errorstr = error;
272     return ret;
273 }
274
275 /*
276  * Save an RSA key file. Return nonzero on success.
277  */
278 int saversakey(const Filename *filename, struct RSAKey *key, char *passphrase)
279 {
280     unsigned char buf[16384];
281     unsigned char keybuf[16];
282     struct MD5Context md5c;
283     unsigned char *p, *estart;
284     FILE *fp;
285
286     /*
287      * Write the initial signature.
288      */
289     p = buf;
290     memcpy(p, rsa_signature, sizeof(rsa_signature));
291     p += sizeof(rsa_signature);
292
293     /*
294      * One byte giving encryption type, and one reserved (zero)
295      * uint32.
296      */
297     *p++ = (passphrase ? SSH_CIPHER_3DES : 0);
298     PUT_32BIT(p, 0);
299     p += 4;
300
301     /*
302      * An ordinary SSH-1 public key consists of: a uint32
303      * containing the bit count, then two bignums containing the
304      * modulus and exponent respectively.
305      */
306     PUT_32BIT(p, bignum_bitcount(key->modulus));
307     p += 4;
308     p += ssh1_write_bignum(p, key->modulus);
309     p += ssh1_write_bignum(p, key->exponent);
310
311     /*
312      * A string containing the comment field.
313      */
314     if (key->comment) {
315         PUT_32BIT(p, strlen(key->comment));
316         p += 4;
317         memcpy(p, key->comment, strlen(key->comment));
318         p += strlen(key->comment);
319     } else {
320         PUT_32BIT(p, 0);
321         p += 4;
322     }
323
324     /*
325      * The encrypted portion starts here.
326      */
327     estart = p;
328
329     /*
330      * Two bytes, then the same two bytes repeated.
331      */
332     *p++ = random_byte();
333     *p++ = random_byte();
334     p[0] = p[-2];
335     p[1] = p[-1];
336     p += 2;
337
338     /*
339      * Four more bignums: the decryption exponent, then iqmp, then
340      * q, then p.
341      */
342     p += ssh1_write_bignum(p, key->private_exponent);
343     p += ssh1_write_bignum(p, key->iqmp);
344     p += ssh1_write_bignum(p, key->q);
345     p += ssh1_write_bignum(p, key->p);
346
347     /*
348      * Now write zeros until the encrypted portion is a multiple of
349      * 8 bytes.
350      */
351     while ((p - estart) % 8)
352         *p++ = '\0';
353
354     /*
355      * Now encrypt the encrypted portion.
356      */
357     if (passphrase) {
358         MD5Init(&md5c);
359         MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
360         MD5Final(keybuf, &md5c);
361         des3_encrypt_pubkey(keybuf, estart, p - estart);
362         smemclr(keybuf, sizeof(keybuf));        /* burn the evidence */
363     }
364
365     /*
366      * Done. Write the result to the file.
367      */
368     fp = f_open(filename, "wb", TRUE);
369     if (fp) {
370         int ret = (fwrite(buf, 1, p - buf, fp) == (size_t) (p - buf));
371         if (fclose(fp))
372             ret = 0;
373         return ret;
374     } else
375         return 0;
376 }
377
378 /* ----------------------------------------------------------------------
379  * SSH-2 private key load/store functions.
380  */
381
382 /*
383  * PuTTY's own format for SSH-2 keys is as follows:
384  *
385  * The file is text. Lines are terminated by CRLF, although CR-only
386  * and LF-only are tolerated on input.
387  *
388  * The first line says "PuTTY-User-Key-File-2: " plus the name of the
389  * algorithm ("ssh-dss", "ssh-rsa" etc).
390  *
391  * The next line says "Encryption: " plus an encryption type.
392  * Currently the only supported encryption types are "aes256-cbc"
393  * and "none".
394  *
395  * The next line says "Comment: " plus the comment string.
396  *
397  * Next there is a line saying "Public-Lines: " plus a number N.
398  * The following N lines contain a base64 encoding of the public
399  * part of the key. This is encoded as the standard SSH-2 public key
400  * blob (with no initial length): so for RSA, for example, it will
401  * read
402  *
403  *    string "ssh-rsa"
404  *    mpint  exponent
405  *    mpint  modulus
406  *
407  * Next, there is a line saying "Private-Lines: " plus a number N,
408  * and then N lines containing the (potentially encrypted) private
409  * part of the key. For the key type "ssh-rsa", this will be
410  * composed of
411  *
412  *    mpint  private_exponent
413  *    mpint  p                  (the larger of the two primes)
414  *    mpint  q                  (the smaller prime)
415  *    mpint  iqmp               (the inverse of q modulo p)
416  *    data   padding            (to reach a multiple of the cipher block size)
417  *
418  * And for "ssh-dss", it will be composed of
419  *
420  *    mpint  x                  (the private key parameter)
421  *  [ string hash   20-byte hash of mpints p || q || g   only in old format ]
422  * 
423  * Finally, there is a line saying "Private-MAC: " plus a hex
424  * representation of a HMAC-SHA-1 of:
425  *
426  *    string  name of algorithm ("ssh-dss", "ssh-rsa")
427  *    string  encryption type
428  *    string  comment
429  *    string  public-blob
430  *    string  private-plaintext (the plaintext version of the
431  *                               private part, including the final
432  *                               padding)
433  * 
434  * The key to the MAC is itself a SHA-1 hash of:
435  * 
436  *    data    "putty-private-key-file-mac-key"
437  *    data    passphrase
438  *
439  * (An empty passphrase is used for unencrypted keys.)
440  *
441  * If the key is encrypted, the encryption key is derived from the
442  * passphrase by means of a succession of SHA-1 hashes. Each hash
443  * is the hash of:
444  *
445  *    uint32  sequence-number
446  *    data    passphrase
447  *
448  * where the sequence-number increases from zero. As many of these
449  * hashes are used as necessary.
450  *
451  * For backwards compatibility with snapshots between 0.51 and
452  * 0.52, we also support the older key file format, which begins
453  * with "PuTTY-User-Key-File-1" (version number differs). In this
454  * format the Private-MAC: field only covers the private-plaintext
455  * field and nothing else (and without the 4-byte string length on
456  * the front too). Moreover, the Private-MAC: field can be replaced
457  * with a Private-Hash: field which is a plain SHA-1 hash instead of
458  * an HMAC (this was generated for unencrypted keys).
459  */
460
461 static int read_header(FILE * fp, char *header)
462 {
463     int len = 39;
464     int c;
465
466     while (1) {
467         c = fgetc(fp);
468         if (c == '\n' || c == '\r' || c == EOF)
469             return 0;                  /* failure */
470         if (c == ':') {
471             c = fgetc(fp);
472             if (c != ' ')
473                 return 0;
474             *header = '\0';
475             return 1;                  /* success! */
476         }
477         if (len == 0)
478             return 0;                  /* failure */
479         *header++ = c;
480         len--;
481     }
482     return 0;                          /* failure */
483 }
484
485 static char *read_body(FILE * fp)
486 {
487     char *text;
488     int len;
489     int size;
490     int c;
491
492     size = 128;
493     text = snewn(size, char);
494     len = 0;
495     text[len] = '\0';
496
497     while (1) {
498         c = fgetc(fp);
499         if (c == '\r' || c == '\n' || c == EOF) {
500             if (c != EOF) {
501                 c = fgetc(fp);
502                 if (c != '\r' && c != '\n')
503                     ungetc(c, fp);
504             }
505             return text;
506         }
507         if (len + 1 >= size) {
508             size += 128;
509             text = sresize(text, size, char);
510         }
511         text[len++] = c;
512         text[len] = '\0';
513     }
514 }
515
516 static unsigned char *read_blob(FILE * fp, int nlines, int *bloblen)
517 {
518     unsigned char *blob;
519     char *line;
520     int linelen, len;
521     int i, j, k;
522
523     /* We expect at most 64 base64 characters, ie 48 real bytes, per line. */
524     blob = snewn(48 * nlines, unsigned char);
525     len = 0;
526     for (i = 0; i < nlines; i++) {
527         line = read_body(fp);
528         if (!line) {
529             sfree(blob);
530             return NULL;
531         }
532         linelen = strlen(line);
533         if (linelen % 4 != 0 || linelen > 64) {
534             sfree(blob);
535             sfree(line);
536             return NULL;
537         }
538         for (j = 0; j < linelen; j += 4) {
539             k = base64_decode_atom(line + j, blob + len);
540             if (!k) {
541                 sfree(line);
542                 sfree(blob);
543                 return NULL;
544             }
545             len += k;
546         }
547         sfree(line);
548     }
549     *bloblen = len;
550     return blob;
551 }
552
553 /*
554  * Magic error return value for when the passphrase is wrong.
555  */
556 struct ssh2_userkey ssh2_wrong_passphrase = {
557     NULL, NULL, NULL
558 };
559
560 const struct ssh_signkey *find_pubkey_alg_len(int namelen, const char *name)
561 {
562     if (match_ssh_id(namelen, name, "ssh-rsa"))
563         return &ssh_rsa;
564     else if (match_ssh_id(namelen, name, "ssh-dss"))
565         return &ssh_dss;
566     else if (match_ssh_id(namelen, name, "ecdsa-sha2-nistp256"))
567         return &ssh_ecdsa_nistp256;
568     else if (match_ssh_id(namelen, name, "ecdsa-sha2-nistp384"))
569         return &ssh_ecdsa_nistp384;
570     else if (match_ssh_id(namelen, name, "ecdsa-sha2-nistp521"))
571         return &ssh_ecdsa_nistp521;
572     else if (match_ssh_id(namelen, name, "ssh-ed25519"))
573         return &ssh_ecdsa_ed25519;
574     else
575         return NULL;
576 }
577
578 const struct ssh_signkey *find_pubkey_alg(const char *name)
579 {
580     return find_pubkey_alg_len(strlen(name), name);
581 }
582
583 struct ssh2_userkey *ssh2_load_userkey(const Filename *filename,
584                                        char *passphrase, const char **errorstr)
585 {
586     FILE *fp;
587     char header[40], *b, *encryption, *comment, *mac;
588     const struct ssh_signkey *alg;
589     struct ssh2_userkey *ret;
590     int cipher, cipherblk;
591     unsigned char *public_blob, *private_blob;
592     int public_blob_len, private_blob_len;
593     int i, is_mac, old_fmt;
594     int passlen = passphrase ? strlen(passphrase) : 0;
595     const char *error = NULL;
596
597     ret = NULL;                        /* return NULL for most errors */
598     encryption = comment = mac = NULL;
599     public_blob = private_blob = NULL;
600
601     fp = f_open(filename, "rb", FALSE);
602     if (!fp) {
603         error = "can't open file";
604         goto error;
605     }
606
607     /* Read the first header line which contains the key type. */
608     if (!read_header(fp, header))
609         goto error;
610     if (0 == strcmp(header, "PuTTY-User-Key-File-2")) {
611         old_fmt = 0;
612     } else if (0 == strcmp(header, "PuTTY-User-Key-File-1")) {
613         /* this is an old key file; warn and then continue */
614         old_keyfile_warning();
615         old_fmt = 1;
616     } else if (0 == strncmp(header, "PuTTY-User-Key-File-", 20)) {
617         /* this is a key file FROM THE FUTURE; refuse it, but with a
618          * more specific error message than the generic one below */
619         error = "PuTTY key format too new";
620         goto error;
621     } else {
622         error = "not a PuTTY SSH-2 private key";
623         goto error;
624     }
625     error = "file format error";
626     if ((b = read_body(fp)) == NULL)
627         goto error;
628     /* Select key algorithm structure. */
629     alg = find_pubkey_alg(b);
630     if (!alg) {
631         sfree(b);
632         goto error;
633     }
634     sfree(b);
635
636     /* Read the Encryption header line. */
637     if (!read_header(fp, header) || 0 != strcmp(header, "Encryption"))
638         goto error;
639     if ((encryption = read_body(fp)) == NULL)
640         goto error;
641     if (!strcmp(encryption, "aes256-cbc")) {
642         cipher = 1;
643         cipherblk = 16;
644     } else if (!strcmp(encryption, "none")) {
645         cipher = 0;
646         cipherblk = 1;
647     } else {
648         goto error;
649     }
650
651     /* Read the Comment header line. */
652     if (!read_header(fp, header) || 0 != strcmp(header, "Comment"))
653         goto error;
654     if ((comment = read_body(fp)) == NULL)
655         goto error;
656
657     /* Read the Public-Lines header line and the public blob. */
658     if (!read_header(fp, header) || 0 != strcmp(header, "Public-Lines"))
659         goto error;
660     if ((b = read_body(fp)) == NULL)
661         goto error;
662     i = atoi(b);
663     sfree(b);
664     if ((public_blob = read_blob(fp, i, &public_blob_len)) == NULL)
665         goto error;
666
667     /* Read the Private-Lines header line and the Private blob. */
668     if (!read_header(fp, header) || 0 != strcmp(header, "Private-Lines"))
669         goto error;
670     if ((b = read_body(fp)) == NULL)
671         goto error;
672     i = atoi(b);
673     sfree(b);
674     if ((private_blob = read_blob(fp, i, &private_blob_len)) == NULL)
675         goto error;
676
677     /* Read the Private-MAC or Private-Hash header line. */
678     if (!read_header(fp, header))
679         goto error;
680     if (0 == strcmp(header, "Private-MAC")) {
681         if ((mac = read_body(fp)) == NULL)
682             goto error;
683         is_mac = 1;
684     } else if (0 == strcmp(header, "Private-Hash") && old_fmt) {
685         if ((mac = read_body(fp)) == NULL)
686             goto error;
687         is_mac = 0;
688     } else
689         goto error;
690
691     fclose(fp);
692     fp = NULL;
693
694     /*
695      * Decrypt the private blob.
696      */
697     if (cipher) {
698         unsigned char key[40];
699         SHA_State s;
700
701         if (!passphrase)
702             goto error;
703         if (private_blob_len % cipherblk)
704             goto error;
705
706         SHA_Init(&s);
707         SHA_Bytes(&s, "\0\0\0\0", 4);
708         SHA_Bytes(&s, passphrase, passlen);
709         SHA_Final(&s, key + 0);
710         SHA_Init(&s);
711         SHA_Bytes(&s, "\0\0\0\1", 4);
712         SHA_Bytes(&s, passphrase, passlen);
713         SHA_Final(&s, key + 20);
714         aes256_decrypt_pubkey(key, private_blob, private_blob_len);
715     }
716
717     /*
718      * Verify the MAC.
719      */
720     {
721         char realmac[41];
722         unsigned char binary[20];
723         unsigned char *macdata;
724         int maclen;
725         int free_macdata;
726
727         if (old_fmt) {
728             /* MAC (or hash) only covers the private blob. */
729             macdata = private_blob;
730             maclen = private_blob_len;
731             free_macdata = 0;
732         } else {
733             unsigned char *p;
734             int namelen = strlen(alg->name);
735             int enclen = strlen(encryption);
736             int commlen = strlen(comment);
737             maclen = (4 + namelen +
738                       4 + enclen +
739                       4 + commlen +
740                       4 + public_blob_len +
741                       4 + private_blob_len);
742             macdata = snewn(maclen, unsigned char);
743             p = macdata;
744 #define DO_STR(s,len) PUT_32BIT(p,(len));memcpy(p+4,(s),(len));p+=4+(len)
745             DO_STR(alg->name, namelen);
746             DO_STR(encryption, enclen);
747             DO_STR(comment, commlen);
748             DO_STR(public_blob, public_blob_len);
749             DO_STR(private_blob, private_blob_len);
750
751             free_macdata = 1;
752         }
753
754         if (is_mac) {
755             SHA_State s;
756             unsigned char mackey[20];
757             char header[] = "putty-private-key-file-mac-key";
758
759             SHA_Init(&s);
760             SHA_Bytes(&s, header, sizeof(header)-1);
761             if (cipher && passphrase)
762                 SHA_Bytes(&s, passphrase, passlen);
763             SHA_Final(&s, mackey);
764
765             hmac_sha1_simple(mackey, 20, macdata, maclen, binary);
766
767             smemclr(mackey, sizeof(mackey));
768             smemclr(&s, sizeof(s));
769         } else {
770             SHA_Simple(macdata, maclen, binary);
771         }
772
773         if (free_macdata) {
774             smemclr(macdata, maclen);
775             sfree(macdata);
776         }
777
778         for (i = 0; i < 20; i++)
779             sprintf(realmac + 2 * i, "%02x", binary[i]);
780
781         if (strcmp(mac, realmac)) {
782             /* An incorrect MAC is an unconditional Error if the key is
783              * unencrypted. Otherwise, it means Wrong Passphrase. */
784             if (cipher) {
785                 error = "wrong passphrase";
786                 ret = SSH2_WRONG_PASSPHRASE;
787             } else {
788                 error = "MAC failed";
789                 ret = NULL;
790             }
791             goto error;
792         }
793     }
794     sfree(mac);
795     mac = NULL;
796
797     /*
798      * Create and return the key.
799      */
800     ret = snew(struct ssh2_userkey);
801     ret->alg = alg;
802     ret->comment = comment;
803     ret->data = alg->createkey(public_blob, public_blob_len,
804                                private_blob, private_blob_len);
805     if (!ret->data) {
806         sfree(ret);
807         ret = NULL;
808         error = "createkey failed";
809         goto error;
810     }
811     sfree(public_blob);
812     smemclr(private_blob, private_blob_len);
813     sfree(private_blob);
814     sfree(encryption);
815     if (errorstr)
816         *errorstr = NULL;
817     return ret;
818
819     /*
820      * Error processing.
821      */
822   error:
823     if (fp)
824         fclose(fp);
825     if (comment)
826         sfree(comment);
827     if (encryption)
828         sfree(encryption);
829     if (mac)
830         sfree(mac);
831     if (public_blob)
832         sfree(public_blob);
833     if (private_blob) {
834         smemclr(private_blob, private_blob_len);
835         sfree(private_blob);
836     }
837     if (errorstr)
838         *errorstr = error;
839     return ret;
840 }
841
842 unsigned char *ssh2_userkey_loadpub(const Filename *filename, char **algorithm,
843                                     int *pub_blob_len, char **commentptr,
844                                     const char **errorstr)
845 {
846     FILE *fp;
847     char header[40], *b;
848     const struct ssh_signkey *alg;
849     unsigned char *public_blob;
850     int public_blob_len;
851     int i;
852     const char *error = NULL;
853     char *comment = NULL;
854
855     public_blob = NULL;
856
857     fp = f_open(filename, "rb", FALSE);
858     if (!fp) {
859         error = "can't open file";
860         goto error;
861     }
862
863     /* Read the first header line which contains the key type. */
864     if (!read_header(fp, header)
865         || (0 != strcmp(header, "PuTTY-User-Key-File-2") &&
866             0 != strcmp(header, "PuTTY-User-Key-File-1"))) {
867         if (0 == strncmp(header, "PuTTY-User-Key-File-", 20))
868             error = "PuTTY key format too new";
869         else
870             error = "not a PuTTY SSH-2 private key";
871         goto error;
872     }
873     error = "file format error";
874     if ((b = read_body(fp)) == NULL)
875         goto error;
876     /* Select key algorithm structure. */
877     alg = find_pubkey_alg(b);
878     sfree(b);
879     if (!alg) {
880         goto error;
881     }
882
883     /* Read the Encryption header line. */
884     if (!read_header(fp, header) || 0 != strcmp(header, "Encryption"))
885         goto error;
886     if ((b = read_body(fp)) == NULL)
887         goto error;
888     sfree(b);                          /* we don't care */
889
890     /* Read the Comment header line. */
891     if (!read_header(fp, header) || 0 != strcmp(header, "Comment"))
892         goto error;
893     if ((comment = read_body(fp)) == NULL)
894         goto error;
895
896     if (commentptr)
897         *commentptr = comment;
898     else
899         sfree(comment);
900
901     /* Read the Public-Lines header line and the public blob. */
902     if (!read_header(fp, header) || 0 != strcmp(header, "Public-Lines"))
903         goto error;
904     if ((b = read_body(fp)) == NULL)
905         goto error;
906     i = atoi(b);
907     sfree(b);
908     if ((public_blob = read_blob(fp, i, &public_blob_len)) == NULL)
909         goto error;
910
911     fclose(fp);
912     if (pub_blob_len)
913         *pub_blob_len = public_blob_len;
914     if (algorithm)
915         *algorithm = alg->name;
916     return public_blob;
917
918     /*
919      * Error processing.
920      */
921   error:
922     if (fp)
923         fclose(fp);
924     if (public_blob)
925         sfree(public_blob);
926     if (errorstr)
927         *errorstr = error;
928     if (comment && commentptr) {
929         sfree(comment);
930         *commentptr = NULL;
931     }
932     return NULL;
933 }
934
935 int ssh2_userkey_encrypted(const Filename *filename, char **commentptr)
936 {
937     FILE *fp;
938     char header[40], *b, *comment;
939     int ret;
940
941     if (commentptr)
942         *commentptr = NULL;
943
944     fp = f_open(filename, "rb", FALSE);
945     if (!fp)
946         return 0;
947     if (!read_header(fp, header)
948         || (0 != strcmp(header, "PuTTY-User-Key-File-2") &&
949             0 != strcmp(header, "PuTTY-User-Key-File-1"))) {
950         fclose(fp);
951         return 0;
952     }
953     if ((b = read_body(fp)) == NULL) {
954         fclose(fp);
955         return 0;
956     }
957     sfree(b);                          /* we don't care about key type here */
958     /* Read the Encryption header line. */
959     if (!read_header(fp, header) || 0 != strcmp(header, "Encryption")) {
960         fclose(fp);
961         return 0;
962     }
963     if ((b = read_body(fp)) == NULL) {
964         fclose(fp);
965         return 0;
966     }
967
968     /* Read the Comment header line. */
969     if (!read_header(fp, header) || 0 != strcmp(header, "Comment")) {
970         fclose(fp);
971         sfree(b);
972         return 1;
973     }
974     if ((comment = read_body(fp)) == NULL) {
975         fclose(fp);
976         sfree(b);
977         return 1;
978     }
979
980     if (commentptr)
981         *commentptr = comment;
982     else
983         sfree(comment);
984
985     fclose(fp);
986     if (!strcmp(b, "aes256-cbc"))
987         ret = 1;
988     else
989         ret = 0;
990     sfree(b);
991     return ret;
992 }
993
994 int base64_lines(int datalen)
995 {
996     /* When encoding, we use 64 chars/line, which equals 48 real chars. */
997     return (datalen + 47) / 48;
998 }
999
1000 void base64_encode(FILE * fp, unsigned char *data, int datalen, int cpl)
1001 {
1002     int linelen = 0;
1003     char out[4];
1004     int n, i;
1005
1006     while (datalen > 0) {
1007         n = (datalen < 3 ? datalen : 3);
1008         base64_encode_atom(data, n, out);
1009         data += n;
1010         datalen -= n;
1011         for (i = 0; i < 4; i++) {
1012             if (linelen >= cpl) {
1013                 linelen = 0;
1014                 fputc('\n', fp);
1015             }
1016             fputc(out[i], fp);
1017             linelen++;
1018         }
1019     }
1020     fputc('\n', fp);
1021 }
1022
1023 int ssh2_save_userkey(const Filename *filename, struct ssh2_userkey *key,
1024                       char *passphrase)
1025 {
1026     FILE *fp;
1027     unsigned char *pub_blob, *priv_blob, *priv_blob_encrypted;
1028     int pub_blob_len, priv_blob_len, priv_encrypted_len;
1029     int passlen;
1030     int cipherblk;
1031     int i;
1032     char *cipherstr;
1033     unsigned char priv_mac[20];
1034
1035     /*
1036      * Fetch the key component blobs.
1037      */
1038     pub_blob = key->alg->public_blob(key->data, &pub_blob_len);
1039     priv_blob = key->alg->private_blob(key->data, &priv_blob_len);
1040     if (!pub_blob || !priv_blob) {
1041         sfree(pub_blob);
1042         sfree(priv_blob);
1043         return 0;
1044     }
1045
1046     /*
1047      * Determine encryption details, and encrypt the private blob.
1048      */
1049     if (passphrase) {
1050         cipherstr = "aes256-cbc";
1051         cipherblk = 16;
1052     } else {
1053         cipherstr = "none";
1054         cipherblk = 1;
1055     }
1056     priv_encrypted_len = priv_blob_len + cipherblk - 1;
1057     priv_encrypted_len -= priv_encrypted_len % cipherblk;
1058     priv_blob_encrypted = snewn(priv_encrypted_len, unsigned char);
1059     memset(priv_blob_encrypted, 0, priv_encrypted_len);
1060     memcpy(priv_blob_encrypted, priv_blob, priv_blob_len);
1061     /* Create padding based on the SHA hash of the unpadded blob. This prevents
1062      * too easy a known-plaintext attack on the last block. */
1063     SHA_Simple(priv_blob, priv_blob_len, priv_mac);
1064     assert(priv_encrypted_len - priv_blob_len < 20);
1065     memcpy(priv_blob_encrypted + priv_blob_len, priv_mac,
1066            priv_encrypted_len - priv_blob_len);
1067
1068     /* Now create the MAC. */
1069     {
1070         unsigned char *macdata;
1071         int maclen;
1072         unsigned char *p;
1073         int namelen = strlen(key->alg->name);
1074         int enclen = strlen(cipherstr);
1075         int commlen = strlen(key->comment);
1076         SHA_State s;
1077         unsigned char mackey[20];
1078         char header[] = "putty-private-key-file-mac-key";
1079
1080         maclen = (4 + namelen +
1081                   4 + enclen +
1082                   4 + commlen +
1083                   4 + pub_blob_len +
1084                   4 + priv_encrypted_len);
1085         macdata = snewn(maclen, unsigned char);
1086         p = macdata;
1087 #define DO_STR(s,len) PUT_32BIT(p,(len));memcpy(p+4,(s),(len));p+=4+(len)
1088         DO_STR(key->alg->name, namelen);
1089         DO_STR(cipherstr, enclen);
1090         DO_STR(key->comment, commlen);
1091         DO_STR(pub_blob, pub_blob_len);
1092         DO_STR(priv_blob_encrypted, priv_encrypted_len);
1093
1094         SHA_Init(&s);
1095         SHA_Bytes(&s, header, sizeof(header)-1);
1096         if (passphrase)
1097             SHA_Bytes(&s, passphrase, strlen(passphrase));
1098         SHA_Final(&s, mackey);
1099         hmac_sha1_simple(mackey, 20, macdata, maclen, priv_mac);
1100         smemclr(macdata, maclen);
1101         sfree(macdata);
1102         smemclr(mackey, sizeof(mackey));
1103         smemclr(&s, sizeof(s));
1104     }
1105
1106     if (passphrase) {
1107         unsigned char key[40];
1108         SHA_State s;
1109
1110         passlen = strlen(passphrase);
1111
1112         SHA_Init(&s);
1113         SHA_Bytes(&s, "\0\0\0\0", 4);
1114         SHA_Bytes(&s, passphrase, passlen);
1115         SHA_Final(&s, key + 0);
1116         SHA_Init(&s);
1117         SHA_Bytes(&s, "\0\0\0\1", 4);
1118         SHA_Bytes(&s, passphrase, passlen);
1119         SHA_Final(&s, key + 20);
1120         aes256_encrypt_pubkey(key, priv_blob_encrypted,
1121                               priv_encrypted_len);
1122
1123         smemclr(key, sizeof(key));
1124         smemclr(&s, sizeof(s));
1125     }
1126
1127     fp = f_open(filename, "w", TRUE);
1128     if (!fp) {
1129         sfree(pub_blob);
1130         smemclr(priv_blob, priv_blob_len);
1131         sfree(priv_blob);
1132         smemclr(priv_blob_encrypted, priv_blob_len);
1133         sfree(priv_blob_encrypted);
1134         return 0;
1135     }
1136     fprintf(fp, "PuTTY-User-Key-File-2: %s\n", key->alg->name);
1137     fprintf(fp, "Encryption: %s\n", cipherstr);
1138     fprintf(fp, "Comment: %s\n", key->comment);
1139     fprintf(fp, "Public-Lines: %d\n", base64_lines(pub_blob_len));
1140     base64_encode(fp, pub_blob, pub_blob_len, 64);
1141     fprintf(fp, "Private-Lines: %d\n", base64_lines(priv_encrypted_len));
1142     base64_encode(fp, priv_blob_encrypted, priv_encrypted_len, 64);
1143     fprintf(fp, "Private-MAC: ");
1144     for (i = 0; i < 20; i++)
1145         fprintf(fp, "%02x", priv_mac[i]);
1146     fprintf(fp, "\n");
1147     fclose(fp);
1148
1149     sfree(pub_blob);
1150     smemclr(priv_blob, priv_blob_len);
1151     sfree(priv_blob);
1152     smemclr(priv_blob_encrypted, priv_blob_len);
1153     sfree(priv_blob_encrypted);
1154     return 1;
1155 }
1156
1157 /* ----------------------------------------------------------------------
1158  * A function to determine the type of a private key file. Returns
1159  * 0 on failure, 1 or 2 on success.
1160  */
1161 int key_type(const Filename *filename)
1162 {
1163     FILE *fp;
1164     char buf[32];
1165     const char putty2_sig[] = "PuTTY-User-Key-File-";
1166     const char sshcom_sig[] = "---- BEGIN SSH2 ENCRYPTED PRIVAT";
1167     const char openssh_new_sig[] = "-----BEGIN OPENSSH PRIVATE KEY";
1168     const char openssh_sig[] = "-----BEGIN ";
1169     int i;
1170
1171     fp = f_open(filename, "r", FALSE);
1172     if (!fp)
1173         return SSH_KEYTYPE_UNOPENABLE;
1174     i = fread(buf, 1, sizeof(buf), fp);
1175     fclose(fp);
1176     if (i < 0)
1177         return SSH_KEYTYPE_UNOPENABLE;
1178     if (i < 32)
1179         return SSH_KEYTYPE_UNKNOWN;
1180     if (!memcmp(buf, rsa_signature, sizeof(rsa_signature)-1))
1181         return SSH_KEYTYPE_SSH1;
1182     if (!memcmp(buf, putty2_sig, sizeof(putty2_sig)-1))
1183         return SSH_KEYTYPE_SSH2;
1184     if (!memcmp(buf, openssh_new_sig, sizeof(openssh_new_sig)-1))
1185         return SSH_KEYTYPE_OPENSSH_NEW;
1186     if (!memcmp(buf, openssh_sig, sizeof(openssh_sig)-1))
1187         return SSH_KEYTYPE_OPENSSH_PEM;
1188     if (!memcmp(buf, sshcom_sig, sizeof(sshcom_sig)-1))
1189         return SSH_KEYTYPE_SSHCOM;
1190     return SSH_KEYTYPE_UNKNOWN;        /* unrecognised or EOF */
1191 }
1192
1193 /*
1194  * Convert the type word to a string, for `wrong type' error
1195  * messages.
1196  */
1197 char *key_type_to_str(int type)
1198 {
1199     switch (type) {
1200       case SSH_KEYTYPE_UNOPENABLE: return "unable to open file"; break;
1201       case SSH_KEYTYPE_UNKNOWN: return "not a private key"; break;
1202       case SSH_KEYTYPE_SSH1: return "SSH-1 private key"; break;
1203       case SSH_KEYTYPE_SSH2: return "PuTTY SSH-2 private key"; break;
1204       case SSH_KEYTYPE_OPENSSH_PEM: return "OpenSSH SSH-2 private key (old PEM format)"; break;
1205       case SSH_KEYTYPE_OPENSSH_NEW: return "OpenSSH SSH-2 private key (new format)"; break;
1206       case SSH_KEYTYPE_SSHCOM: return "ssh.com SSH-2 private key"; break;
1207       default: return "INTERNAL ERROR"; break;
1208     }
1209 }