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