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