projects / u / mdw / putty / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
INCOMPATIBLE CHANGE to the SSH2 private key file format. There is
[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 /* ----------------------------------------------------------------------
22 * Progress report code. This is really horrible :-)
23 */
24 #define PROGRESSRANGE 65535
25 #define MAXPHASE 5
26 struct progress {
27 int nphases;
28 struct {
29 int exponential;
30 unsigned startpoint, total;
31 unsigned param, current, n; /* if exponential */
32 unsigned mult; /* if linear */
33 } phases[MAXPHASE];
34 unsigned total, divisor, range;
35 HWND progbar;
36 };
37
38 static void progress_update(void *param, int action, int phase, int iprogress)
39 {
40 struct progress *p = (struct progress *) param;
41 unsigned progress = iprogress;
42 int position;
43
44 if (action < PROGFN_READY && p->nphases < phase)
45 p->nphases = phase;
46 switch (action) {
47 case PROGFN_INITIALISE:
48 p->nphases = 0;
49 break;
50 case PROGFN_LIN_PHASE:
51 p->phases[phase-1].exponential = 0;
52 p->phases[phase-1].mult = p->phases[phase].total / progress;
53 break;
54 case PROGFN_EXP_PHASE:
55 p->phases[phase-1].exponential = 1;
56 p->phases[phase-1].param = 0x10000 + progress;
57 p->phases[phase-1].current = p->phases[phase-1].total;
58 p->phases[phase-1].n = 0;
59 break;
60 case PROGFN_PHASE_EXTENT:
61 p->phases[phase-1].total = progress;
62 break;
63 case PROGFN_READY:
64 {
65 unsigned total = 0;
66 int i;
67 for (i = 0; i < p->nphases; i++) {
68 p->phases[i].startpoint = total;
69 total += p->phases[i].total;
70 }
71 p->total = total;
72 p->divisor = ((p->total + PROGRESSRANGE - 1) / PROGRESSRANGE);
73 p->range = p->total / p->divisor;
74 SendMessage(p->progbar, PBM_SETRANGE, 0, MAKELPARAM(0, p->range));
75 }
76 break;
77 case PROGFN_PROGRESS:
78 if (p->phases[phase-1].exponential) {
79 while (p->phases[phase-1].n < progress) {
80 p->phases[phase-1].n++;
81 p->phases[phase-1].current *= p->phases[phase-1].param;
82 p->phases[phase-1].current /= 0x10000;
83 }
84 position = (p->phases[phase-1].startpoint +
85 p->phases[phase-1].total - p->phases[phase-1].current);
86 } else {
87 position = (p->phases[phase-1].startpoint +
88 progress * p->phases[phase-1].mult);
89 }
90 SendMessage(p->progbar, PBM_SETPOS, position / p->divisor, 0);
91 break;
92 }
93 }
94
95 extern char ver[];
96
97 #define PASSPHRASE_MAXLEN 512
98
99 struct PassphraseProcStruct {
100 char *passphrase;
101 char *comment;
102 };
103
104 /*
105 * Dialog-box function for the passphrase box.
106 */
107 static int CALLBACK PassphraseProc(HWND hwnd, UINT msg,
108 WPARAM wParam, LPARAM lParam)
109 {
110 static char *passphrase = NULL;
111 struct PassphraseProcStruct *p;
112
113 switch (msg) {
114 case WM_INITDIALOG:
115 SetForegroundWindow(hwnd);
116 SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0,
117 SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
118
119 /*
120 * Centre the window.
121 */
122 { /* centre the window */
123 RECT rs, rd;
124 HWND hw;
125
126 hw = GetDesktopWindow();
127 if (GetWindowRect(hw, &rs) && GetWindowRect(hwnd, &rd))
128 MoveWindow(hwnd,
129 (rs.right + rs.left + rd.left - rd.right) / 2,
130 (rs.bottom + rs.top + rd.top - rd.bottom) / 2,
131 rd.right - rd.left, rd.bottom - rd.top, TRUE);
132 }
133
134 p = (struct PassphraseProcStruct *) lParam;
135 passphrase = p->passphrase;
136 if (p->comment)
137 SetDlgItemText(hwnd, 101, p->comment);
138 *passphrase = 0;
139 SetDlgItemText(hwnd, 102, passphrase);
140 return 0;
141 case WM_COMMAND:
142 switch (LOWORD(wParam)) {
143 case IDOK:
144 if (*passphrase)
145 EndDialog(hwnd, 1);
146 else
147 MessageBeep(0);
148 return 0;
149 case IDCANCEL:
150 EndDialog(hwnd, 0);
151 return 0;
152 case 102: /* edit box */
153 if ((HIWORD(wParam) == EN_CHANGE) && passphrase) {
154 GetDlgItemText(hwnd, 102, passphrase,
155 PASSPHRASE_MAXLEN - 1);
156 passphrase[PASSPHRASE_MAXLEN - 1] = '\0';
157 }
158 return 0;
159 }
160 return 0;
161 case WM_CLOSE:
162 EndDialog(hwnd, 0);
163 return 0;
164 }
165 return 0;
166 }
167
168 /*
169 * Prompt for a key file. Assumes the filename buffer is of size
170 * FILENAME_MAX.
171 */
172 static int prompt_keyfile(HWND hwnd, char *dlgtitle,
173 char *filename, int save)
174 {
175 OPENFILENAME of;
176 memset(&of, 0, sizeof(of));
177 #ifdef OPENFILENAME_SIZE_VERSION_400
178 of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
179 #else
180 of.lStructSize = sizeof(of);
181 #endif
182 of.hwndOwner = hwnd;
183 of.lpstrFilter = "All Files\0*\0\0\0";
184 of.lpstrCustomFilter = NULL;
185 of.nFilterIndex = 1;
186 of.lpstrFile = filename;
187 *filename = '\0';
188 of.nMaxFile = FILENAME_MAX;
189 of.lpstrFileTitle = NULL;
190 of.lpstrInitialDir = NULL;
191 of.lpstrTitle = dlgtitle;
192 of.Flags = 0;
193 if (save)
194 return GetSaveFileName(&of);
195 else
196 return GetOpenFileName(&of);
197 }
198
199 /*
200 * This function is needed to link with the DES code. We need not
201 * have it do anything at all.
202 */
203 void logevent(char *msg)
204 {
205 }
206
207 /*
208 * Dialog-box function for the Licence box.
209 */
210 static int CALLBACK LicenceProc(HWND hwnd, UINT msg,
211 WPARAM wParam, LPARAM lParam)
212 {
213 switch (msg) {
214 case WM_INITDIALOG:
215 /*
216 * Centre the window.
217 */
218 { /* centre the window */
219 RECT rs, rd;
220 HWND hw;
221
222 hw = GetDesktopWindow();
223 if (GetWindowRect(hw, &rs) && GetWindowRect(hwnd, &rd))
224 MoveWindow(hwnd,
225 (rs.right + rs.left + rd.left - rd.right) / 2,
226 (rs.bottom + rs.top + rd.top - rd.bottom) / 2,
227 rd.right - rd.left, rd.bottom - rd.top, TRUE);
228 }
229
230 return 1;
231 case WM_COMMAND:
232 switch (LOWORD(wParam)) {
233 case IDOK:
234 EndDialog(hwnd, 1);
235 return 0;
236 }
237 return 0;
238 case WM_CLOSE:
239 EndDialog(hwnd, 1);
240 return 0;
241 }
242 return 0;
243 }
244
245 /*
246 * Dialog-box function for the About box.
247 */
248 static int CALLBACK AboutProc(HWND hwnd, UINT msg,
249 WPARAM wParam, LPARAM lParam)
250 {
251 switch (msg) {
252 case WM_INITDIALOG:
253 /*
254 * Centre the window.
255 */
256 { /* centre the window */
257 RECT rs, rd;
258 HWND hw;
259
260 hw = GetDesktopWindow();
261 if (GetWindowRect(hw, &rs) && GetWindowRect(hwnd, &rd))
262 MoveWindow(hwnd,
263 (rs.right + rs.left + rd.left - rd.right) / 2,
264 (rs.bottom + rs.top + rd.top - rd.bottom) / 2,
265 rd.right - rd.left, rd.bottom - rd.top, TRUE);
266 }
267
268 SetDlgItemText(hwnd, 100, ver);
269 return 1;
270 case WM_COMMAND:
271 switch (LOWORD(wParam)) {
272 case IDOK:
273 EndDialog(hwnd, 1);
274 return 0;
275 case 101:
276 EnableWindow(hwnd, 0);
277 DialogBox(hinst, MAKEINTRESOURCE(214), NULL, LicenceProc);
278 EnableWindow(hwnd, 1);
279 SetActiveWindow(hwnd);
280 return 0;
281 }
282 return 0;
283 case WM_CLOSE:
284 EndDialog(hwnd, 1);
285 return 0;
286 }
287 return 0;
288 }
289
290 /*
291 * Thread to generate a key.
292 */
293 struct rsa_key_thread_params {
294 HWND progressbar; /* notify this with progress */
295 HWND dialog; /* notify this on completion */
296 int keysize; /* bits in key */
297 int is_dsa;
298 struct RSAKey *key;
299 struct dss_key *dsskey;
300 };
301 static DWORD WINAPI generate_rsa_key_thread(void *param)
302 {
303 struct rsa_key_thread_params *params =
304 (struct rsa_key_thread_params *) param;
305 struct progress prog;
306 prog.progbar = params->progressbar;
307
308 progress_update(&prog, PROGFN_INITIALISE, 0, 0);
309
310 if (params->is_dsa)
311 dsa_generate(params->dsskey, params->keysize, progress_update, &prog);
312 else
313 rsa_generate(params->key, params->keysize, progress_update, &prog);
314
315 PostMessage(params->dialog, WM_DONEKEY, 0, 0);
316
317 sfree(params);
318 return 0;
319 }
320
321 struct MainDlgState {
322 int collecting_entropy;
323 int generation_thread_exists;
324 int key_exists;
325 int entropy_got, entropy_required, entropy_size;
326 int keysize;
327 int ssh2, is_dsa;
328 char **commentptr; /* points to key.comment or ssh2key.comment */
329 struct ssh2_userkey ssh2key;
330 unsigned *entropy;
331 struct RSAKey key;
332 struct dss_key dsskey;
333 };
334
335 static void hidemany(HWND hwnd, const int *ids, int hideit)
336 {
337 while (*ids) {
338 ShowWindow(GetDlgItem(hwnd, *ids++), (hideit ? SW_HIDE : SW_SHOW));
339 }
340 }
341
342 static void setupbigedit1(HWND hwnd, int id, int idstatic, struct RSAKey *key)
343 {
344 char *buffer;
345 char *dec1, *dec2;
346
347 dec1 = bignum_decimal(key->exponent);
348 dec2 = bignum_decimal(key->modulus);
349 buffer = smalloc(strlen(dec1) + strlen(dec2) +
350 strlen(key->comment) + 30);
351 sprintf(buffer, "%d %s %s %s",
352 bignum_bitcount(key->modulus), dec1, dec2, key->comment);
353 SetDlgItemText(hwnd, id, buffer);
354 SetDlgItemText(hwnd, idstatic,
355 "&Public key for pasting into authorized_keys file:");
356 sfree(dec1);
357 sfree(dec2);
358 sfree(buffer);
359 }
360
361 static void setupbigedit2(HWND hwnd, int id, int idstatic,
362 struct ssh2_userkey *key)
363 {
364 unsigned char *pub_blob;
365 char *buffer, *p;
366 int pub_len;
367 int i;
368
369 pub_blob = key->alg->public_blob(key->data, &pub_len);
370 buffer = smalloc(strlen(key->alg->name) + 4 * ((pub_len + 2) / 3) +
371 strlen(key->comment) + 3);
372 strcpy(buffer, key->alg->name);
373 p = buffer + strlen(buffer);
374 *p++ = ' ';
375 i = 0;
376 while (i < pub_len) {
377 int n = (pub_len - i < 3 ? pub_len - i : 3);
378 base64_encode_atom(pub_blob + i, n, p);
379 i += n;
380 p += 4;
381 }
382 *p++ = ' ';
383 strcpy(p, key->comment);
384 SetDlgItemText(hwnd, id, buffer);
385 SetDlgItemText(hwnd, idstatic, "&Public key for pasting into "
386 "OpenSSH authorized_keys2 file:");
387 sfree(pub_blob);
388 sfree(buffer);
389 }
390
391 static int save_ssh1_pubkey(char *filename, struct RSAKey *key)
392 {
393 char *dec1, *dec2;
394 FILE *fp;
395
396 dec1 = bignum_decimal(key->exponent);
397 dec2 = bignum_decimal(key->modulus);
398 fp = fopen(filename, "wb");
399 if (!fp)
400 return 0;
401 fprintf(fp, "%d %s %s %s\n",
402 bignum_bitcount(key->modulus), dec1, dec2, key->comment);
403 fclose(fp);
404 sfree(dec1);
405 sfree(dec2);
406 return 1;
407 }
408
409 /*
410 * Warn about the obsolescent key file format.
411 */
412 void old_keyfile_warning(void)
413 {
414 static const char mbtitle[] = "PuTTY Key File Warning";
415 static const char message[] =
416 "You are loading an SSH 2 private key which has an\n"
417 "old version of the file format. This means your key\n"
418 "file is not fully tamperproof. Future versions of\n"
419 "PuTTY may stop supporting this private key format,\n"
420 "so we recommend you convert your key to the new\n"
421 "format.\n"
422 "\n"
423 "Once the key is loaded into PuTTYgen, you can perform\n"
424 "this conversion simply by saving it again.";
425
426 MessageBox(NULL, message, mbtitle, MB_OK);
427 }
428
429 static int save_ssh2_pubkey(char *filename, struct ssh2_userkey *key)
430 {
431 unsigned char *pub_blob;
432 char *p;
433 int pub_len;
434 int i, column;
435 FILE *fp;
436
437 pub_blob = key->alg->public_blob(key->data, &pub_len);
438
439 fp = fopen(filename, "wb");
440 if (!fp)
441 return 0;
442
443 fprintf(fp, "---- BEGIN SSH2 PUBLIC KEY ----\n");
444
445 fprintf(fp, "Comment: \"");
446 for (p = key->comment; *p; p++) {
447 if (*p == '\\' || *p == '\"')
448 fputc('\\', fp);
449 fputc(*p, fp);
450 }
451 fprintf(fp, "\"\n");
452
453 i = 0;
454 column = 0;
455 while (i < pub_len) {
456 char buf[5];
457 int n = (pub_len - i < 3 ? pub_len - i : 3);
458 base64_encode_atom(pub_blob + i, n, buf);
459 i += n;
460 buf[4] = '\0';
461 fputs(buf, fp);
462 if (++column >= 16) {
463 fputc('\n', fp);
464 column = 0;
465 }
466 }
467 if (column > 0)
468 fputc('\n', fp);
469
470 fprintf(fp, "---- END SSH2 PUBLIC KEY ----\n");
471 fclose(fp);
472 sfree(pub_blob);
473 return 1;
474 }
475
476 /*
477 * Dialog-box function for the main PuTTYgen dialog box.
478 */
479 static int CALLBACK MainDlgProc(HWND hwnd, UINT msg,
480 WPARAM wParam, LPARAM lParam)
481 {
482 enum {
483 controlidstart = 100,
484 IDC_TITLE,
485 IDC_BOX_KEY,
486 IDC_NOKEY,
487 IDC_GENERATING,
488 IDC_PROGRESS,
489 IDC_PKSTATIC, IDC_KEYDISPLAY,
490 IDC_FPSTATIC, IDC_FINGERPRINT,
491 IDC_COMMENTSTATIC, IDC_COMMENTEDIT,
492 IDC_PASSPHRASE1STATIC, IDC_PASSPHRASE1EDIT,
493 IDC_PASSPHRASE2STATIC, IDC_PASSPHRASE2EDIT,
494 IDC_BOX_ACTIONS,
495 IDC_GENSTATIC, IDC_GENERATE,
496 IDC_LOADSTATIC, IDC_LOAD,
497 IDC_SAVESTATIC, IDC_SAVE, IDC_SAVEPUB,
498 IDC_BOX_PARAMS,
499 IDC_TYPESTATIC, IDC_KEYSSH1, IDC_KEYSSH2RSA, IDC_KEYSSH2DSA,
500 IDC_BITSSTATIC, IDC_BITS,
501 IDC_ABOUT,
502 };
503 static const int nokey_ids[] = { IDC_NOKEY, 0 };
504 static const int generating_ids[] =
505 { 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 static const char generating_msg[] =
514 "Please wait while a key is generated...";
515 static const char entropy_msg[] =
516 "Please generate some randomness by moving the mouse over the blank area.";
517 struct MainDlgState *state;
518
519 switch (msg) {
520 case WM_INITDIALOG:
521 /*
522 * Centre the window.
523 */
524 { /* centre the window */
525 RECT rs, rd;
526 HWND hw;
527
528 hw = GetDesktopWindow();
529 if (GetWindowRect(hw, &rs) && GetWindowRect(hwnd, &rd))
530 MoveWindow(hwnd,
531 (rs.right + rs.left + rd.left - rd.right) / 2,
532 (rs.bottom + rs.top + rd.top - rd.bottom) / 2,
533 rd.right - rd.left, rd.bottom - rd.top, TRUE);
534 }
535
536 state = smalloc(sizeof(*state));
537 state->generation_thread_exists = FALSE;
538 state->collecting_entropy = FALSE;
539 state->entropy = NULL;
540 state->key_exists = FALSE;
541 SetWindowLong(hwnd, GWL_USERDATA, (LONG) state);
542 {
543 struct ctlpos cp, cp2;
544
545 /* Accelerators used: acglops1rbd */
546
547 ctlposinit(&cp, hwnd, 4, 4, 4);
548 bartitle(&cp, "Public and private key generation for PuTTY",
549 IDC_TITLE);
550 beginbox(&cp, "Key", IDC_BOX_KEY);
551 cp2 = cp;
552 statictext(&cp2, "No key.", 1, IDC_NOKEY);
553 cp2 = cp;
554 statictext(&cp2, "", 1, IDC_GENERATING);
555 progressbar(&cp2, IDC_PROGRESS);
556 bigeditctrl(&cp,
557 "&Public key for pasting into authorized_keys file:",
558 IDC_PKSTATIC, IDC_KEYDISPLAY, 5);
559 SendDlgItemMessage(hwnd, IDC_KEYDISPLAY, EM_SETREADONLY, 1, 0);
560 staticedit(&cp, "Key fingerprint:", IDC_FPSTATIC,
561 IDC_FINGERPRINT, 75);
562 SendDlgItemMessage(hwnd, IDC_FINGERPRINT, EM_SETREADONLY, 1,
563 0);
564 staticedit(&cp, "Key &comment:", IDC_COMMENTSTATIC,
565 IDC_COMMENTEDIT, 75);
566 staticpassedit(&cp, "Key p&assphrase:", IDC_PASSPHRASE1STATIC,
567 IDC_PASSPHRASE1EDIT, 75);
568 staticpassedit(&cp, "C&onfirm passphrase:",
569 IDC_PASSPHRASE2STATIC, IDC_PASSPHRASE2EDIT, 75);
570 endbox(&cp);
571 beginbox(&cp, "Actions", IDC_BOX_ACTIONS);
572 staticbtn(&cp, "Generate a public/private key pair",
573 IDC_GENSTATIC, "&Generate", IDC_GENERATE);
574 staticbtn(&cp, "Load an existing private key file",
575 IDC_LOADSTATIC, "&Load", IDC_LOAD);
576 static2btn(&cp, "Save the generated key", IDC_SAVESTATIC,
577 "Save p&ublic key", IDC_SAVEPUB,
578 "&Save private key", IDC_SAVE);
579 endbox(&cp);
580 beginbox(&cp, "Parameters", IDC_BOX_PARAMS);
581 radioline(&cp, "Type of key to generate:", IDC_TYPESTATIC, 3,
582 "SSH&1 (RSA)", IDC_KEYSSH1,
583 "SSH2 &RSA", IDC_KEYSSH2RSA,
584 "SSH2 &DSA", IDC_KEYSSH2DSA, NULL);
585 staticedit(&cp, "Number of &bits in a generated key:",
586 IDC_BITSSTATIC, IDC_BITS, 20);
587 endbox(&cp);
588 }
589 CheckRadioButton(hwnd, IDC_KEYSSH1, IDC_KEYSSH2DSA, IDC_KEYSSH1);
590 SetDlgItemInt(hwnd, IDC_BITS, DEFAULT_KEYSIZE, FALSE);
591
592 /*
593 * Initially, hide the progress bar and the key display,
594 * and show the no-key display. Also disable the Save
595 * buttons, because with no key we obviously can't save
596 * anything.
597 */
598 hidemany(hwnd, nokey_ids, FALSE);
599 hidemany(hwnd, generating_ids, TRUE);
600 hidemany(hwnd, gotkey_ids, TRUE);
601 EnableWindow(GetDlgItem(hwnd, IDC_SAVE), 0);
602 EnableWindow(GetDlgItem(hwnd, IDC_SAVEPUB), 0);
603
604 return 1;
605 case WM_MOUSEMOVE:
606 state = (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
607 if (state->collecting_entropy &&
608 state->entropy && state->entropy_got < state->entropy_required) {
609 state->entropy[state->entropy_got++] = lParam;
610 state->entropy[state->entropy_got++] = GetMessageTime();
611 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS,
612 state->entropy_got, 0);
613 if (state->entropy_got >= state->entropy_required) {
614 struct rsa_key_thread_params *params;
615 DWORD threadid;
616
617 /*
618 * Seed the entropy pool
619 */
620 random_add_heavynoise(state->entropy, state->entropy_size);
621 memset(state->entropy, 0, state->entropy_size);
622 sfree(state->entropy);
623 state->collecting_entropy = FALSE;
624
625 SetDlgItemText(hwnd, IDC_GENERATING, generating_msg);
626 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETRANGE, 0,
627 MAKELPARAM(0, PROGRESSRANGE));
628 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS, 0, 0);
629
630 params = smalloc(sizeof(*params));
631 params->progressbar = GetDlgItem(hwnd, IDC_PROGRESS);
632 params->dialog = hwnd;
633 params->keysize = state->keysize;
634 params->is_dsa = state->is_dsa;
635 params->key = &state->key;
636 params->dsskey = &state->dsskey;
637
638 if (!CreateThread(NULL, 0, generate_rsa_key_thread,
639 params, 0, &threadid)) {
640 MessageBox(hwnd, "Out of thread resources",
641 "Key generation error",
642 MB_OK | MB_ICONERROR);
643 sfree(params);
644 } else {
645 state->generation_thread_exists = TRUE;
646 }
647 }
648 }
649 break;
650 case WM_COMMAND:
651 switch (LOWORD(wParam)) {
652 case IDC_COMMENTEDIT:
653 if (HIWORD(wParam) == EN_CHANGE) {
654 state = (struct MainDlgState *)
655 GetWindowLong(hwnd, GWL_USERDATA);
656 if (state->key_exists) {
657 HWND editctl = GetDlgItem(hwnd, IDC_COMMENTEDIT);
658 int len = GetWindowTextLength(editctl);
659 if (*state->commentptr)
660 sfree(*state->commentptr);
661 *state->commentptr = smalloc(len + 1);
662 GetWindowText(editctl, *state->commentptr, len + 1);
663 if (state->ssh2) {
664 setupbigedit2(hwnd, IDC_KEYDISPLAY, IDC_PKSTATIC,
665 &state->ssh2key);
666 } else {
667 setupbigedit1(hwnd, IDC_KEYDISPLAY, IDC_PKSTATIC,
668 &state->key);
669 }
670 }
671 }
672 break;
673 case IDC_ABOUT:
674 EnableWindow(hwnd, 0);
675 DialogBox(hinst, MAKEINTRESOURCE(213), NULL, AboutProc);
676 EnableWindow(hwnd, 1);
677 SetActiveWindow(hwnd);
678 return 0;
679 case IDC_GENERATE:
680 state =
681 (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
682 if (!state->generation_thread_exists) {
683 BOOL ok;
684 state->keysize = GetDlgItemInt(hwnd, IDC_BITS, &ok, FALSE);
685 if (!ok)
686 state->keysize = DEFAULT_KEYSIZE;
687 /* If we ever introduce a new key type, check it here! */
688 state->ssh2 = !IsDlgButtonChecked(hwnd, IDC_KEYSSH1);
689 state->is_dsa = IsDlgButtonChecked(hwnd, IDC_KEYSSH2DSA);
690 if (state->keysize < 256) {
691 int ret = MessageBox(hwnd,
692 "PuTTYgen will not generate a key"
693 " smaller than 256 bits.\n"
694 "Key length reset to 256. Continue?",
695 "PuTTYgen Warning",
696 MB_ICONWARNING | MB_OKCANCEL);
697 if (ret != IDOK)
698 break;
699 state->keysize = 256;
700 SetDlgItemInt(hwnd, IDC_BITS, 256, FALSE);
701 }
702 hidemany(hwnd, nokey_ids, TRUE);
703 hidemany(hwnd, generating_ids, FALSE);
704 hidemany(hwnd, gotkey_ids, TRUE);
705 EnableWindow(GetDlgItem(hwnd, IDC_GENERATE), 0);
706 EnableWindow(GetDlgItem(hwnd, IDC_LOAD), 0);
707 EnableWindow(GetDlgItem(hwnd, IDC_SAVE), 0);
708 EnableWindow(GetDlgItem(hwnd, IDC_SAVEPUB), 0);
709 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH1), 0);
710 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2RSA), 0);
711 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2DSA), 0);
712 EnableWindow(GetDlgItem(hwnd, IDC_BITS), 0);
713 state->key_exists = FALSE;
714 SetDlgItemText(hwnd, IDC_GENERATING, entropy_msg);
715 state->collecting_entropy = TRUE;
716
717 /*
718 * My brief statistical tests on mouse movements
719 * suggest that there are about 2.5 bits of
720 * randomness in the x position, 2.5 in the y
721 * position, and 1.7 in the message time, making
722 * 5.7 bits of unpredictability per mouse movement.
723 * However, other people have told me it's far less
724 * than that, so I'm going to be stupidly cautious
725 * and knock that down to a nice round 2. With this
726 * method, we require two words per mouse movement,
727 * so with 2 bits per mouse movement we expect 2
728 * bits every 2 words.
729 */
730 state->entropy_required = (state->keysize / 2) * 2;
731 state->entropy_got = 0;
732 state->entropy_size = (state->entropy_required *
733 sizeof(*state->entropy));
734 state->entropy = smalloc(state->entropy_size);
735
736 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETRANGE, 0,
737 MAKELPARAM(0, state->entropy_required));
738 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS, 0, 0);
739 }
740 break;
741 case IDC_SAVE:
742 state =
743 (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
744 if (state->key_exists) {
745 char filename[FILENAME_MAX];
746 char passphrase[PASSPHRASE_MAXLEN];
747 char passphrase2[PASSPHRASE_MAXLEN];
748 GetDlgItemText(hwnd, IDC_PASSPHRASE1EDIT,
749 passphrase, sizeof(passphrase));
750 GetDlgItemText(hwnd, IDC_PASSPHRASE2EDIT,
751 passphrase2, sizeof(passphrase2));
752 if (strcmp(passphrase, passphrase2)) {
753 MessageBox(hwnd,
754 "The two passphrases given do not match.",
755 "PuTTYgen Error", MB_OK | MB_ICONERROR);
756 break;
757 }
758 if (!*passphrase) {
759 int ret;
760 ret = MessageBox(hwnd,
761 "Are you sure you want to save this key\n"
762 "without a passphrase to protect it?",
763 "PuTTYgen Warning",
764 MB_YESNO | MB_ICONWARNING);
765 if (ret != IDYES)
766 break;
767 }
768 if (prompt_keyfile(hwnd, "Save private key as:",
769 filename, 1)) {
770 int ret;
771 FILE *fp = fopen(filename, "r");
772 if (fp) {
773 char buffer[FILENAME_MAX + 80];
774 fclose(fp);
775 sprintf(buffer, "Overwrite existing file\n%.*s?",
776 FILENAME_MAX, filename);
777 ret = MessageBox(hwnd, buffer, "PuTTYgen Warning",
778 MB_YESNO | MB_ICONWARNING);
779 if (ret != IDYES)
780 break;
781 }
782 if (state->ssh2) {
783 ret = ssh2_save_userkey(filename, &state->ssh2key,
784 *passphrase ? passphrase :
785 NULL);
786 } else {
787 ret = saversakey(filename, &state->key,
788 *passphrase ? passphrase : NULL);
789 }
790 if (ret <= 0) {
791 MessageBox(hwnd, "Unable to save key file",
792 "PuTTYgen Error", MB_OK | MB_ICONERROR);
793 }
794 }
795 }
796 break;
797 case IDC_SAVEPUB:
798 state =
799 (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
800 if (state->key_exists) {
801 char filename[FILENAME_MAX];
802 if (prompt_keyfile(hwnd, "Save public key as:",
803 filename, 1)) {
804 int ret;
805 FILE *fp = fopen(filename, "r");
806 if (fp) {
807 char buffer[FILENAME_MAX + 80];
808 fclose(fp);
809 sprintf(buffer, "Overwrite existing file\n%.*s?",
810 FILENAME_MAX, filename);
811 ret = MessageBox(hwnd, buffer, "PuTTYgen Warning",
812 MB_YESNO | MB_ICONWARNING);
813 if (ret != IDYES)
814 break;
815 }
816 if (state->ssh2) {
817 ret = save_ssh2_pubkey(filename, &state->ssh2key);
818 } else {
819 ret = save_ssh1_pubkey(filename, &state->key);
820 }
821 if (ret <= 0) {
822 MessageBox(hwnd, "Unable to save key file",
823 "PuTTYgen Error", MB_OK | MB_ICONERROR);
824 }
825 }
826 }
827 break;
828 case IDC_LOAD:
829 state =
830 (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
831 if (!state->generation_thread_exists) {
832 char filename[FILENAME_MAX];
833 if (prompt_keyfile(hwnd, "Load private key:", filename, 0)) {
834 char passphrase[PASSPHRASE_MAXLEN];
835 int needs_pass;
836 int ver;
837 int ret;
838 char *comment;
839 struct PassphraseProcStruct pps;
840 struct RSAKey newkey1;
841 struct ssh2_userkey *newkey2 = NULL;
842
843 ver = keyfile_version(filename);
844 if (ver == 0) {
845 MessageBox(NULL, "Couldn't load private key.",
846 "PuTTYgen Error", MB_OK | MB_ICONERROR);
847 break;
848 }
849
850 comment = NULL;
851 if (ver == 1)
852 needs_pass = rsakey_encrypted(filename, &comment);
853 else
854 needs_pass =
855 ssh2_userkey_encrypted(filename, &comment);
856 pps.passphrase = passphrase;
857 pps.comment = comment;
858 do {
859 if (needs_pass) {
860 int dlgret;
861 dlgret = DialogBoxParam(hinst,
862 MAKEINTRESOURCE(210),
863 NULL, PassphraseProc,
864 (LPARAM) & pps);
865 if (!dlgret) {
866 ret = -2;
867 break;
868 }
869 } else
870 *passphrase = '\0';
871 if (ver == 1)
872 ret =
873 loadrsakey(filename, &newkey1, passphrase);
874 else {
875 newkey2 =
876 ssh2_load_userkey(filename, passphrase);
877 if (newkey2 == SSH2_WRONG_PASSPHRASE)
878 ret = -1;
879 else if (!newkey2)
880 ret = 0;
881 else
882 ret = 1;
883 }
884 } while (ret == -1);
885 if (comment)
886 sfree(comment);
887 if (ret == 0) {
888 MessageBox(NULL, "Couldn't load private key.",
889 "PuTTYgen Error", MB_OK | MB_ICONERROR);
890 } else if (ret == 1) {
891 EnableWindow(GetDlgItem(hwnd, IDC_GENERATE), 1);
892 EnableWindow(GetDlgItem(hwnd, IDC_LOAD), 1);
893 EnableWindow(GetDlgItem(hwnd, IDC_SAVE), 1);
894 EnableWindow(GetDlgItem(hwnd, IDC_SAVEPUB), 1);
895 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH1), 1);
896 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2RSA), 1);
897 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2DSA), 1);
898 EnableWindow(GetDlgItem(hwnd, IDC_BITS), 1);
899 /*
900 * Now update the key controls with all the
901 * key data.
902 */
903 {
904 SetDlgItemText(hwnd, IDC_PASSPHRASE1EDIT,
905 passphrase);
906 SetDlgItemText(hwnd, IDC_PASSPHRASE2EDIT,
907 passphrase);
908 if (ver == 1) {
909 char buf[128];
910 char *savecomment;
911
912 state->ssh2 = FALSE;
913 state->commentptr = &state->key.comment;
914 state->key = newkey1;
915
916 /*
917 * Set the key fingerprint.
918 */
919 savecomment = state->key.comment;
920 state->key.comment = NULL;
921 rsa_fingerprint(buf, sizeof(buf),
922 &state->key);
923 state->key.comment = savecomment;
924
925 SetDlgItemText(hwnd, IDC_FINGERPRINT, buf);
926 /*
927 * Construct a decimal representation
928 * of the key, for pasting into
929 * .ssh/authorized_keys on a Unix box.
930 */
931 setupbigedit1(hwnd, IDC_KEYDISPLAY,
932 IDC_PKSTATIC, &state->key);
933 } else {
934 char *fp;
935 char *savecomment;
936
937 state->ssh2 = TRUE;
938 state->commentptr =
939 &state->ssh2key.comment;
940 state->ssh2key = *newkey2; /* structure copy */
941 sfree(newkey2);
942
943 savecomment = state->ssh2key.comment;
944 state->ssh2key.comment = NULL;
945 fp =
946 state->ssh2key.alg->
947 fingerprint(state->ssh2key.data);
948 state->ssh2key.comment = savecomment;
949
950 SetDlgItemText(hwnd, IDC_FINGERPRINT, fp);
951 sfree(fp);
952
953 setupbigedit2(hwnd, IDC_KEYDISPLAY,
954 IDC_PKSTATIC, &state->ssh2key);
955 }
956 SetDlgItemText(hwnd, IDC_COMMENTEDIT,
957 *state->commentptr);
958 }
959 /*
960 * Finally, hide the progress bar and show
961 * the key data.
962 */
963 hidemany(hwnd, nokey_ids, TRUE);
964 hidemany(hwnd, generating_ids, TRUE);
965 hidemany(hwnd, gotkey_ids, FALSE);
966 state->key_exists = TRUE;
967 }
968 }
969 }
970 break;
971 }
972 return 0;
973 case WM_DONEKEY:
974 state = (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
975 state->generation_thread_exists = FALSE;
976 state->key_exists = TRUE;
977 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETRANGE, 0,
978 MAKELPARAM(0, PROGRESSRANGE));
979 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS, PROGRESSRANGE, 0);
980 EnableWindow(GetDlgItem(hwnd, IDC_GENERATE), 1);
981 EnableWindow(GetDlgItem(hwnd, IDC_LOAD), 1);
982 EnableWindow(GetDlgItem(hwnd, IDC_SAVE), 1);
983 EnableWindow(GetDlgItem(hwnd, IDC_SAVEPUB), 1);
984 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH1), 1);
985 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2RSA), 1);
986 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2DSA), 1);
987 EnableWindow(GetDlgItem(hwnd, IDC_BITS), 1);
988 if (state->ssh2) {
989 if (state->is_dsa) {
990 state->ssh2key.data = &state->dsskey;
991 state->ssh2key.alg = &ssh_dss;
992 } else {
993 state->ssh2key.data = &state->key;
994 state->ssh2key.alg = &ssh_rsa;
995 }
996 state->commentptr = &state->ssh2key.comment;
997 } else {
998 state->commentptr = &state->key.comment;
999 }
1000 /*
1001 * Invent a comment for the key. We'll do this by including
1002 * the date in it. This will be so horrifyingly ugly that
1003 * the user will immediately want to change it, which is
1004 * what we want :-)
1005 */
1006 *state->commentptr = smalloc(30);
1007 {
1008 time_t t;
1009 struct tm *tm;
1010 time(&t);
1011 tm = localtime(&t);
1012 if (state->is_dsa)
1013 strftime(*state->commentptr, 30, "dsa-key-%Y%m%d", tm);
1014 else
1015 strftime(*state->commentptr, 30, "rsa-key-%Y%m%d", tm);
1016 }
1017
1018 /*
1019 * Now update the key controls with all the key data.
1020 */
1021 {
1022 char *savecomment;
1023 /*
1024 * Blank passphrase, initially. This isn't dangerous,
1025 * because we will warn (Are You Sure?) before allowing
1026 * the user to save an unprotected private key.
1027 */
1028 SetDlgItemText(hwnd, IDC_PASSPHRASE1EDIT, "");
1029 SetDlgItemText(hwnd, IDC_PASSPHRASE2EDIT, "");
1030 /*
1031 * Set the comment.
1032 */
1033 SetDlgItemText(hwnd, IDC_COMMENTEDIT, *state->commentptr);
1034 /*
1035 * Set the key fingerprint.
1036 */
1037 savecomment = *state->commentptr;
1038 *state->commentptr = NULL;
1039 if (state->ssh2) {
1040 char *fp;
1041 fp = state->ssh2key.alg->fingerprint(state->ssh2key.data);
1042 SetDlgItemText(hwnd, IDC_FINGERPRINT, fp);
1043 sfree(fp);
1044 } else {
1045 char buf[128];
1046 rsa_fingerprint(buf, sizeof(buf), &state->key);
1047 SetDlgItemText(hwnd, IDC_FINGERPRINT, buf);
1048 }
1049 *state->commentptr = savecomment;
1050 /*
1051 * Construct a decimal representation of the key, for
1052 * pasting into .ssh/authorized_keys or
1053 * .ssh/authorized_keys2 on a Unix box.
1054 */
1055 if (state->ssh2) {
1056 setupbigedit2(hwnd, IDC_KEYDISPLAY,
1057 IDC_PKSTATIC, &state->ssh2key);
1058 } else {
1059 setupbigedit1(hwnd, IDC_KEYDISPLAY,
1060 IDC_PKSTATIC, &state->key);
1061 }
1062 }
1063 /*
1064 * Finally, hide the progress bar and show the key data.
1065 */
1066 hidemany(hwnd, nokey_ids, TRUE);
1067 hidemany(hwnd, generating_ids, TRUE);
1068 hidemany(hwnd, gotkey_ids, FALSE);
1069 break;
1070 case WM_CLOSE:
1071 state = (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
1072 sfree(state);
1073 EndDialog(hwnd, 1);
1074 return 0;
1075 }
1076 return 0;
1077 }
1078
1079 int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show)
1080 {
1081 InitCommonControls();
1082 hinst = inst;
1083 random_init();
1084 return DialogBox(hinst, MAKEINTRESOURCE(201), NULL,
1085 MainDlgProc) != IDOK;
1086 }
Local modifications for Simon Tatham's `PuTTY' SSH client and terminal emulator