projects / u / mdw / putty / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Added a command-line key generation tool. Currently builds and runs
[u/mdw/putty] / cmdgen.c
1 /*
2 * cmdgen.c - command-line form of PuTTYgen
3 */
4
5 /*
6 * TODO:
7 *
8 * - Test thoroughly.
9 * + a neat way to do this might be to have a -DTESTMODE for
10 * this file, which #defines console_get_line and
11 * get_random_noise to different names in order to be able to
12 * link them to test stubs rather than the real ones. That
13 * way I can have a test rig which checks whether passphrases
14 * are being prompted for.
15 */
16
17 #define PUTTY_DO_GLOBALS
18
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <ctype.h>
22 #include <limits.h>
23 #include <assert.h>
24 #include <time.h>
25
26 #include "putty.h"
27 #include "ssh.h"
28
29 #ifdef TESTMODE
30 #define get_random_data get_random_data_diagnostic
31 char *get_random_data(int len)
32 {
33 char *buf = snewn(len, char);
34 memset(buf, 'x', len);
35 return buf;
36 }
37 #endif
38
39 struct progress {
40 int phase, current;
41 };
42
43 static void progress_update(void *param, int action, int phase, int iprogress)
44 {
45 struct progress *p = (struct progress *)param;
46 if (action != PROGFN_PROGRESS)
47 return;
48 if (phase > p->phase) {
49 if (p->phase >= 0)
50 fputc('\n', stderr);
51 p->phase = phase;
52 if (iprogress >= 0)
53 p->current = iprogress - 1;
54 else
55 p->current = iprogress;
56 }
57 while (p->current < iprogress) {
58 fputc('+', stdout);
59 p->current++;
60 }
61 fflush(stdout);
62 }
63
64 static void no_progress(void *param, int action, int phase, int iprogress)
65 {
66 }
67
68 void modalfatalbox(char *p, ...)
69 {
70 va_list ap;
71 fprintf(stderr, "FATAL ERROR: ");
72 va_start(ap, p);
73 vfprintf(stderr, p, ap);
74 va_end(ap);
75 fputc('\n', stderr);
76 cleanup_exit(1);
77 }
78
79 /*
80 * Stubs to let everything else link sensibly.
81 */
82 void log_eventlog(void *handle, const char *event)
83 {
84 }
85 char *x_get_default(const char *key)
86 {
87 return NULL;
88 }
89 void sk_cleanup(void)
90 {
91 }
92
93 void showversion(void)
94 {
95 char *verstr = dupstr(ver);
96 verstr[0] = tolower(verstr[0]);
97 printf("PuTTYgen %s\n", verstr);
98 sfree(verstr);
99 }
100
101 void usage(void)
102 {
103 fprintf(stderr,
104 "Usage: puttygen ( keyfile | -t type [ -b bits ] )\n"
105 " [ -C comment ] [ -P ]\n"
106 " [ -o output-keyfile ] [ -O type ]\n");
107 }
108
109 void help(void)
110 {
111 /*
112 * Help message is an extended version of the usage message. So
113 * start with that, plus a version heading.
114 */
115 showversion();
116 usage();
117 fprintf(stderr,
118 " -t specify key type when generating (rsa, dsa, rsa1)\n"
119 " -C change or specify key comment\n"
120 " -P change key passphrase\n"
121 " -O specify output type:\n"
122 " private output PuTTY private key format\n"
123 " private-openssh export OpenSSH private key\n"
124 " private-sshcom export ssh.com private key\n"
125 " public standard / ssh.com public key\n"
126 " public-openssh OpenSSH public key\n"
127 " fingerprint output the key fingerprint\n"
128 " -l equivalent to `-O fingerprint'\n"
129 " -L equivalent to `-O public-openssh'\n"
130 " -p equivalent to `-O public'\n"
131 );
132 }
133
134 static int save_ssh2_pubkey(char *filename, char *comment,
135 void *v_pub_blob, int pub_len)
136 {
137 unsigned char *pub_blob = (unsigned char *)v_pub_blob;
138 char *p;
139 int i, column;
140 FILE *fp;
141
142 if (filename) {
143 fp = fopen(filename, "wb");
144 if (!fp)
145 return 0;
146 } else
147 fp = stdout;
148
149 fprintf(fp, "---- BEGIN SSH2 PUBLIC KEY ----\n");
150
151 if (comment) {
152 fprintf(fp, "Comment: \"");
153 for (p = comment; *p; p++) {
154 if (*p == '\\' || *p == '\"')
155 fputc('\\', fp);
156 fputc(*p, fp);
157 }
158 fprintf(fp, "\"\n");
159 }
160
161 i = 0;
162 column = 0;
163 while (i < pub_len) {
164 char buf[5];
165 int n = (pub_len - i < 3 ? pub_len - i : 3);
166 base64_encode_atom(pub_blob + i, n, buf);
167 i += n;
168 buf[4] = '\0';
169 fputs(buf, fp);
170 if (++column >= 16) {
171 fputc('\n', fp);
172 column = 0;
173 }
174 }
175 if (column > 0)
176 fputc('\n', fp);
177
178 fprintf(fp, "---- END SSH2 PUBLIC KEY ----\n");
179 if (filename)
180 fclose(fp);
181 return 1;
182 }
183
184 static void move(char *from, char *to)
185 {
186 int ret;
187
188 ret = rename(from, to);
189 if (ret) {
190 /*
191 * This OS may require us to remove the original file first.
192 */
193 remove(to);
194 ret = rename(from, to);
195 }
196 if (ret) {
197 perror("puttygen: cannot move new file on to old one");
198 exit(1);
199 }
200 }
201
202 static char *blobfp(char *alg, int bits, char *blob, int bloblen)
203 {
204 char buffer[128];
205 unsigned char digest[16];
206 struct MD5Context md5c;
207 int i;
208
209 MD5Init(&md5c);
210 MD5Update(&md5c, blob, bloblen);
211 MD5Final(digest, &md5c);
212
213 sprintf(buffer, "%s ", alg);
214 if (bits > 0)
215 sprintf(buffer + strlen(buffer), "%d ", bits);
216 for (i = 0; i < 16; i++)
217 sprintf(buffer + strlen(buffer), "%s%02x", i ? ":" : "",
218 digest[i]);
219
220 return dupstr(buffer);
221 }
222
223 int main(int argc, char **argv)
224 {
225 char *infile = NULL;
226 Filename infilename;
227 enum { NOKEYGEN, RSA1, RSA2, DSA } keytype = NOKEYGEN;
228 char *outfile = NULL, *outfiletmp = NULL;
229 Filename outfilename;
230 enum { PRIVATE, PUBLIC, PUBLICO, FP, OPENSSH, SSHCOM } outtype = PRIVATE;
231 int bits = 1024;
232 char *comment = NULL, *origcomment = NULL;
233 int change_passphrase = FALSE;
234 int errs = FALSE, nogo = FALSE;
235 int intype = SSH_KEYTYPE_UNOPENABLE;
236 int sshver = 0;
237 struct ssh2_userkey *ssh2key = NULL;
238 struct RSAKey *ssh1key = NULL;
239 char *ssh2blob = NULL, *ssh2alg = NULL;
240 const struct ssh_signkey *ssh2algf = NULL;
241 int ssh2bloblen;
242 char *passphrase = NULL;
243 int load_encrypted;
244 progfn_t progressfn = is_interactive() ? progress_update : no_progress;
245
246 /* ------------------------------------------------------------------
247 * Parse the command line to figure out what we've been asked to do.
248 */
249
250 /*
251 * If run with no arguments at all, print the usage message and
252 * return success.
253 */
254 if (argc <= 1) {
255 usage();
256 return 0;
257 }
258
259 /*
260 * Parse command line arguments.
261 */
262 while (--argc) {
263 char *p = *++argv;
264 if (*p == '-') {
265 /*
266 * An option.
267 */
268 while (p && *++p) {
269 char c = *p;
270 switch (c) {
271 case '-':
272 /*
273 * Long option.
274 */
275 {
276 char *opt, *val;
277 opt = p++; /* opt will have _one_ leading - */
278 while (*p && *p != '=')
279 p++; /* find end of option */
280 if (*p == '=') {
281 *p++ = '\0';
282 val = p;
283 } else
284 val = NULL;
285 if (!strcmp(opt, "-help")) {
286 help();
287 nogo = TRUE;
288 } else if (!strcmp(opt, "-version")) {
289 showversion();
290 nogo = TRUE;
291 }
292 /*
293 * A sample option requiring an argument:
294 *
295 * else if (!strcmp(opt, "-output")) {
296 * if (!val)
297 * errs = TRUE, error(err_optnoarg, opt);
298 * else
299 * ofile = val;
300 * }
301 */
302 else {
303 errs = TRUE;
304 fprintf(stderr,
305 "puttygen: no such option `--%s'\n", opt);
306 }
307 }
308 p = NULL;
309 break;
310 case 'h':
311 case 'V':
312 case 'P':
313 case 'l':
314 case 'L':
315 case 'p':
316 case 'q':
317 /*
318 * Option requiring no parameter.
319 */
320 switch (c) {
321 case 'h':
322 help();
323 nogo = TRUE;
324 break;
325 case 'V':
326 showversion();
327 nogo = TRUE;
328 break;
329 case 'P':
330 change_passphrase = TRUE;
331 break;
332 case 'l':
333 outtype = FP;
334 break;
335 case 'L':
336 outtype = PUBLICO;
337 break;
338 case 'p':
339 outtype = PUBLIC;
340 break;
341 case 'q':
342 progressfn = no_progress;
343 break;
344 }
345 break;
346 case 't':
347 case 'b':
348 case 'C':
349 case 'O':
350 case 'o':
351 /*
352 * Option requiring parameter.
353 */
354 p++;
355 if (!*p && argc > 1)
356 --argc, p = *++argv;
357 else if (!*p) {
358 fprintf(stderr, "puttygen: option `-%c' expects a"
359 " parameter\n", c);
360 errs = TRUE;
361 }
362 /*
363 * Now c is the option and p is the parameter.
364 */
365 switch (c) {
366 case 't':
367 if (!strcmp(p, "rsa") || !strcmp(p, "rsa2"))
368 keytype = RSA2, sshver = 2;
369 else if (!strcmp(p, "rsa1"))
370 keytype = RSA1, sshver = 1;
371 else if (!strcmp(p, "dsa") || !strcmp(p, "dss"))
372 keytype = DSA, sshver = 2;
373 else {
374 fprintf(stderr,
375 "puttygen: unknown key type `%s'\n", p);
376 errs = TRUE;
377 }
378 break;
379 case 'b':
380 bits = atoi(p);
381 break;
382 case 'C':
383 comment = p;
384 break;
385 case 'O':
386 if (!strcmp(p, "public"))
387 outtype = PUBLIC;
388 else if (!strcmp(p, "public-openssh"))
389 outtype = PUBLICO;
390 else if (!strcmp(p, "private"))
391 outtype = PRIVATE;
392 else if (!strcmp(p, "fingerprint"))
393 outtype = FP;
394 else if (!strcmp(p, "private-openssh"))
395 outtype = OPENSSH, sshver = 2;
396 else if (!strcmp(p, "private-sshcom"))
397 outtype = SSHCOM, sshver = 2;
398 else {
399 fprintf(stderr,
400 "puttygen: unknown output type `%s'\n", p);
401 errs = TRUE;
402 }
403 break;
404 case 'o':
405 outfile = p;
406 break;
407 }
408 p = NULL; /* prevent continued processing */
409 break;
410 default:
411 /*
412 * Unrecognised option.
413 */
414 errs = TRUE;
415 fprintf(stderr, "puttygen: no such option `-%c'\n", c);
416 break;
417 }
418 }
419 } else {
420 /*
421 * A non-option argument.
422 */
423 if (!infile)
424 infile = p;
425 else {
426 errs = TRUE;
427 fprintf(stderr, "puttygen: cannot handle more than one"
428 " input file\n");
429 }
430 }
431 }
432
433 if (errs)
434 return 1;
435
436 if (nogo)
437 return 0;
438
439 /*
440 * If run with at least one argument _but_ not the required
441 * ones, print the usage message and return failure.
442 */
443 if (!infile && keytype == NOKEYGEN) {
444 usage();
445 return 1;
446 }
447
448 /* ------------------------------------------------------------------
449 * Figure out further details of exactly what we're going to do.
450 */
451
452 /*
453 * Bomb out if we've been asked to both load and generate a
454 * key.
455 */
456 if (keytype != NOKEYGEN && intype) {
457 fprintf(stderr, "puttygen: cannot both load and generate a key\n");
458 return 1;
459 }
460
461 /*
462 * Analyse the type of the input file, in case this affects our
463 * course of action.
464 */
465 if (infile) {
466 infilename = filename_from_str(infile);
467
468 intype = key_type(&infilename);
469
470 switch (intype) {
471 /*
472 * It would be nice here to be able to load _public_
473 * key files, in any of a number of forms, and (a)
474 * convert them to other public key types, (b) print
475 * out their fingerprints. Or, I suppose, for real
476 * orthogonality, (c) change their comment!
477 *
478 * In fact this opens some interesting possibilities.
479 * Suppose ssh2_userkey_loadpub() were able to load
480 * public key files as well as extracting the public
481 * key from private ones. And suppose I did the thing
482 * I've been wanting to do, where specifying a
483 * particular private key file for authentication
484 * causes any _other_ key in the agent to be discarded.
485 * Then, if you had an agent forwarded to the machine
486 * you were running Unix PuTTY or Plink on, and you
487 * needed to specify which of the keys in the agent it
488 * should use, you could do that by supplying a
489 * _public_ key file, thus not needing to trust even
490 * your encrypted private key file to the network. Ooh!
491 */
492
493 case SSH_KEYTYPE_UNOPENABLE:
494 case SSH_KEYTYPE_UNKNOWN:
495 fprintf(stderr, "puttygen: unable to load file `%s': %s\n",
496 infile, key_type_to_str(intype));
497 return 1;
498
499 case SSH_KEYTYPE_SSH1:
500 if (sshver == 2) {
501 fprintf(stderr, "puttygen: conversion from SSH1 to SSH2 keys"
502 " not supported\n");
503 return 1;
504 }
505 sshver = 1;
506 break;
507
508 case SSH_KEYTYPE_SSH2:
509 case SSH_KEYTYPE_OPENSSH:
510 case SSH_KEYTYPE_SSHCOM:
511 if (sshver == 1) {
512 fprintf(stderr, "puttygen: conversion from SSH2 to SSH1 keys"
513 " not supported\n");
514 return 1;
515 }
516 sshver = 2;
517 break;
518 }
519 }
520
521 /*
522 * Determine the default output file, if none is provided.
523 *
524 * This will usually be equal to stdout, except that if the
525 * input and output file formats are the same then the default
526 * output is to overwrite the input.
527 *
528 * Also in this code, we bomb out if the input and output file
529 * formats are the same and no other action is performed.
530 */
531 if ((intype == SSH_KEYTYPE_SSH1 && outtype == PRIVATE) ||
532 (intype == SSH_KEYTYPE_SSH2 && outtype == PRIVATE) ||
533 (intype == SSH_KEYTYPE_OPENSSH && outtype == OPENSSH) ||
534 (intype == SSH_KEYTYPE_SSHCOM && outtype == SSHCOM)) {
535 if (!outfile) {
536 outfile = infile;
537 outfiletmp = dupcat(outfile, ".tmp");
538 }
539
540 if (!change_passphrase && !comment) {
541 fprintf(stderr, "puttygen: this command would perform no useful"
542 " action\n");
543 return 1;
544 }
545 } else {
546 if (!outfile) {
547 /*
548 * Bomb out rather than automatically choosing to write
549 * a private key file to stdout.
550 */
551 if (outtype==PRIVATE || outtype==OPENSSH || outtype==SSHCOM) {
552 fprintf(stderr, "puttygen: need to specify an output file\n");
553 return 1;
554 }
555 }
556 }
557
558 /*
559 * Figure out whether we need to load the encrypted part of the
560 * key. This will be the case if either (a) we need to write
561 * out a private key format, or (b) the entire input key file
562 * is encrypted.
563 */
564 if (outtype == PRIVATE || outtype == OPENSSH || outtype == SSHCOM ||
565 intype == SSH_KEYTYPE_OPENSSH || intype == SSH_KEYTYPE_SSHCOM)
566 load_encrypted = TRUE;
567 else
568 load_encrypted = FALSE;
569
570 /* ------------------------------------------------------------------
571 * Now we're ready to actually do some stuff.
572 */
573
574 /*
575 * Either load or generate a key.
576 */
577 if (keytype != NOKEYGEN) {
578 char *entropy;
579 char default_comment[80];
580 time_t t;
581 struct tm *tm;
582 struct progress prog;
583
584 prog.phase = -1;
585 prog.current = -1;
586
587 time(&t);
588 tm = localtime(&t);
589 if (keytype == DSA)
590 strftime(default_comment, 30, "dsa-key-%Y%m%d", tm);
591 else
592 strftime(default_comment, 30, "rsa-key-%Y%m%d", tm);
593
594 random_init();
595 entropy = get_random_data(bits / 8);
596 random_add_heavynoise(entropy, bits / 8);
597 memset(entropy, 0, bits/8);
598 sfree(entropy);
599
600 if (keytype == DSA) {
601 struct dss_key *dsskey = snew(struct dss_key);
602 dsa_generate(dsskey, bits, progressfn, &prog);
603 ssh2key = snew(struct ssh2_userkey);
604 ssh2key->data = dsskey;
605 ssh2key->alg = &ssh_dss;
606 ssh1key = NULL;
607 } else {
608 struct RSAKey *rsakey = snew(struct RSAKey);
609 rsa_generate(rsakey, bits, progressfn, &prog);
610 if (keytype == RSA1) {
611 ssh1key = rsakey;
612 } else {
613 ssh2key = snew(struct ssh2_userkey);
614 ssh2key->data = rsakey;
615 ssh2key->alg = &ssh_rsa;
616 }
617 }
618 progressfn(&prog, PROGFN_PROGRESS, INT_MAX, -1);
619
620 if (ssh2key)
621 ssh2key->comment = dupstr(default_comment);
622 if (ssh1key)
623 ssh1key->comment = dupstr(default_comment);
624
625 } else {
626 const char *error = NULL;
627 int encrypted;
628
629 assert(infile != NULL);
630
631 /*
632 * Find out whether the input key is encrypted.
633 */
634 if (intype == SSH_KEYTYPE_SSH1)
635 encrypted = rsakey_encrypted(&infilename, &origcomment);
636 else if (intype == SSH_KEYTYPE_SSH2)
637 encrypted = ssh2_userkey_encrypted(&infilename, &origcomment);
638 else
639 encrypted = import_encrypted(&infilename, intype, &origcomment);
640
641 /*
642 * If so, ask for a passphrase.
643 */
644 if (encrypted && load_encrypted) {
645 passphrase = snewn(512, char);
646 if (!console_get_line("Enter passphrase to load key: ",
647 passphrase, 512, TRUE)) {
648 perror("puttygen: unable to read passphrase");
649 return 1;
650 }
651 } else {
652 passphrase = NULL;
653 }
654
655 switch (intype) {
656 int ret;
657
658 case SSH_KEYTYPE_SSH1:
659 ssh1key = snew(struct RSAKey);
660 if (!load_encrypted) {
661 void *vblob;
662 char *blob;
663 int n, bloblen;
664
665 ret = rsakey_pubblob(&infilename, &vblob, &bloblen, &error);
666 blob = (char *)vblob;
667
668 n = 4; /* skip modulus bits */
669 n += ssh1_read_bignum(blob + n, &ssh1key->exponent);
670 n += ssh1_read_bignum(blob + n, &ssh1key->modulus);
671 ssh1key->comment = NULL;
672 } else {
673 ret = loadrsakey(&infilename, ssh1key, passphrase, &error);
674 }
675 if (ret)
676 error = NULL;
677 else if (!error)
678 error = "unknown error";
679 break;
680
681 case SSH_KEYTYPE_SSH2:
682 if (!load_encrypted) {
683 ssh2blob = ssh2_userkey_loadpub(&infilename, &ssh2alg,
684 &ssh2bloblen, &error);
685 ssh2algf = find_pubkey_alg(ssh2alg);
686 if (ssh2algf)
687 bits = ssh2algf->pubkey_bits(ssh2blob, ssh2bloblen);
688 else
689 bits = -1;
690 } else {
691 ssh2key = ssh2_load_userkey(&infilename, passphrase, &error);
692 }
693 if (ssh2key || ssh2blob)
694 error = NULL;
695 else if (!error) {
696 if (ssh2key == SSH2_WRONG_PASSPHRASE)
697 error = "wrong passphrase";
698 else
699 error = "unknown error";
700 }
701 break;
702
703 case SSH_KEYTYPE_OPENSSH:
704 case SSH_KEYTYPE_SSHCOM:
705 ssh2key = import_ssh2(&infilename, intype, passphrase);
706 if (ssh2key)
707 error = NULL;
708 else if (!error) {
709 if (ssh2key == SSH2_WRONG_PASSPHRASE)
710 error = "wrong passphrase";
711 else
712 error = "unknown error";
713 }
714 break;
715
716 default:
717 assert(0);
718 }
719
720 if (error) {
721 fprintf(stderr, "puttygen: error loading `%s': %s\n",
722 infile, error);
723 return 1;
724 }
725 }
726
727 /*
728 * Change the comment if asked to.
729 */
730 if (comment) {
731 if (sshver == 1) {
732 assert(ssh1key);
733 sfree(ssh1key->comment);
734 ssh1key->comment = dupstr(comment);
735 } else {
736 assert(ssh2key);
737 sfree(ssh2key->comment);
738 ssh2key->comment = dupstr(comment);
739 }
740 }
741
742 /*
743 * Prompt for a new passphrase if we have been asked to, or if
744 * we have just generated a key.
745 */
746 if (change_passphrase || keytype != NOKEYGEN) {
747 char *passphrase2;
748
749 if (passphrase) {
750 memset(passphrase, 0, strlen(passphrase));
751 sfree(passphrase);
752 }
753
754 passphrase = snewn(512, char);
755 passphrase2 = snewn(512, char);
756 if (!console_get_line("Enter passphrase to save key: ",
757 passphrase, 512, TRUE) ||
758 !console_get_line("Re-enter passphrase to verify: ",
759 passphrase2, 512, TRUE)) {
760 perror("puttygen: unable to read new passphrase");
761 return 1;
762 }
763 if (strcmp(passphrase, passphrase2)) {
764 fprintf(stderr, "puttygen: passphrases do not match\n");
765 return 1;
766 }
767 memset(passphrase2, 0, strlen(passphrase2));
768 sfree(passphrase2);
769 if (!*passphrase) {
770 sfree(passphrase);
771 passphrase = NULL;
772 }
773 }
774
775 /*
776 * Write output.
777 *
778 * (In the case where outfile and outfiletmp are both NULL,
779 * there is no semantic reason to initialise outfilename at
780 * all; but we have to write _something_ to it or some compiler
781 * will probably complain that it might be used uninitialised.)
782 */
783 if (outfiletmp)
784 outfilename = filename_from_str(outfiletmp);
785 else
786 outfilename = filename_from_str(outfile ? outfile : "");
787
788 switch (outtype) {
789 int ret;
790
791 case PRIVATE:
792 if (sshver == 1) {
793 assert(ssh1key);
794 ret = saversakey(&outfilename, ssh1key, passphrase);
795 if (!ret) {
796 fprintf(stderr, "puttygen: unable to save SSH1 private key\n");
797 return 1;
798 }
799 } else {
800 assert(ssh2key);
801 ret = ssh2_save_userkey(&outfilename, ssh2key, passphrase);
802 if (!ret) {
803 fprintf(stderr, "puttygen: unable to save SSH2 private key\n");
804 return 1;
805 }
806 }
807 if (outfiletmp)
808 move(outfiletmp, outfile);
809 break;
810
811 case PUBLIC:
812 case PUBLICO:
813 if (sshver == 1) {
814 FILE *fp;
815 char *dec1, *dec2;
816
817 assert(ssh1key);
818
819 if (outfile)
820 fp = f_open(outfilename, "w");
821 else
822 fp = stdout;
823 dec1 = bignum_decimal(ssh1key->exponent);
824 dec2 = bignum_decimal(ssh1key->modulus);
825 fprintf(fp, "%d %s %s %s\n", bignum_bitcount(ssh1key->modulus),
826 dec1, dec2, ssh1key->comment);
827 sfree(dec1);
828 sfree(dec2);
829 if (outfile)
830 fclose(fp);
831 } else if (outtype == PUBLIC) {
832 if (!ssh2blob) {
833 assert(ssh2key);
834 ssh2blob = ssh2key->alg->public_blob(ssh2key->data,
835 &ssh2bloblen);
836 }
837 save_ssh2_pubkey(outfile, ssh2key ? ssh2key->comment : origcomment,
838 ssh2blob, ssh2bloblen);
839 } else if (outtype == PUBLICO) {
840 char *buffer, *p;
841 int i;
842 FILE *fp;
843
844 if (!ssh2blob) {
845 assert(ssh2key);
846 ssh2blob = ssh2key->alg->public_blob(ssh2key->data,
847 &ssh2bloblen);
848 }
849 if (!ssh2alg) {
850 assert(ssh2key);
851 ssh2alg = ssh2key->alg->name;
852 }
853 if (ssh2key)
854 comment = ssh2key->comment;
855 else
856 comment = origcomment;
857
858 buffer = snewn(strlen(ssh2alg) +
859 4 * ((ssh2bloblen+2) / 3) +
860 strlen(comment) + 3, char);
861 strcpy(buffer, ssh2alg);
862 p = buffer + strlen(buffer);
863 *p++ = ' ';
864 i = 0;
865 while (i < ssh2bloblen) {
866 int n = (ssh2bloblen - i < 3 ? ssh2bloblen - i : 3);
867 base64_encode_atom(ssh2blob + i, n, p);
868 i += n;
869 p += 4;
870 }
871 if (*comment) {
872 *p++ = ' ';
873 strcpy(p, comment);
874 } else
875 *p++ = '\0';
876
877 if (outfile)
878 fp = f_open(outfilename, "w");
879 else
880 fp = stdout;
881 fprintf(fp, "%s\n", buffer);
882 if (outfile)
883 fclose(fp);
884
885 sfree(buffer);
886 }
887 break;
888
889 case FP:
890 {
891 FILE *fp;
892 char *fingerprint;
893
894 if (sshver == 1) {
895 assert(ssh1key);
896 fingerprint = snewn(128, char);
897 rsa_fingerprint(fingerprint, 128, ssh1key);
898 } else {
899 if (ssh2key) {
900 fingerprint = ssh2key->alg->fingerprint(ssh2key->data);
901 } else {
902 assert(ssh2blob);
903 fingerprint = blobfp(ssh2alg, bits, ssh2blob, ssh2bloblen);
904 }
905 }
906
907 if (outfile)
908 fp = f_open(outfilename, "w");
909 else
910 fp = stdout;
911 fprintf(fp, "%s\n", fingerprint);
912 if (outfile)
913 fclose(fp);
914
915 sfree(fingerprint);
916 }
917 break;
918
919 case OPENSSH:
920 case SSHCOM:
921 assert(sshver == 2);
922 assert(ssh2key);
923 ret = export_ssh2(&outfilename, outtype, ssh2key, passphrase);
924 if (!ret) {
925 fprintf(stderr, "puttygen: unable to export key\n");
926 return 1;
927 }
928 if (outfiletmp)
929 move(outfiletmp, outfile);
930 break;
931 }
932
933 if (passphrase) {
934 memset(passphrase, 0, strlen(passphrase));
935 sfree(passphrase);
936 }
937
938 if (ssh1key)
939 freersakey(ssh1key);
940 if (ssh2key) {
941 ssh2key->alg->freekey(ssh2key->data);
942 sfree(ssh2key);
943 }
944
945 return 0;
946 }
Local modifications for Simon Tatham's `PuTTY' SSH client and terminal emulator