projects / u / mdw / putty / blob
? search:


956cdaf42cba8f6424068282dd9e7803a14385c6
[u/mdw/putty] / puttygen.c
1 /*
2 * PuTTY key generation front end.
3 */
4
5 #include <windows.h>
6 #include <commctrl.h>
7 #include <time.h>
8 #include <stdio.h>
9 #include <stdlib.h>
10
11 #define PUTTY_DO_GLOBALS
12
13 #include "putty.h"
14 #include "ssh.h"
15 #include "winstuff.h"
16
17 #define WM_DONEKEY (WM_XUSER + 1)
18
19 #define DEFAULT_KEYSIZE 1024
20
21 static int requested_help;
22
23 static char *cmdline_keyfile = NULL;
24
25 /*
26 * Print a modal (Really Bad) message box and perform a fatal exit.
27 */
28 void modalfatalbox(char *fmt, ...)
29 {
30 va_list ap;
31 char stuff[200];
32
33 va_start(ap, fmt);
34 vsprintf(stuff, fmt, ap);
35 va_end(ap);
36 MessageBox(NULL, stuff, "PuTTYgen Fatal Error",
37 MB_SYSTEMMODAL | MB_ICONERROR | MB_OK);
38 exit(1);
39 }
40
41 /* ----------------------------------------------------------------------
42 * Progress report code. This is really horrible :-)
43 */
44 #define PROGRESSRANGE 65535
45 #define MAXPHASE 5
46 struct progress {
47 int nphases;
48 struct {
49 int exponential;
50 unsigned startpoint, total;
51 unsigned param, current, n; /* if exponential */
52 unsigned mult; /* if linear */
53 } phases[MAXPHASE];
54 unsigned total, divisor, range;
55 HWND progbar;
56 };
57
58 static void progress_update(void *param, int action, int phase, int iprogress)
59 {
60 struct progress *p = (struct progress *) param;
61 unsigned progress = iprogress;
62 int position;
63
64 if (action < PROGFN_READY && p->nphases < phase)
65 p->nphases = phase;
66 switch (action) {
67 case PROGFN_INITIALISE:
68 p->nphases = 0;
69 break;
70 case PROGFN_LIN_PHASE:
71 p->phases[phase-1].exponential = 0;
72 p->phases[phase-1].mult = p->phases[phase].total / progress;
73 break;
74 case PROGFN_EXP_PHASE:
75 p->phases[phase-1].exponential = 1;
76 p->phases[phase-1].param = 0x10000 + progress;
77 p->phases[phase-1].current = p->phases[phase-1].total;
78 p->phases[phase-1].n = 0;
79 break;
80 case PROGFN_PHASE_EXTENT:
81 p->phases[phase-1].total = progress;
82 break;
83 case PROGFN_READY:
84 {
85 unsigned total = 0;
86 int i;
87 for (i = 0; i < p->nphases; i++) {
88 p->phases[i].startpoint = total;
89 total += p->phases[i].total;
90 }
91 p->total = total;
92 p->divisor = ((p->total + PROGRESSRANGE - 1) / PROGRESSRANGE);
93 p->range = p->total / p->divisor;
94 SendMessage(p->progbar, PBM_SETRANGE, 0, MAKELPARAM(0, p->range));
95 }
96 break;
97 case PROGFN_PROGRESS:
98 if (p->phases[phase-1].exponential) {
99 while (p->phases[phase-1].n < progress) {
100 p->phases[phase-1].n++;
101 p->phases[phase-1].current *= p->phases[phase-1].param;
102 p->phases[phase-1].current /= 0x10000;
103 }
104 position = (p->phases[phase-1].startpoint +
105 p->phases[phase-1].total - p->phases[phase-1].current);
106 } else {
107 position = (p->phases[phase-1].startpoint +
108 progress * p->phases[phase-1].mult);
109 }
110 SendMessage(p->progbar, PBM_SETPOS, position / p->divisor, 0);
111 break;
112 }
113 }
114
115 extern char ver[];
116
117 #define PASSPHRASE_MAXLEN 512
118
119 struct PassphraseProcStruct {
120 char *passphrase;
121 char *comment;
122 };
123
124 /*
125 * Dialog-box function for the passphrase box.
126 */
127 static int CALLBACK PassphraseProc(HWND hwnd, UINT msg,
128 WPARAM wParam, LPARAM lParam)
129 {
130 static char *passphrase = NULL;
131 struct PassphraseProcStruct *p;
132
133 switch (msg) {
134 case WM_INITDIALOG:
135 SetForegroundWindow(hwnd);
136 SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0,
137 SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
138
139 /*
140 * Centre the window.
141 */
142 { /* centre the window */
143 RECT rs, rd;
144 HWND hw;
145
146 hw = GetDesktopWindow();
147 if (GetWindowRect(hw, &rs) && GetWindowRect(hwnd, &rd))
148 MoveWindow(hwnd,
149 (rs.right + rs.left + rd.left - rd.right) / 2,
150 (rs.bottom + rs.top + rd.top - rd.bottom) / 2,
151 rd.right - rd.left, rd.bottom - rd.top, TRUE);
152 }
153
154 p = (struct PassphraseProcStruct *) lParam;
155 passphrase = p->passphrase;
156 if (p->comment)
157 SetDlgItemText(hwnd, 101, p->comment);
158 *passphrase = 0;
159 SetDlgItemText(hwnd, 102, passphrase);
160 return 0;
161 case WM_COMMAND:
162 switch (LOWORD(wParam)) {
163 case IDOK:
164 if (*passphrase)
165 EndDialog(hwnd, 1);
166 else
167 MessageBeep(0);
168 return 0;
169 case IDCANCEL:
170 EndDialog(hwnd, 0);
171 return 0;
172 case 102: /* edit box */
173 if ((HIWORD(wParam) == EN_CHANGE) && passphrase) {
174 GetDlgItemText(hwnd, 102, passphrase,
175 PASSPHRASE_MAXLEN - 1);
176 passphrase[PASSPHRASE_MAXLEN - 1] = '\0';
177 }
178 return 0;
179 }
180 return 0;
181 case WM_CLOSE:
182 EndDialog(hwnd, 0);
183 return 0;
184 }
185 return 0;
186 }
187
188 /*
189 * Prompt for a key file. Assumes the filename buffer is of size
190 * FILENAME_MAX.
191 */
192 static int prompt_keyfile(HWND hwnd, char *dlgtitle,
193 char *filename, int save, int ppk)
194 {
195 OPENFILENAME of;
196 memset(&of, 0, sizeof(of));
197 #ifdef OPENFILENAME_SIZE_VERSION_400
198 of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
199 #else
200 of.lStructSize = sizeof(of);
201 #endif
202 of.hwndOwner = hwnd;
203 if (ppk) {
204 of.lpstrFilter = "PuTTY Private Key Files\0*.PPK\0All Files\0*\0\0\0";
205 of.lpstrDefExt = ".ppk";
206 } else {
207 of.lpstrFilter = "All Files\0*\0\0\0";
208 }
209 of.lpstrCustomFilter = NULL;
210 of.nFilterIndex = 1;
211 of.lpstrFile = filename;
212 *filename = '\0';
213 of.nMaxFile = FILENAME_MAX;
214 of.lpstrFileTitle = NULL;
215 of.lpstrInitialDir = NULL;
216 of.lpstrTitle = dlgtitle;
217 of.Flags = 0;
218 if (save)
219 return GetSaveFileName(&of);
220 else
221 return GetOpenFileName(&of);
222 }
223
224 /*
225 * Dialog-box function for the Licence box.
226 */
227 static int CALLBACK LicenceProc(HWND hwnd, UINT msg,
228 WPARAM wParam, LPARAM lParam)
229 {
230 switch (msg) {
231 case WM_INITDIALOG:
232 /*
233 * Centre the window.
234 */
235 { /* centre the window */
236 RECT rs, rd;
237 HWND hw;
238
239 hw = GetDesktopWindow();
240 if (GetWindowRect(hw, &rs) && GetWindowRect(hwnd, &rd))
241 MoveWindow(hwnd,
242 (rs.right + rs.left + rd.left - rd.right) / 2,
243 (rs.bottom + rs.top + rd.top - rd.bottom) / 2,
244 rd.right - rd.left, rd.bottom - rd.top, TRUE);
245 }
246
247 return 1;
248 case WM_COMMAND:
249 switch (LOWORD(wParam)) {
250 case IDOK:
251 EndDialog(hwnd, 1);
252 return 0;
253 }
254 return 0;
255 case WM_CLOSE:
256 EndDialog(hwnd, 1);
257 return 0;
258 }
259 return 0;
260 }
261
262 /*
263 * Dialog-box function for the About box.
264 */
265 static int CALLBACK AboutProc(HWND hwnd, UINT msg,
266 WPARAM wParam, LPARAM lParam)
267 {
268 switch (msg) {
269 case WM_INITDIALOG:
270 /*
271 * Centre the window.
272 */
273 { /* centre the window */
274 RECT rs, rd;
275 HWND hw;
276
277 hw = GetDesktopWindow();
278 if (GetWindowRect(hw, &rs) && GetWindowRect(hwnd, &rd))
279 MoveWindow(hwnd,
280 (rs.right + rs.left + rd.left - rd.right) / 2,
281 (rs.bottom + rs.top + rd.top - rd.bottom) / 2,
282 rd.right - rd.left, rd.bottom - rd.top, TRUE);
283 }
284
285 SetDlgItemText(hwnd, 100, ver);
286 return 1;
287 case WM_COMMAND:
288 switch (LOWORD(wParam)) {
289 case IDOK:
290 EndDialog(hwnd, 1);
291 return 0;
292 case 101:
293 EnableWindow(hwnd, 0);
294 DialogBox(hinst, MAKEINTRESOURCE(214), NULL, LicenceProc);
295 EnableWindow(hwnd, 1);
296 SetActiveWindow(hwnd);
297 return 0;
298 }
299 return 0;
300 case WM_CLOSE:
301 EndDialog(hwnd, 1);
302 return 0;
303 }
304 return 0;
305 }
306
307 /*
308 * Thread to generate a key.
309 */
310 struct rsa_key_thread_params {
311 HWND progressbar; /* notify this with progress */
312 HWND dialog; /* notify this on completion */
313 int keysize; /* bits in key */
314 int is_dsa;
315 struct RSAKey *key;
316 struct dss_key *dsskey;
317 };
318 static DWORD WINAPI generate_rsa_key_thread(void *param)
319 {
320 struct rsa_key_thread_params *params =
321 (struct rsa_key_thread_params *) param;
322 struct progress prog;
323 prog.progbar = params->progressbar;
324
325 progress_update(&prog, PROGFN_INITIALISE, 0, 0);
326
327 if (params->is_dsa)
328 dsa_generate(params->dsskey, params->keysize, progress_update, &prog);
329 else
330 rsa_generate(params->key, params->keysize, progress_update, &prog);
331
332 PostMessage(params->dialog, WM_DONEKEY, 0, 0);
333
334 sfree(params);
335 return 0;
336 }
337
338 struct MainDlgState {
339 int collecting_entropy;
340 int generation_thread_exists;
341 int key_exists;
342 int entropy_got, entropy_required, entropy_size;
343 int keysize;
344 int ssh2, is_dsa;
345 char **commentptr; /* points to key.comment or ssh2key.comment */
346 struct ssh2_userkey ssh2key;
347 unsigned *entropy;
348 struct RSAKey key;
349 struct dss_key dsskey;
350 HMENU filemenu, keymenu, cvtmenu;
351 };
352
353 static void hidemany(HWND hwnd, const int *ids, int hideit)
354 {
355 while (*ids) {
356 ShowWindow(GetDlgItem(hwnd, *ids++), (hideit ? SW_HIDE : SW_SHOW));
357 }
358 }
359
360 static void setupbigedit1(HWND hwnd, int id, int idstatic, struct RSAKey *key)
361 {
362 char *buffer;
363 char *dec1, *dec2;
364
365 dec1 = bignum_decimal(key->exponent);
366 dec2 = bignum_decimal(key->modulus);
367 buffer = smalloc(strlen(dec1) + strlen(dec2) +
368 strlen(key->comment) + 30);
369 sprintf(buffer, "%d %s %s %s",
370 bignum_bitcount(key->modulus), dec1, dec2, key->comment);
371 SetDlgItemText(hwnd, id, buffer);
372 SetDlgItemText(hwnd, idstatic,
373 "&Public key for pasting into authorized_keys file:");
374 sfree(dec1);
375 sfree(dec2);
376 sfree(buffer);
377 }
378
379 static void setupbigedit2(HWND hwnd, int id, int idstatic,
380 struct ssh2_userkey *key)
381 {
382 unsigned char *pub_blob;
383 char *buffer, *p;
384 int pub_len;
385 int i;
386
387 pub_blob = key->alg->public_blob(key->data, &pub_len);
388 buffer = smalloc(strlen(key->alg->name) + 4 * ((pub_len + 2) / 3) +
389 strlen(key->comment) + 3);
390 strcpy(buffer, key->alg->name);
391 p = buffer + strlen(buffer);
392 *p++ = ' ';
393 i = 0;
394 while (i < pub_len) {
395 int n = (pub_len - i < 3 ? pub_len - i : 3);
396 base64_encode_atom(pub_blob + i, n, p);
397 i += n;
398 p += 4;
399 }
400 *p++ = ' ';
401 strcpy(p, key->comment);
402 SetDlgItemText(hwnd, id, buffer);
403 SetDlgItemText(hwnd, idstatic, "&Public key for pasting into "
404 "OpenSSH authorized_keys2 file:");
405 sfree(pub_blob);
406 sfree(buffer);
407 }
408
409 static int save_ssh1_pubkey(char *filename, struct RSAKey *key)
410 {
411 char *dec1, *dec2;
412 FILE *fp;
413
414 dec1 = bignum_decimal(key->exponent);
415 dec2 = bignum_decimal(key->modulus);
416 fp = fopen(filename, "wb");
417 if (!fp)
418 return 0;
419 fprintf(fp, "%d %s %s %s\n",
420 bignum_bitcount(key->modulus), dec1, dec2, key->comment);
421 fclose(fp);
422 sfree(dec1);
423 sfree(dec2);
424 return 1;
425 }
426
427 /*
428 * Warn about the obsolescent key file format.
429 */
430 void old_keyfile_warning(void)
431 {
432 static const char mbtitle[] = "PuTTY Key File Warning";
433 static const char message[] =
434 "You are loading an SSH 2 private key which has an\n"
435 "old version of the file format. This means your key\n"
436 "file is not fully tamperproof. Future versions of\n"
437 "PuTTY may stop supporting this private key format,\n"
438 "so we recommend you convert your key to the new\n"
439 "format.\n"
440 "\n"
441 "Once the key is loaded into PuTTYgen, you can perform\n"
442 "this conversion simply by saving it again.";
443
444 MessageBox(NULL, message, mbtitle, MB_OK);
445 }
446
447 static int save_ssh2_pubkey(char *filename, struct ssh2_userkey *key)
448 {
449 unsigned char *pub_blob;
450 char *p;
451 int pub_len;
452 int i, column;
453 FILE *fp;
454
455 pub_blob = key->alg->public_blob(key->data, &pub_len);
456
457 fp = fopen(filename, "wb");
458 if (!fp)
459 return 0;
460
461 fprintf(fp, "---- BEGIN SSH2 PUBLIC KEY ----\n");
462
463 fprintf(fp, "Comment: \"");
464 for (p = key->comment; *p; p++) {
465 if (*p == '\\' || *p == '\"')
466 fputc('\\', fp);
467 fputc(*p, fp);
468 }
469 fprintf(fp, "\"\n");
470
471 i = 0;
472 column = 0;
473 while (i < pub_len) {
474 char buf[5];
475 int n = (pub_len - i < 3 ? pub_len - i : 3);
476 base64_encode_atom(pub_blob + i, n, buf);
477 i += n;
478 buf[4] = '\0';
479 fputs(buf, fp);
480 if (++column >= 16) {
481 fputc('\n', fp);
482 column = 0;
483 }
484 }
485 if (column > 0)
486 fputc('\n', fp);
487
488 fprintf(fp, "---- END SSH2 PUBLIC KEY ----\n");
489 fclose(fp);
490 sfree(pub_blob);
491 return 1;
492 }
493
494 enum {
495 controlidstart = 100,
496 IDC_QUIT,
497 IDC_TITLE,
498 IDC_BOX_KEY,
499 IDC_NOKEY,
500 IDC_GENERATING,
501 IDC_PROGRESS,
502 IDC_PKSTATIC, IDC_KEYDISPLAY,
503 IDC_FPSTATIC, IDC_FINGERPRINT,
504 IDC_COMMENTSTATIC, IDC_COMMENTEDIT,
505 IDC_PASSPHRASE1STATIC, IDC_PASSPHRASE1EDIT,
506 IDC_PASSPHRASE2STATIC, IDC_PASSPHRASE2EDIT,
507 IDC_BOX_ACTIONS,
508 IDC_GENSTATIC, IDC_GENERATE,
509 IDC_LOADSTATIC, IDC_LOAD,
510 IDC_SAVESTATIC, IDC_SAVE, IDC_SAVEPUB,
511 IDC_BOX_PARAMS,
512 IDC_TYPESTATIC, IDC_KEYSSH1, IDC_KEYSSH2RSA, IDC_KEYSSH2DSA,
513 IDC_BITSSTATIC, IDC_BITS,
514 IDC_ABOUT,
515 IDC_GIVEHELP,
516 IDC_IMPORT, IDC_EXPORT_OPENSSH, IDC_EXPORT_SSHCOM
517 };
518
519 static const int nokey_ids[] = { IDC_NOKEY, 0 };
520 static const int generating_ids[] = { IDC_GENERATING, IDC_PROGRESS, 0 };
521 static const int gotkey_ids[] = {
522 IDC_PKSTATIC, IDC_KEYDISPLAY,
523 IDC_FPSTATIC, IDC_FINGERPRINT,
524 IDC_COMMENTSTATIC, IDC_COMMENTEDIT,
525 IDC_PASSPHRASE1STATIC, IDC_PASSPHRASE1EDIT,
526 IDC_PASSPHRASE2STATIC, IDC_PASSPHRASE2EDIT, 0
527 };
528
529 /*
530 * Small UI helper function to switch the state of the main dialog
531 * by enabling and disabling controls and menu items.
532 */
533 void ui_set_state(HWND hwnd, struct MainDlgState *state, int status)
534 {
535 int type;
536
537 switch (status) {
538 case 0: /* no key */
539 hidemany(hwnd, nokey_ids, FALSE);
540 hidemany(hwnd, generating_ids, TRUE);
541 hidemany(hwnd, gotkey_ids, TRUE);
542 EnableWindow(GetDlgItem(hwnd, IDC_GENERATE), 1);
543 EnableWindow(GetDlgItem(hwnd, IDC_LOAD), 1);
544 EnableWindow(GetDlgItem(hwnd, IDC_SAVE), 0);
545 EnableWindow(GetDlgItem(hwnd, IDC_SAVEPUB), 0);
546 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH1), 1);
547 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2RSA), 1);
548 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2DSA), 1);
549 EnableWindow(GetDlgItem(hwnd, IDC_BITS), 1);
550 EnableMenuItem(state->filemenu, IDC_LOAD, MF_ENABLED|MF_BYCOMMAND);
551 EnableMenuItem(state->filemenu, IDC_SAVE, MF_GRAYED|MF_BYCOMMAND);
552 EnableMenuItem(state->filemenu, IDC_SAVEPUB, MF_GRAYED|MF_BYCOMMAND);
553 EnableMenuItem(state->keymenu, IDC_GENERATE, MF_ENABLED|MF_BYCOMMAND);
554 EnableMenuItem(state->keymenu, IDC_KEYSSH1, MF_ENABLED|MF_BYCOMMAND);
555 EnableMenuItem(state->keymenu, IDC_KEYSSH2RSA, MF_ENABLED|MF_BYCOMMAND);
556 EnableMenuItem(state->keymenu, IDC_KEYSSH2DSA, MF_ENABLED|MF_BYCOMMAND);
557 EnableMenuItem(state->cvtmenu, IDC_IMPORT, MF_ENABLED|MF_BYCOMMAND);
558 EnableMenuItem(state->cvtmenu, IDC_EXPORT_OPENSSH,
559 MF_GRAYED|MF_BYCOMMAND);
560 EnableMenuItem(state->cvtmenu, IDC_EXPORT_SSHCOM,
561 MF_GRAYED|MF_BYCOMMAND);
562 break;
563 case 1: /* generating key */
564 hidemany(hwnd, nokey_ids, TRUE);
565 hidemany(hwnd, generating_ids, FALSE);
566 hidemany(hwnd, gotkey_ids, TRUE);
567 EnableWindow(GetDlgItem(hwnd, IDC_GENERATE), 0);
568 EnableWindow(GetDlgItem(hwnd, IDC_LOAD), 0);
569 EnableWindow(GetDlgItem(hwnd, IDC_SAVE), 0);
570 EnableWindow(GetDlgItem(hwnd, IDC_SAVEPUB), 0);
571 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH1), 0);
572 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2RSA), 0);
573 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2DSA), 0);
574 EnableWindow(GetDlgItem(hwnd, IDC_BITS), 0);
575 EnableMenuItem(state->filemenu, IDC_LOAD, MF_GRAYED|MF_BYCOMMAND);
576 EnableMenuItem(state->filemenu, IDC_SAVE, MF_GRAYED|MF_BYCOMMAND);
577 EnableMenuItem(state->filemenu, IDC_SAVEPUB, MF_GRAYED|MF_BYCOMMAND);
578 EnableMenuItem(state->keymenu, IDC_GENERATE, MF_GRAYED|MF_BYCOMMAND);
579 EnableMenuItem(state->keymenu, IDC_KEYSSH1, MF_GRAYED|MF_BYCOMMAND);
580 EnableMenuItem(state->keymenu, IDC_KEYSSH2RSA, MF_GRAYED|MF_BYCOMMAND);
581 EnableMenuItem(state->keymenu, IDC_KEYSSH2DSA, MF_GRAYED|MF_BYCOMMAND);
582 EnableMenuItem(state->cvtmenu, IDC_IMPORT, MF_GRAYED|MF_BYCOMMAND);
583 EnableMenuItem(state->cvtmenu, IDC_EXPORT_OPENSSH,
584 MF_GRAYED|MF_BYCOMMAND);
585 EnableMenuItem(state->cvtmenu, IDC_EXPORT_SSHCOM,
586 MF_GRAYED|MF_BYCOMMAND);
587 break;
588 case 2:
589 hidemany(hwnd, nokey_ids, TRUE);
590 hidemany(hwnd, generating_ids, TRUE);
591 hidemany(hwnd, gotkey_ids, FALSE);
592 EnableWindow(GetDlgItem(hwnd, IDC_GENERATE), 1);
593 EnableWindow(GetDlgItem(hwnd, IDC_LOAD), 1);
594 EnableWindow(GetDlgItem(hwnd, IDC_SAVE), 1);
595 EnableWindow(GetDlgItem(hwnd, IDC_SAVEPUB), 1);
596 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH1), 1);
597 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2RSA), 1);
598 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2DSA), 1);
599 EnableWindow(GetDlgItem(hwnd, IDC_BITS), 1);
600 EnableMenuItem(state->filemenu, IDC_LOAD, MF_ENABLED|MF_BYCOMMAND);
601 EnableMenuItem(state->filemenu, IDC_SAVE, MF_ENABLED|MF_BYCOMMAND);
602 EnableMenuItem(state->filemenu, IDC_SAVEPUB, MF_ENABLED|MF_BYCOMMAND);
603 EnableMenuItem(state->keymenu, IDC_GENERATE, MF_ENABLED|MF_BYCOMMAND);
604 EnableMenuItem(state->keymenu, IDC_KEYSSH1, MF_ENABLED|MF_BYCOMMAND);
605 EnableMenuItem(state->keymenu, IDC_KEYSSH2RSA,MF_ENABLED|MF_BYCOMMAND);
606 EnableMenuItem(state->keymenu, IDC_KEYSSH2DSA,MF_ENABLED|MF_BYCOMMAND);
607 EnableMenuItem(state->cvtmenu, IDC_IMPORT, MF_ENABLED|MF_BYCOMMAND);
608 /*
609 * Enable export menu items if and only if the key type
610 * supports this kind of export.
611 */
612 type = state->ssh2 ? SSH_KEYTYPE_SSH2 : SSH_KEYTYPE_SSH1;
613 #define do_export_menuitem(x,y) \
614 EnableMenuItem(state->cvtmenu, x, MF_BYCOMMAND | \
615 (import_target_type(y)==type?MF_ENABLED:MF_GRAYED))
616 do_export_menuitem(IDC_EXPORT_OPENSSH, SSH_KEYTYPE_OPENSSH);
617 do_export_menuitem(IDC_EXPORT_SSHCOM, SSH_KEYTYPE_SSHCOM);
618 #undef do_export_menuitem
619 break;
620 }
621 }
622
623 void load_key_file(HWND hwnd, struct MainDlgState *state,
624 char *filename, int was_import_cmd)
625 {
626 char passphrase[PASSPHRASE_MAXLEN];
627 int needs_pass;
628 int type, realtype;
629 int ret;
630 char *comment;
631 struct PassphraseProcStruct pps;
632 struct RSAKey newkey1;
633 struct ssh2_userkey *newkey2 = NULL;
634
635 type = realtype = key_type(filename);
636 if (type != SSH_KEYTYPE_SSH1 &&
637 type != SSH_KEYTYPE_SSH2 &&
638 !import_possible(type)) {
639 char msg[256];
640 sprintf(msg, "Couldn't load private key (%s)",
641 key_type_to_str(type));
642 MessageBox(NULL, msg,
643 "PuTTYgen Error", MB_OK | MB_ICONERROR);
644 return;
645 }
646
647 if (type != SSH_KEYTYPE_SSH1 &&
648 type != SSH_KEYTYPE_SSH2) {
649 realtype = type;
650 type = import_target_type(type);
651 }
652
653 comment = NULL;
654 if (realtype == SSH_KEYTYPE_SSH1)
655 needs_pass = rsakey_encrypted(filename, &comment);
656 else if (realtype == SSH_KEYTYPE_SSH2)
657 needs_pass =
658 ssh2_userkey_encrypted(filename, &comment);
659 else
660 needs_pass = import_encrypted(filename, realtype,
661 &comment);
662 pps.passphrase = passphrase;
663 pps.comment = comment;
664 do {
665 if (needs_pass) {
666 int dlgret;
667 dlgret = DialogBoxParam(hinst,
668 MAKEINTRESOURCE(210),
669 NULL, PassphraseProc,
670 (LPARAM) & pps);
671 if (!dlgret) {
672 ret = -2;
673 break;
674 }
675 } else
676 *passphrase = '\0';
677 if (type == SSH_KEYTYPE_SSH1) {
678 if (realtype == type)
679 ret = loadrsakey(filename, &newkey1,
680 passphrase);
681 else
682 ret = import_ssh1(filename, realtype,
683 &newkey1, passphrase);
684 } else {
685 if (realtype == type)
686 newkey2 = ssh2_load_userkey(filename,
687 passphrase);
688 else
689 newkey2 = import_ssh2(filename, realtype,
690 passphrase);
691 if (newkey2 == SSH2_WRONG_PASSPHRASE)
692 ret = -1;
693 else if (!newkey2)
694 ret = 0;
695 else
696 ret = 1;
697 }
698 } while (ret == -1);
699 if (comment)
700 sfree(comment);
701 if (ret == 0) {
702 MessageBox(NULL, "Couldn't load private key.",
703 "PuTTYgen Error", MB_OK | MB_ICONERROR);
704 } else if (ret == 1) {
705 /*
706 * Now update the key controls with all the
707 * key data.
708 */
709 {
710 SetDlgItemText(hwnd, IDC_PASSPHRASE1EDIT,
711 passphrase);
712 SetDlgItemText(hwnd, IDC_PASSPHRASE2EDIT,
713 passphrase);
714 if (type == SSH_KEYTYPE_SSH1) {
715 char buf[128];
716 char *savecomment;
717
718 state->ssh2 = FALSE;
719 state->commentptr = &state->key.comment;
720 state->key = newkey1;
721
722 /*
723 * Set the key fingerprint.
724 */
725 savecomment = state->key.comment;
726 state->key.comment = NULL;
727 rsa_fingerprint(buf, sizeof(buf),
728 &state->key);
729 state->key.comment = savecomment;
730
731 SetDlgItemText(hwnd, IDC_FINGERPRINT, buf);
732 /*
733 * Construct a decimal representation
734 * of the key, for pasting into
735 * .ssh/authorized_keys on a Unix box.
736 */
737 setupbigedit1(hwnd, IDC_KEYDISPLAY,
738 IDC_PKSTATIC, &state->key);
739 } else {
740 char *fp;
741 char *savecomment;
742
743 state->ssh2 = TRUE;
744 state->commentptr =
745 &state->ssh2key.comment;
746 state->ssh2key = *newkey2; /* structure copy */
747 sfree(newkey2);
748
749 savecomment = state->ssh2key.comment;
750 state->ssh2key.comment = NULL;
751 fp =
752 state->ssh2key.alg->
753 fingerprint(state->ssh2key.data);
754 state->ssh2key.comment = savecomment;
755
756 SetDlgItemText(hwnd, IDC_FINGERPRINT, fp);
757 sfree(fp);
758
759 setupbigedit2(hwnd, IDC_KEYDISPLAY,
760 IDC_PKSTATIC, &state->ssh2key);
761 }
762 SetDlgItemText(hwnd, IDC_COMMENTEDIT,
763 *state->commentptr);
764 }
765 /*
766 * Finally, hide the progress bar and show
767 * the key data.
768 */
769 ui_set_state(hwnd, state, 2);
770 state->key_exists = TRUE;
771
772 /*
773 * If the user has imported a foreign key
774 * using the Load command, let them know.
775 * If they've used the Import command, be
776 * silent.
777 */
778 if (realtype != type && !was_import_cmd) {
779 char msg[512];
780 sprintf(msg, "Successfully imported foreign key\n"
781 "(%s).\n"
782 "To use this key with PuTTY, you need to\n"
783 "use the \"Save private key\" command to\n"
784 "save it in PuTTY's own format.",
785 key_type_to_str(realtype));
786 MessageBox(NULL, msg, "PuTTYgen Notice",
787 MB_OK | MB_ICONINFORMATION);
788 }
789 }
790 }
791
792 /*
793 * Dialog-box function for the main PuTTYgen dialog box.
794 */
795 static int CALLBACK MainDlgProc(HWND hwnd, UINT msg,
796 WPARAM wParam, LPARAM lParam)
797 {
798 static const char generating_msg[] =
799 "Please wait while a key is generated...";
800 static const char entropy_msg[] =
801 "Please generate some randomness by moving the mouse over the blank area.";
802 struct MainDlgState *state;
803
804 switch (msg) {
805 case WM_INITDIALOG:
806 if (help_path)
807 SetWindowLong(hwnd, GWL_EXSTYLE,
808 GetWindowLong(hwnd, GWL_EXSTYLE) | WS_EX_CONTEXTHELP);
809 else {
810 /*
811 * If we add a Help button, this is where we destroy it
812 * if the help file isn't present.
813 */
814 }
815 requested_help = FALSE;
816
817 state = smalloc(sizeof(*state));
818 state->generation_thread_exists = FALSE;
819 state->collecting_entropy = FALSE;
820 state->entropy = NULL;
821 state->key_exists = FALSE;
822 SetWindowLong(hwnd, GWL_USERDATA, (LONG) state);
823 {
824 HMENU menu, menu1;
825
826 menu = CreateMenu();
827
828 menu1 = CreateMenu();
829 AppendMenu(menu1, MF_ENABLED, IDC_LOAD, "&Load private key");
830 AppendMenu(menu1, MF_ENABLED, IDC_SAVEPUB, "Save p&ublic key");
831 AppendMenu(menu1, MF_ENABLED, IDC_SAVE, "&Save private key");
832 AppendMenu(menu1, MF_SEPARATOR, 0, 0);
833 AppendMenu(menu1, MF_ENABLED, IDC_QUIT, "E&xit");
834 AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1, "&File");
835 state->filemenu = menu1;
836
837 menu1 = CreateMenu();
838 AppendMenu(menu1, MF_ENABLED, IDC_GENERATE, "&Generate key pair");
839 AppendMenu(menu1, MF_SEPARATOR, 0, 0);
840 AppendMenu(menu1, MF_ENABLED, IDC_KEYSSH1, "SSH&1 key (RSA)");
841 AppendMenu(menu1, MF_ENABLED, IDC_KEYSSH2RSA, "SSH2 &RSA key");
842 AppendMenu(menu1, MF_ENABLED, IDC_KEYSSH2DSA, "SSH2 &DSA key");
843 AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1, "&Key");
844 state->keymenu = menu1;
845
846 menu1 = CreateMenu();
847 AppendMenu(menu1, MF_ENABLED, IDC_IMPORT, "&Import key");
848 AppendMenu(menu1, MF_SEPARATOR, 0, 0);
849 AppendMenu(menu1, MF_ENABLED, IDC_EXPORT_OPENSSH,
850 "Export &OpenSSH key");
851 AppendMenu(menu1, MF_ENABLED, IDC_EXPORT_SSHCOM,
852 "Export &ssh.com key");
853 AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1,
854 "&Conversions");
855 state->cvtmenu = menu1;
856
857 menu1 = CreateMenu();
858 AppendMenu(menu1, MF_ENABLED, IDC_ABOUT, "&About");
859 if (help_path)
860 AppendMenu(menu1, MF_ENABLED, IDC_GIVEHELP, "&Help");
861 AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1, "&Help");
862
863 SetMenu(hwnd, menu);
864 }
865
866 /*
867 * Centre the window.
868 */
869 { /* centre the window */
870 RECT rs, rd;
871 HWND hw;
872
873 hw = GetDesktopWindow();
874 if (GetWindowRect(hw, &rs) && GetWindowRect(hwnd, &rd))
875 MoveWindow(hwnd,
876 (rs.right + rs.left + rd.left - rd.right) / 2,
877 (rs.bottom + rs.top + rd.top - rd.bottom) / 2,
878 rd.right - rd.left, rd.bottom - rd.top, TRUE);
879 }
880
881 {
882 struct ctlpos cp, cp2;
883
884 /* Accelerators used: acglops1rbd */
885
886 ctlposinit(&cp, hwnd, 4, 4, 4);
887 beginbox(&cp, "Key", IDC_BOX_KEY);
888 cp2 = cp;
889 statictext(&cp2, "No key.", 1, IDC_NOKEY);
890 cp2 = cp;
891 statictext(&cp2, "", 1, IDC_GENERATING);
892 progressbar(&cp2, IDC_PROGRESS);
893 bigeditctrl(&cp,
894 "&Public key for pasting into authorized_keys file:",
895 IDC_PKSTATIC, IDC_KEYDISPLAY, 5);
896 SendDlgItemMessage(hwnd, IDC_KEYDISPLAY, EM_SETREADONLY, 1, 0);
897 staticedit(&cp, "Key fingerprint:", IDC_FPSTATIC,
898 IDC_FINGERPRINT, 75);
899 SendDlgItemMessage(hwnd, IDC_FINGERPRINT, EM_SETREADONLY, 1,
900 0);
901 staticedit(&cp, "Key &comment:", IDC_COMMENTSTATIC,
902 IDC_COMMENTEDIT, 75);
903 staticpassedit(&cp, "Key p&assphrase:", IDC_PASSPHRASE1STATIC,
904 IDC_PASSPHRASE1EDIT, 75);
905 staticpassedit(&cp, "C&onfirm passphrase:",
906 IDC_PASSPHRASE2STATIC, IDC_PASSPHRASE2EDIT, 75);
907 endbox(&cp);
908 beginbox(&cp, "Actions", IDC_BOX_ACTIONS);
909 staticbtn(&cp, "Generate a public/private key pair",
910 IDC_GENSTATIC, "&Generate", IDC_GENERATE);
911 staticbtn(&cp, "Load an existing private key file",
912 IDC_LOADSTATIC, "&Load", IDC_LOAD);
913 static2btn(&cp, "Save the generated key", IDC_SAVESTATIC,
914 "Save p&ublic key", IDC_SAVEPUB,
915 "&Save private key", IDC_SAVE);
916 endbox(&cp);
917 beginbox(&cp, "Parameters", IDC_BOX_PARAMS);
918 radioline(&cp, "Type of key to generate:", IDC_TYPESTATIC, 3,
919 "SSH&1 (RSA)", IDC_KEYSSH1,
920 "SSH2 &RSA", IDC_KEYSSH2RSA,
921 "SSH2 &DSA", IDC_KEYSSH2DSA, NULL);
922 staticedit(&cp, "Number of &bits in a generated key:",
923 IDC_BITSSTATIC, IDC_BITS, 20);
924 endbox(&cp);
925 }
926 CheckRadioButton(hwnd, IDC_KEYSSH1, IDC_KEYSSH2DSA, IDC_KEYSSH1);
927 CheckMenuRadioItem(state->keymenu, IDC_KEYSSH1, IDC_KEYSSH2DSA,
928 IDC_KEYSSH1, MF_BYCOMMAND);
929 SetDlgItemInt(hwnd, IDC_BITS, DEFAULT_KEYSIZE, FALSE);
930
931 /*
932 * Initially, hide the progress bar and the key display,
933 * and show the no-key display. Also disable the Save
934 * buttons, because with no key we obviously can't save
935 * anything.
936 */
937 ui_set_state(hwnd, state, 0);
938
939 /*
940 * Load a key file if one was provided on the command line.
941 */
942 if (cmdline_keyfile)
943 load_key_file(hwnd, state, cmdline_keyfile, 0);
944
945 return 1;
946 case WM_MOUSEMOVE:
947 state = (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
948 if (state->collecting_entropy &&
949 state->entropy && state->entropy_got < state->entropy_required) {
950 state->entropy[state->entropy_got++] = lParam;
951 state->entropy[state->entropy_got++] = GetMessageTime();
952 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS,
953 state->entropy_got, 0);
954 if (state->entropy_got >= state->entropy_required) {
955 struct rsa_key_thread_params *params;
956 DWORD threadid;
957
958 /*
959 * Seed the entropy pool
960 */
961 random_add_heavynoise(state->entropy, state->entropy_size);
962 memset(state->entropy, 0, state->entropy_size);
963 sfree(state->entropy);
964 state->collecting_entropy = FALSE;
965
966 SetDlgItemText(hwnd, IDC_GENERATING, generating_msg);
967 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETRANGE, 0,
968 MAKELPARAM(0, PROGRESSRANGE));
969 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS, 0, 0);
970
971 params = smalloc(sizeof(*params));
972 params->progressbar = GetDlgItem(hwnd, IDC_PROGRESS);
973 params->dialog = hwnd;
974 params->keysize = state->keysize;
975 params->is_dsa = state->is_dsa;
976 params->key = &state->key;
977 params->dsskey = &state->dsskey;
978
979 if (!CreateThread(NULL, 0, generate_rsa_key_thread,
980 params, 0, &threadid)) {
981 MessageBox(hwnd, "Out of thread resources",
982 "Key generation error",
983 MB_OK | MB_ICONERROR);
984 sfree(params);
985 } else {
986 state->generation_thread_exists = TRUE;
987 }
988 }
989 }
990 break;
991 case WM_COMMAND:
992 switch (LOWORD(wParam)) {
993 case IDC_KEYSSH1:
994 case IDC_KEYSSH2RSA:
995 case IDC_KEYSSH2DSA:
996 {
997 state = (struct MainDlgState *)
998 GetWindowLong(hwnd, GWL_USERDATA);
999 if (!IsDlgButtonChecked(hwnd, LOWORD(wParam)))
1000 CheckRadioButton(hwnd, IDC_KEYSSH1, IDC_KEYSSH2DSA,
1001 LOWORD(wParam));
1002 CheckMenuRadioItem(state->keymenu, IDC_KEYSSH1, IDC_KEYSSH2DSA,
1003 LOWORD(wParam), MF_BYCOMMAND);
1004 }
1005 break;
1006 case IDC_QUIT:
1007 PostMessage(hwnd, WM_CLOSE, 0, 0);
1008 break;
1009 case IDC_COMMENTEDIT:
1010 if (HIWORD(wParam) == EN_CHANGE) {
1011 state = (struct MainDlgState *)
1012 GetWindowLong(hwnd, GWL_USERDATA);
1013 if (state->key_exists) {
1014 HWND editctl = GetDlgItem(hwnd, IDC_COMMENTEDIT);
1015 int len = GetWindowTextLength(editctl);
1016 if (*state->commentptr)
1017 sfree(*state->commentptr);
1018 *state->commentptr = smalloc(len + 1);
1019 GetWindowText(editctl, *state->commentptr, len + 1);
1020 if (state->ssh2) {
1021 setupbigedit2(hwnd, IDC_KEYDISPLAY, IDC_PKSTATIC,
1022 &state->ssh2key);
1023 } else {
1024 setupbigedit1(hwnd, IDC_KEYDISPLAY, IDC_PKSTATIC,
1025 &state->key);
1026 }
1027 }
1028 }
1029 break;
1030 case IDC_ABOUT:
1031 EnableWindow(hwnd, 0);
1032 DialogBox(hinst, MAKEINTRESOURCE(213), NULL, AboutProc);
1033 EnableWindow(hwnd, 1);
1034 SetActiveWindow(hwnd);
1035 return 0;
1036 case IDC_GIVEHELP:
1037 if (HIWORD(wParam) == BN_CLICKED ||
1038 HIWORD(wParam) == BN_DOUBLECLICKED) {
1039 if (help_path) {
1040 WinHelp(hwnd, help_path, HELP_COMMAND,
1041 (DWORD)"JI(`',`puttygen.general')");
1042 requested_help = TRUE;
1043 }
1044 }
1045 return 0;
1046 case IDC_GENERATE:
1047 state =
1048 (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
1049 if (!state->generation_thread_exists) {
1050 BOOL ok;
1051 state->keysize = GetDlgItemInt(hwnd, IDC_BITS, &ok, FALSE);
1052 if (!ok)
1053 state->keysize = DEFAULT_KEYSIZE;
1054 /* If we ever introduce a new key type, check it here! */
1055 state->ssh2 = !IsDlgButtonChecked(hwnd, IDC_KEYSSH1);
1056 state->is_dsa = IsDlgButtonChecked(hwnd, IDC_KEYSSH2DSA);
1057 if (state->keysize < 256) {
1058 int ret = MessageBox(hwnd,
1059 "PuTTYgen will not generate a key"
1060 " smaller than 256 bits.\n"
1061 "Key length reset to 256. Continue?",
1062 "PuTTYgen Warning",
1063 MB_ICONWARNING | MB_OKCANCEL);
1064 if (ret != IDOK)
1065 break;
1066 state->keysize = 256;
1067 SetDlgItemInt(hwnd, IDC_BITS, 256, FALSE);
1068 }
1069 ui_set_state(hwnd, state, 1);
1070 SetDlgItemText(hwnd, IDC_GENERATING, entropy_msg);
1071 state->key_exists = FALSE;
1072 state->collecting_entropy = TRUE;
1073
1074 /*
1075 * My brief statistical tests on mouse movements
1076 * suggest that there are about 2.5 bits of
1077 * randomness in the x position, 2.5 in the y
1078 * position, and 1.7 in the message time, making
1079 * 5.7 bits of unpredictability per mouse movement.
1080 * However, other people have told me it's far less
1081 * than that, so I'm going to be stupidly cautious
1082 * and knock that down to a nice round 2. With this
1083 * method, we require two words per mouse movement,
1084 * so with 2 bits per mouse movement we expect 2
1085 * bits every 2 words.
1086 */
1087 state->entropy_required = (state->keysize / 2) * 2;
1088 state->entropy_got = 0;
1089 state->entropy_size = (state->entropy_required *
1090 sizeof(*state->entropy));
1091 state->entropy = smalloc(state->entropy_size);
1092
1093 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETRANGE, 0,
1094 MAKELPARAM(0, state->entropy_required));
1095 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS, 0, 0);
1096 }
1097 break;
1098 case IDC_SAVE:
1099 case IDC_EXPORT_OPENSSH:
1100 case IDC_EXPORT_SSHCOM:
1101 state =
1102 (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
1103 if (state->key_exists) {
1104 char filename[FILENAME_MAX];
1105 char passphrase[PASSPHRASE_MAXLEN];
1106 char passphrase2[PASSPHRASE_MAXLEN];
1107 int type, realtype;
1108
1109 if (state->ssh2)
1110 realtype = SSH_KEYTYPE_SSH2;
1111 else
1112 realtype = SSH_KEYTYPE_SSH1;
1113
1114 if (LOWORD(wParam) == IDC_EXPORT_OPENSSH)
1115 type = SSH_KEYTYPE_OPENSSH;
1116 else if (LOWORD(wParam) == IDC_EXPORT_SSHCOM)
1117 type = SSH_KEYTYPE_SSHCOM;
1118 else
1119 type = realtype;
1120
1121 if (type != realtype &&
1122 import_target_type(type) != realtype) {
1123 char msg[256];
1124 sprintf(msg, "Cannot export an SSH%d key in an SSH%d"
1125 " format", (state->ssh2 ? 2 : 1),
1126 (state->ssh2 ? 1 : 2));
1127 MessageBox(hwnd, msg,
1128 "PuTTYgen Error", MB_OK | MB_ICONERROR);
1129 break;
1130 }
1131
1132 GetDlgItemText(hwnd, IDC_PASSPHRASE1EDIT,
1133 passphrase, sizeof(passphrase));
1134 GetDlgItemText(hwnd, IDC_PASSPHRASE2EDIT,
1135 passphrase2, sizeof(passphrase2));
1136 if (strcmp(passphrase, passphrase2)) {
1137 MessageBox(hwnd,
1138 "The two passphrases given do not match.",
1139 "PuTTYgen Error", MB_OK | MB_ICONERROR);
1140 break;
1141 }
1142 if (!*passphrase) {
1143 int ret;
1144 ret = MessageBox(hwnd,
1145 "Are you sure you want to save this key\n"
1146 "without a passphrase to protect it?",
1147 "PuTTYgen Warning",
1148 MB_YESNO | MB_ICONWARNING);
1149 if (ret != IDYES)
1150 break;
1151 }
1152 if (prompt_keyfile(hwnd, "Save private key as:",
1153 filename, 1, (type == realtype))) {
1154 int ret;
1155 FILE *fp = fopen(filename, "r");
1156 if (fp) {
1157 char buffer[FILENAME_MAX + 80];
1158 fclose(fp);
1159 sprintf(buffer, "Overwrite existing file\n%.*s?",
1160 FILENAME_MAX, filename);
1161 ret = MessageBox(hwnd, buffer, "PuTTYgen Warning",
1162 MB_YESNO | MB_ICONWARNING);
1163 if (ret != IDYES)
1164 break;
1165 }
1166
1167 if (state->ssh2) {
1168 if (type != realtype)
1169 ret = export_ssh2(filename, type, &state->ssh2key,
1170 *passphrase ? passphrase : NULL);
1171 else
1172 ret = ssh2_save_userkey(filename, &state->ssh2key,
1173 *passphrase ? passphrase :
1174 NULL);
1175 } else {
1176 if (type != realtype)
1177 ret = export_ssh1(filename, type, &state->key,
1178 *passphrase ? passphrase : NULL);
1179 else
1180 ret = saversakey(filename, &state->key,
1181 *passphrase ? passphrase : NULL);
1182 }
1183 if (ret <= 0) {
1184 MessageBox(hwnd, "Unable to save key file",
1185 "PuTTYgen Error", MB_OK | MB_ICONERROR);
1186 }
1187 }
1188 }
1189 break;
1190 case IDC_SAVEPUB:
1191 state =
1192 (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
1193 if (state->key_exists) {
1194 char filename[FILENAME_MAX];
1195 if (prompt_keyfile(hwnd, "Save public key as:",
1196 filename, 1, 0)) {
1197 int ret;
1198 FILE *fp = fopen(filename, "r");
1199 if (fp) {
1200 char buffer[FILENAME_MAX + 80];
1201 fclose(fp);
1202 sprintf(buffer, "Overwrite existing file\n%.*s?",
1203 FILENAME_MAX, filename);
1204 ret = MessageBox(hwnd, buffer, "PuTTYgen Warning",
1205 MB_YESNO | MB_ICONWARNING);
1206 if (ret != IDYES)
1207 break;
1208 }
1209 if (state->ssh2) {
1210 ret = save_ssh2_pubkey(filename, &state->ssh2key);
1211 } else {
1212 ret = save_ssh1_pubkey(filename, &state->key);
1213 }
1214 if (ret <= 0) {
1215 MessageBox(hwnd, "Unable to save key file",
1216 "PuTTYgen Error", MB_OK | MB_ICONERROR);
1217 }
1218 }
1219 }
1220 break;
1221 case IDC_LOAD:
1222 case IDC_IMPORT:
1223 state =
1224 (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
1225 if (!state->generation_thread_exists) {
1226 char filename[FILENAME_MAX];
1227 if (prompt_keyfile(hwnd, "Load private key:",
1228 filename, 0, LOWORD(wParam)==IDC_LOAD))
1229 load_key_file(hwnd, state, filename,
1230 LOWORD(wParam) != IDC_LOAD);
1231 }
1232 break;
1233 }
1234 return 0;
1235 case WM_DONEKEY:
1236 state = (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
1237 state->generation_thread_exists = FALSE;
1238 state->key_exists = TRUE;
1239 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETRANGE, 0,
1240 MAKELPARAM(0, PROGRESSRANGE));
1241 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS, PROGRESSRANGE, 0);
1242 if (state->ssh2) {
1243 if (state->is_dsa) {
1244 state->ssh2key.data = &state->dsskey;
1245 state->ssh2key.alg = &ssh_dss;
1246 } else {
1247 state->ssh2key.data = &state->key;
1248 state->ssh2key.alg = &ssh_rsa;
1249 }
1250 state->commentptr = &state->ssh2key.comment;
1251 } else {
1252 state->commentptr = &state->key.comment;
1253 }
1254 /*
1255 * Invent a comment for the key. We'll do this by including
1256 * the date in it. This will be so horrifyingly ugly that
1257 * the user will immediately want to change it, which is
1258 * what we want :-)
1259 */
1260 *state->commentptr = smalloc(30);
1261 {
1262 time_t t;
1263 struct tm *tm;
1264 time(&t);
1265 tm = localtime(&t);
1266 if (state->is_dsa)
1267 strftime(*state->commentptr, 30, "dsa-key-%Y%m%d", tm);
1268 else
1269 strftime(*state->commentptr, 30, "rsa-key-%Y%m%d", tm);
1270 }
1271
1272 /*
1273 * Now update the key controls with all the key data.
1274 */
1275 {
1276 char *savecomment;
1277 /*
1278 * Blank passphrase, initially. This isn't dangerous,
1279 * because we will warn (Are You Sure?) before allowing
1280 * the user to save an unprotected private key.
1281 */
1282 SetDlgItemText(hwnd, IDC_PASSPHRASE1EDIT, "");
1283 SetDlgItemText(hwnd, IDC_PASSPHRASE2EDIT, "");
1284 /*
1285 * Set the comment.
1286 */
1287 SetDlgItemText(hwnd, IDC_COMMENTEDIT, *state->commentptr);
1288 /*
1289 * Set the key fingerprint.
1290 */
1291 savecomment = *state->commentptr;
1292 *state->commentptr = NULL;
1293 if (state->ssh2) {
1294 char *fp;
1295 fp = state->ssh2key.alg->fingerprint(state->ssh2key.data);
1296 SetDlgItemText(hwnd, IDC_FINGERPRINT, fp);
1297 sfree(fp);
1298 } else {
1299 char buf[128];
1300 rsa_fingerprint(buf, sizeof(buf), &state->key);
1301 SetDlgItemText(hwnd, IDC_FINGERPRINT, buf);
1302 }
1303 *state->commentptr = savecomment;
1304 /*
1305 * Construct a decimal representation of the key, for
1306 * pasting into .ssh/authorized_keys or
1307 * .ssh/authorized_keys2 on a Unix box.
1308 */
1309 if (state->ssh2) {
1310 setupbigedit2(hwnd, IDC_KEYDISPLAY,
1311 IDC_PKSTATIC, &state->ssh2key);
1312 } else {
1313 setupbigedit1(hwnd, IDC_KEYDISPLAY,
1314 IDC_PKSTATIC, &state->key);
1315 }
1316 }
1317 /*
1318 * Finally, hide the progress bar and show the key data.
1319 */
1320 ui_set_state(hwnd, state, 2);
1321 break;
1322 case WM_HELP:
1323 if (help_path) {
1324 int id = ((LPHELPINFO)lParam)->iCtrlId;
1325 char *cmd = NULL;
1326 switch (id) {
1327 case IDC_GENERATING:
1328 case IDC_PROGRESS:
1329 case IDC_GENSTATIC:
1330 case IDC_GENERATE:
1331 cmd = "JI(`',`puttygen.generate')"; break;
1332 case IDC_PKSTATIC:
1333 case IDC_KEYDISPLAY:
1334 cmd = "JI(`',`puttygen.pastekey')"; break;
1335 case IDC_FPSTATIC:
1336 case IDC_FINGERPRINT:
1337 cmd = "JI(`',`puttygen.fingerprint')"; break;
1338 case IDC_COMMENTSTATIC:
1339 case IDC_COMMENTEDIT:
1340 cmd = "JI(`',`puttygen.comment')"; break;
1341 case IDC_PASSPHRASE1STATIC:
1342 case IDC_PASSPHRASE1EDIT:
1343 case IDC_PASSPHRASE2STATIC:
1344 case IDC_PASSPHRASE2EDIT:
1345 cmd = "JI(`',`puttygen.passphrase')"; break;
1346 case IDC_LOADSTATIC:
1347 case IDC_LOAD:
1348 cmd = "JI(`',`puttygen.load')"; break;
1349 case IDC_SAVESTATIC:
1350 case IDC_SAVE:
1351 cmd = "JI(`',`puttygen.savepriv')"; break;
1352 case IDC_SAVEPUB:
1353 cmd = "JI(`',`puttygen.savepub')"; break;
1354 case IDC_TYPESTATIC:
1355 case IDC_KEYSSH1:
1356 case IDC_KEYSSH2RSA:
1357 case IDC_KEYSSH2DSA:
1358 cmd = "JI(`',`puttygen.keytype')"; break;
1359 case IDC_BITSSTATIC:
1360 case IDC_BITS:
1361 cmd = "JI(`',`puttygen.bits')"; break;
1362 case IDC_IMPORT:
1363 case IDC_EXPORT_OPENSSH:
1364 case IDC_EXPORT_SSHCOM:
1365 cmd = "JI(`',`puttygen.conversions')"; break;
1366 }
1367 if (cmd) {
1368 WinHelp(hwnd, help_path, HELP_COMMAND, (DWORD)cmd);
1369 requested_help = TRUE;
1370 } else {
1371 MessageBeep(0);
1372 }
1373 }
1374 break;
1375 case WM_CLOSE:
1376 state = (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
1377 sfree(state);
1378 if (requested_help) {
1379 WinHelp(hwnd, help_path, HELP_QUIT, 0);
1380 requested_help = FALSE;
1381 }
1382 EndDialog(hwnd, 1);
1383 return 0;
1384 }
1385 return 0;
1386 }
1387
1388 void cleanup_exit(int code) { exit(code); }
1389
1390 int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show)
1391 {
1392 int argc;
1393 char **argv;
1394
1395 split_into_argv(cmdline, &argc, &argv, NULL);
1396
1397 if (argc > 0) {
1398 /*
1399 * Assume the first argument to be a private key file, and
1400 * attempt to load it.
1401 */
1402 cmdline_keyfile = argv[0];
1403 }
1404
1405 InitCommonControls();
1406 hinst = inst;
1407
1408 /*
1409 * See if we can find our Help file.
1410 */
1411 {
1412 char b[2048], *p, *q, *r;
1413 FILE *fp;
1414 GetModuleFileName(NULL, b, sizeof(b) - 1);
1415 r = b;
1416 p = strrchr(b, '\\');
1417 if (p && p >= r) r = p+1;
1418 q = strrchr(b, ':');
1419 if (q && q >= r) r = q+1;
1420 strcpy(r, "putty.hlp");
1421 if ( (fp = fopen(b, "r")) != NULL) {
1422 help_path = dupstr(b);
1423 fclose(fp);
1424 } else
1425 help_path = NULL;
1426 }
1427
1428 random_init();
1429 return DialogBox(hinst, MAKEINTRESOURCE(201), NULL,
1430 MainDlgProc) != IDOK;
1431 }
Local modifications for Simon Tatham's `PuTTY' SSH client and terminal emulator