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