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