~mdw / sgt / putty / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Final cleanups on key import/export work. Rationalised the UI (so
[sgt/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, exportmenu;
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->exportmenu, IDC_EXPORT_OPENSSH,
543 MF_GRAYED|MF_BYCOMMAND);
544 EnableMenuItem(state->exportmenu, IDC_EXPORT_SSHCOM,
545 MF_GRAYED|MF_BYCOMMAND);
546 break;
547 case 1: /* generating key */
548 hidemany(hwnd, nokey_ids, TRUE);
549 hidemany(hwnd, generating_ids, FALSE);
550 hidemany(hwnd, gotkey_ids, TRUE);
551 EnableWindow(GetDlgItem(hwnd, IDC_GENERATE), 0);
552 EnableWindow(GetDlgItem(hwnd, IDC_LOAD), 0);
553 EnableWindow(GetDlgItem(hwnd, IDC_SAVE), 0);
554 EnableWindow(GetDlgItem(hwnd, IDC_SAVEPUB), 0);
555 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH1), 0);
556 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2RSA), 0);
557 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2DSA), 0);
558 EnableWindow(GetDlgItem(hwnd, IDC_BITS), 0);
559 EnableMenuItem(state->filemenu, IDC_LOAD, MF_GRAYED|MF_BYCOMMAND);
560 EnableMenuItem(state->filemenu, IDC_SAVE, MF_GRAYED|MF_BYCOMMAND);
561 EnableMenuItem(state->filemenu, IDC_SAVEPUB, MF_GRAYED|MF_BYCOMMAND);
562 EnableMenuItem(state->keymenu, IDC_GENERATE, MF_GRAYED|MF_BYCOMMAND);
563 EnableMenuItem(state->keymenu, IDC_KEYSSH1, MF_GRAYED|MF_BYCOMMAND);
564 EnableMenuItem(state->keymenu, IDC_KEYSSH2RSA, MF_GRAYED|MF_BYCOMMAND);
565 EnableMenuItem(state->keymenu, IDC_KEYSSH2DSA, MF_GRAYED|MF_BYCOMMAND);
566 EnableMenuItem(state->exportmenu, IDC_EXPORT_OPENSSH,
567 MF_GRAYED|MF_BYCOMMAND);
568 EnableMenuItem(state->exportmenu, IDC_EXPORT_SSHCOM,
569 MF_GRAYED|MF_BYCOMMAND);
570 break;
571 case 2:
572 hidemany(hwnd, nokey_ids, TRUE);
573 hidemany(hwnd, generating_ids, TRUE);
574 hidemany(hwnd, gotkey_ids, FALSE);
575 EnableWindow(GetDlgItem(hwnd, IDC_GENERATE), 1);
576 EnableWindow(GetDlgItem(hwnd, IDC_LOAD), 1);
577 EnableWindow(GetDlgItem(hwnd, IDC_SAVE), 1);
578 EnableWindow(GetDlgItem(hwnd, IDC_SAVEPUB), 1);
579 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH1), 1);
580 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2RSA), 1);
581 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2DSA), 1);
582 EnableWindow(GetDlgItem(hwnd, IDC_BITS), 1);
583 EnableMenuItem(state->filemenu, IDC_LOAD, MF_ENABLED|MF_BYCOMMAND);
584 EnableMenuItem(state->filemenu, IDC_SAVE, MF_ENABLED|MF_BYCOMMAND);
585 EnableMenuItem(state->filemenu, IDC_SAVEPUB, MF_ENABLED|MF_BYCOMMAND);
586 EnableMenuItem(state->keymenu, IDC_GENERATE, MF_ENABLED|MF_BYCOMMAND);
587 EnableMenuItem(state->keymenu, IDC_KEYSSH1, MF_ENABLED|MF_BYCOMMAND);
588 EnableMenuItem(state->keymenu, IDC_KEYSSH2RSA,MF_ENABLED|MF_BYCOMMAND);
589 EnableMenuItem(state->keymenu, IDC_KEYSSH2DSA,MF_ENABLED|MF_BYCOMMAND);
590 /*
591 * Enable export menu items if and only if the key type
592 * supports this kind of export.
593 */
594 type = state->ssh2 ? SSH_KEYTYPE_SSH2 : SSH_KEYTYPE_SSH1;
595 #define do_export_menuitem(x,y) \
596 EnableMenuItem(state->exportmenu, x, MF_BYCOMMAND | \
597 (import_target_type(y)==type?MF_ENABLED:MF_GRAYED))
598 do_export_menuitem(IDC_EXPORT_OPENSSH, SSH_KEYTYPE_OPENSSH);
599 do_export_menuitem(IDC_EXPORT_SSHCOM, SSH_KEYTYPE_SSHCOM);
600 #undef do_export_menuitem
601 break;
602 }
603 }
604
605 /*
606 * Dialog-box function for the main PuTTYgen dialog box.
607 */
608 static int CALLBACK MainDlgProc(HWND hwnd, UINT msg,
609 WPARAM wParam, LPARAM lParam)
610 {
611 static const char generating_msg[] =
612 "Please wait while a key is generated...";
613 static const char entropy_msg[] =
614 "Please generate some randomness by moving the mouse over the blank area.";
615 struct MainDlgState *state;
616
617 switch (msg) {
618 case WM_INITDIALOG:
619 if (help_path)
620 SetWindowLong(hwnd, GWL_EXSTYLE,
621 GetWindowLong(hwnd, GWL_EXSTYLE) | WS_EX_CONTEXTHELP);
622 else {
623 /*
624 * If we add a Help button, this is where we destroy it
625 * if the help file isn't present.
626 */
627 }
628 requested_help = FALSE;
629
630 state = smalloc(sizeof(*state));
631 state->generation_thread_exists = FALSE;
632 state->collecting_entropy = FALSE;
633 state->entropy = NULL;
634 state->key_exists = FALSE;
635 SetWindowLong(hwnd, GWL_USERDATA, (LONG) state);
636 {
637 HMENU menu, menu1;
638
639 menu = CreateMenu();
640
641 menu1 = CreateMenu();
642 AppendMenu(menu1, MF_ENABLED, IDC_LOAD, "&Load private key");
643 AppendMenu(menu1, MF_ENABLED, IDC_SAVEPUB, "Save p&ublic key");
644 AppendMenu(menu1, MF_ENABLED, IDC_SAVE, "&Save private key");
645 AppendMenu(menu1, MF_SEPARATOR, 0, 0);
646 AppendMenu(menu1, MF_ENABLED, IDC_QUIT, "E&xit");
647 AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1, "&File");
648 state->filemenu = menu1;
649
650 menu1 = CreateMenu();
651 AppendMenu(menu1, MF_ENABLED, IDC_GENERATE, "&Generate key pair");
652 AppendMenu(menu1, MF_SEPARATOR, 0, 0);
653 AppendMenu(menu1, MF_ENABLED, IDC_KEYSSH1, "SSH&1 key (RSA)");
654 AppendMenu(menu1, MF_ENABLED, IDC_KEYSSH2RSA, "SSH2 &RSA key");
655 AppendMenu(menu1, MF_ENABLED, IDC_KEYSSH2DSA, "SSH2 &DSA key");
656 AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1, "&Key");
657 state->keymenu = menu1;
658
659 menu1 = CreateMenu();
660 AppendMenu(menu1, MF_ENABLED, IDC_EXPORT_OPENSSH,
661 "Export &OpenSSH key");
662 AppendMenu(menu1, MF_ENABLED, IDC_EXPORT_SSHCOM,
663 "Export &ssh.com key");
664 AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1,
665 "&Export");
666 state->exportmenu = menu1;
667
668 menu1 = CreateMenu();
669 AppendMenu(menu1, MF_ENABLED, IDC_ABOUT, "&About");
670 if (help_path)
671 AppendMenu(menu1, MF_ENABLED, IDC_GIVEHELP, "&Help");
672 AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1, "&Help");
673
674 SetMenu(hwnd, menu);
675 }
676
677 /*
678 * Centre the window.
679 */
680 { /* centre the window */
681 RECT rs, rd;
682 HWND hw;
683
684 hw = GetDesktopWindow();
685 if (GetWindowRect(hw, &rs) && GetWindowRect(hwnd, &rd))
686 MoveWindow(hwnd,
687 (rs.right + rs.left + rd.left - rd.right) / 2,
688 (rs.bottom + rs.top + rd.top - rd.bottom) / 2,
689 rd.right - rd.left, rd.bottom - rd.top, TRUE);
690 }
691
692 {
693 struct ctlpos cp, cp2;
694
695 /* Accelerators used: acglops1rbd */
696
697 ctlposinit(&cp, hwnd, 4, 4, 4);
698 beginbox(&cp, "Key", IDC_BOX_KEY);
699 cp2 = cp;
700 statictext(&cp2, "No key.", 1, IDC_NOKEY);
701 cp2 = cp;
702 statictext(&cp2, "", 1, IDC_GENERATING);
703 progressbar(&cp2, IDC_PROGRESS);
704 bigeditctrl(&cp,
705 "&Public key for pasting into authorized_keys file:",
706 IDC_PKSTATIC, IDC_KEYDISPLAY, 5);
707 SendDlgItemMessage(hwnd, IDC_KEYDISPLAY, EM_SETREADONLY, 1, 0);
708 staticedit(&cp, "Key fingerprint:", IDC_FPSTATIC,
709 IDC_FINGERPRINT, 75);
710 SendDlgItemMessage(hwnd, IDC_FINGERPRINT, EM_SETREADONLY, 1,
711 0);
712 staticedit(&cp, "Key &comment:", IDC_COMMENTSTATIC,
713 IDC_COMMENTEDIT, 75);
714 staticpassedit(&cp, "Key p&assphrase:", IDC_PASSPHRASE1STATIC,
715 IDC_PASSPHRASE1EDIT, 75);
716 staticpassedit(&cp, "C&onfirm passphrase:",
717 IDC_PASSPHRASE2STATIC, IDC_PASSPHRASE2EDIT, 75);
718 endbox(&cp);
719 beginbox(&cp, "Actions", IDC_BOX_ACTIONS);
720 staticbtn(&cp, "Generate a public/private key pair",
721 IDC_GENSTATIC, "&Generate", IDC_GENERATE);
722 staticbtn(&cp, "Load an existing private key file",
723 IDC_LOADSTATIC, "&Load", IDC_LOAD);
724 static2btn(&cp, "Save the generated key", IDC_SAVESTATIC,
725 "Save p&ublic key", IDC_SAVEPUB,
726 "&Save private key", IDC_SAVE);
727 endbox(&cp);
728 beginbox(&cp, "Parameters", IDC_BOX_PARAMS);
729 radioline(&cp, "Type of key to generate:", IDC_TYPESTATIC, 3,
730 "SSH&1 (RSA)", IDC_KEYSSH1,
731 "SSH2 &RSA", IDC_KEYSSH2RSA,
732 "SSH2 &DSA", IDC_KEYSSH2DSA, NULL);
733 staticedit(&cp, "Number of &bits in a generated key:",
734 IDC_BITSSTATIC, IDC_BITS, 20);
735 endbox(&cp);
736 }
737 CheckRadioButton(hwnd, IDC_KEYSSH1, IDC_KEYSSH2DSA, IDC_KEYSSH1);
738 CheckMenuRadioItem(state->keymenu, IDC_KEYSSH1, IDC_KEYSSH2DSA,
739 IDC_KEYSSH1, MF_BYCOMMAND);
740 SetDlgItemInt(hwnd, IDC_BITS, DEFAULT_KEYSIZE, FALSE);
741
742 /*
743 * Initially, hide the progress bar and the key display,
744 * and show the no-key display. Also disable the Save
745 * buttons, because with no key we obviously can't save
746 * anything.
747 */
748 ui_set_state(hwnd, state, 0);
749
750 return 1;
751 case WM_MOUSEMOVE:
752 state = (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
753 if (state->collecting_entropy &&
754 state->entropy && state->entropy_got < state->entropy_required) {
755 state->entropy[state->entropy_got++] = lParam;
756 state->entropy[state->entropy_got++] = GetMessageTime();
757 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS,
758 state->entropy_got, 0);
759 if (state->entropy_got >= state->entropy_required) {
760 struct rsa_key_thread_params *params;
761 DWORD threadid;
762
763 /*
764 * Seed the entropy pool
765 */
766 random_add_heavynoise(state->entropy, state->entropy_size);
767 memset(state->entropy, 0, state->entropy_size);
768 sfree(state->entropy);
769 state->collecting_entropy = FALSE;
770
771 SetDlgItemText(hwnd, IDC_GENERATING, generating_msg);
772 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETRANGE, 0,
773 MAKELPARAM(0, PROGRESSRANGE));
774 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS, 0, 0);
775
776 params = smalloc(sizeof(*params));
777 params->progressbar = GetDlgItem(hwnd, IDC_PROGRESS);
778 params->dialog = hwnd;
779 params->keysize = state->keysize;
780 params->is_dsa = state->is_dsa;
781 params->key = &state->key;
782 params->dsskey = &state->dsskey;
783
784 if (!CreateThread(NULL, 0, generate_rsa_key_thread,
785 params, 0, &threadid)) {
786 MessageBox(hwnd, "Out of thread resources",
787 "Key generation error",
788 MB_OK | MB_ICONERROR);
789 sfree(params);
790 } else {
791 state->generation_thread_exists = TRUE;
792 }
793 }
794 }
795 break;
796 case WM_COMMAND:
797 switch (LOWORD(wParam)) {
798 case IDC_KEYSSH1:
799 case IDC_KEYSSH2RSA:
800 case IDC_KEYSSH2DSA:
801 {
802 state = (struct MainDlgState *)
803 GetWindowLong(hwnd, GWL_USERDATA);
804 if (!IsDlgButtonChecked(hwnd, LOWORD(wParam)))
805 CheckRadioButton(hwnd, IDC_KEYSSH1, IDC_KEYSSH2DSA,
806 LOWORD(wParam));
807 CheckMenuRadioItem(state->keymenu, IDC_KEYSSH1, IDC_KEYSSH2DSA,
808 LOWORD(wParam), MF_BYCOMMAND);
809 }
810 break;
811 case IDC_QUIT:
812 PostMessage(hwnd, WM_CLOSE, 0, 0);
813 break;
814 case IDC_COMMENTEDIT:
815 if (HIWORD(wParam) == EN_CHANGE) {
816 state = (struct MainDlgState *)
817 GetWindowLong(hwnd, GWL_USERDATA);
818 if (state->key_exists) {
819 HWND editctl = GetDlgItem(hwnd, IDC_COMMENTEDIT);
820 int len = GetWindowTextLength(editctl);
821 if (*state->commentptr)
822 sfree(*state->commentptr);
823 *state->commentptr = smalloc(len + 1);
824 GetWindowText(editctl, *state->commentptr, len + 1);
825 if (state->ssh2) {
826 setupbigedit2(hwnd, IDC_KEYDISPLAY, IDC_PKSTATIC,
827 &state->ssh2key);
828 } else {
829 setupbigedit1(hwnd, IDC_KEYDISPLAY, IDC_PKSTATIC,
830 &state->key);
831 }
832 }
833 }
834 break;
835 case IDC_ABOUT:
836 EnableWindow(hwnd, 0);
837 DialogBox(hinst, MAKEINTRESOURCE(213), NULL, AboutProc);
838 EnableWindow(hwnd, 1);
839 SetActiveWindow(hwnd);
840 return 0;
841 case IDC_GIVEHELP:
842 if (HIWORD(wParam) == BN_CLICKED ||
843 HIWORD(wParam) == BN_DOUBLECLICKED) {
844 if (help_path) {
845 WinHelp(hwnd, help_path, HELP_COMMAND,
846 (DWORD)"JI(`',`puttygen.general')");
847 requested_help = TRUE;
848 }
849 }
850 return 0;
851 case IDC_GENERATE:
852 state =
853 (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
854 if (!state->generation_thread_exists) {
855 BOOL ok;
856 state->keysize = GetDlgItemInt(hwnd, IDC_BITS, &ok, FALSE);
857 if (!ok)
858 state->keysize = DEFAULT_KEYSIZE;
859 /* If we ever introduce a new key type, check it here! */
860 state->ssh2 = !IsDlgButtonChecked(hwnd, IDC_KEYSSH1);
861 state->is_dsa = IsDlgButtonChecked(hwnd, IDC_KEYSSH2DSA);
862 if (state->keysize < 256) {
863 int ret = MessageBox(hwnd,
864 "PuTTYgen will not generate a key"
865 " smaller than 256 bits.\n"
866 "Key length reset to 256. Continue?",
867 "PuTTYgen Warning",
868 MB_ICONWARNING | MB_OKCANCEL);
869 if (ret != IDOK)
870 break;
871 state->keysize = 256;
872 SetDlgItemInt(hwnd, IDC_BITS, 256, FALSE);
873 }
874 ui_set_state(hwnd, state, 1);
875 SetDlgItemText(hwnd, IDC_GENERATING, entropy_msg);
876 state->key_exists = FALSE;
877 state->collecting_entropy = TRUE;
878
879 /*
880 * My brief statistical tests on mouse movements
881 * suggest that there are about 2.5 bits of
882 * randomness in the x position, 2.5 in the y
883 * position, and 1.7 in the message time, making
884 * 5.7 bits of unpredictability per mouse movement.
885 * However, other people have told me it's far less
886 * than that, so I'm going to be stupidly cautious
887 * and knock that down to a nice round 2. With this
888 * method, we require two words per mouse movement,
889 * so with 2 bits per mouse movement we expect 2
890 * bits every 2 words.
891 */
892 state->entropy_required = (state->keysize / 2) * 2;
893 state->entropy_got = 0;
894 state->entropy_size = (state->entropy_required *
895 sizeof(*state->entropy));
896 state->entropy = smalloc(state->entropy_size);
897
898 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETRANGE, 0,
899 MAKELPARAM(0, state->entropy_required));
900 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS, 0, 0);
901 }
902 break;
903 case IDC_SAVE:
904 case IDC_EXPORT_OPENSSH:
905 case IDC_EXPORT_SSHCOM:
906 state =
907 (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
908 if (state->key_exists) {
909 char filename[FILENAME_MAX];
910 char passphrase[PASSPHRASE_MAXLEN];
911 char passphrase2[PASSPHRASE_MAXLEN];
912 int type, realtype;
913
914 if (state->ssh2)
915 realtype = SSH_KEYTYPE_SSH2;
916 else
917 realtype = SSH_KEYTYPE_SSH1;
918
919 if (LOWORD(wParam) == IDC_EXPORT_OPENSSH)
920 type = SSH_KEYTYPE_OPENSSH;
921 else if (LOWORD(wParam) == IDC_EXPORT_SSHCOM)
922 type = SSH_KEYTYPE_SSHCOM;
923 else
924 type = realtype;
925
926 if (type != realtype &&
927 import_target_type(type) != realtype) {
928 char msg[256];
929 sprintf(msg, "Cannot export an SSH%d key in an SSH%d"
930 " format", (state->ssh2 ? 2 : 1),
931 (state->ssh2 ? 1 : 2));
932 MessageBox(hwnd, msg,
933 "PuTTYgen Error", MB_OK | MB_ICONERROR);
934 break;
935 }
936
937 GetDlgItemText(hwnd, IDC_PASSPHRASE1EDIT,
938 passphrase, sizeof(passphrase));
939 GetDlgItemText(hwnd, IDC_PASSPHRASE2EDIT,
940 passphrase2, sizeof(passphrase2));
941 if (strcmp(passphrase, passphrase2)) {
942 MessageBox(hwnd,
943 "The two passphrases given do not match.",
944 "PuTTYgen Error", MB_OK | MB_ICONERROR);
945 break;
946 }
947 if (!*passphrase) {
948 int ret;
949 ret = MessageBox(hwnd,
950 "Are you sure you want to save this key\n"
951 "without a passphrase to protect it?",
952 "PuTTYgen Warning",
953 MB_YESNO | MB_ICONWARNING);
954 if (ret != IDYES)
955 break;
956 }
957 if (prompt_keyfile(hwnd, "Save private key as:",
958 filename, 1)) {
959 int ret;
960 FILE *fp = fopen(filename, "r");
961 if (fp) {
962 char buffer[FILENAME_MAX + 80];
963 fclose(fp);
964 sprintf(buffer, "Overwrite existing file\n%.*s?",
965 FILENAME_MAX, filename);
966 ret = MessageBox(hwnd, buffer, "PuTTYgen Warning",
967 MB_YESNO | MB_ICONWARNING);
968 if (ret != IDYES)
969 break;
970 }
971
972 if (state->ssh2) {
973 if (type != realtype)
974 ret = export_ssh2(filename, type, &state->ssh2key,
975 *passphrase ? passphrase : NULL);
976 else
977 ret = ssh2_save_userkey(filename, &state->ssh2key,
978 *passphrase ? passphrase :
979 NULL);
980 } else {
981 if (type != realtype)
982 ret = export_ssh1(filename, type, &state->key,
983 *passphrase ? passphrase : NULL);
984 else
985 ret = saversakey(filename, &state->key,
986 *passphrase ? passphrase : NULL);
987 }
988 if (ret <= 0) {
989 MessageBox(hwnd, "Unable to save key file",
990 "PuTTYgen Error", MB_OK | MB_ICONERROR);
991 }
992 }
993 }
994 break;
995 case IDC_SAVEPUB:
996 state =
997 (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
998 if (state->key_exists) {
999 char filename[FILENAME_MAX];
1000 if (prompt_keyfile(hwnd, "Save public key as:",
1001 filename, 1)) {
1002 int ret;
1003 FILE *fp = fopen(filename, "r");
1004 if (fp) {
1005 char buffer[FILENAME_MAX + 80];
1006 fclose(fp);
1007 sprintf(buffer, "Overwrite existing file\n%.*s?",
1008 FILENAME_MAX, filename);
1009 ret = MessageBox(hwnd, buffer, "PuTTYgen Warning",
1010 MB_YESNO | MB_ICONWARNING);
1011 if (ret != IDYES)
1012 break;
1013 }
1014 if (state->ssh2) {
1015 ret = save_ssh2_pubkey(filename, &state->ssh2key);
1016 } else {
1017 ret = save_ssh1_pubkey(filename, &state->key);
1018 }
1019 if (ret <= 0) {
1020 MessageBox(hwnd, "Unable to save key file",
1021 "PuTTYgen Error", MB_OK | MB_ICONERROR);
1022 }
1023 }
1024 }
1025 break;
1026 case IDC_LOAD:
1027 state =
1028 (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
1029 if (!state->generation_thread_exists) {
1030 char filename[FILENAME_MAX];
1031 if (prompt_keyfile(hwnd, "Load private key:", filename, 0)) {
1032 char passphrase[PASSPHRASE_MAXLEN];
1033 int needs_pass;
1034 int type, realtype;
1035 int ret;
1036 char *comment;
1037 struct PassphraseProcStruct pps;
1038 struct RSAKey newkey1;
1039 struct ssh2_userkey *newkey2 = NULL;
1040
1041 type = realtype = key_type(filename);
1042 if (type != SSH_KEYTYPE_SSH1 &&
1043 type != SSH_KEYTYPE_SSH2 &&
1044 !import_possible(type)) {
1045 char msg[256];
1046 sprintf(msg, "Couldn't load private key (%s)",
1047 key_type_to_str(type));
1048 MessageBox(NULL, msg,
1049 "PuTTYgen Error", MB_OK | MB_ICONERROR);
1050 break;
1051 }
1052
1053 if (type != SSH_KEYTYPE_SSH1 &&
1054 type != SSH_KEYTYPE_SSH2) {
1055 realtype = type;
1056 type = import_target_type(type);
1057 }
1058
1059 comment = NULL;
1060 if (realtype == SSH_KEYTYPE_SSH1)
1061 needs_pass = rsakey_encrypted(filename, &comment);
1062 else if (realtype == SSH_KEYTYPE_SSH2)
1063 needs_pass =
1064 ssh2_userkey_encrypted(filename, &comment);
1065 else
1066 needs_pass = import_encrypted(filename, realtype,
1067 &comment);
1068 pps.passphrase = passphrase;
1069 pps.comment = comment;
1070 do {
1071 if (needs_pass) {
1072 int dlgret;
1073 dlgret = DialogBoxParam(hinst,
1074 MAKEINTRESOURCE(210),
1075 NULL, PassphraseProc,
1076 (LPARAM) & pps);
1077 if (!dlgret) {
1078 ret = -2;
1079 break;
1080 }
1081 } else
1082 *passphrase = '\0';
1083 if (type == SSH_KEYTYPE_SSH1) {
1084 if (realtype == type)
1085 ret = loadrsakey(filename, &newkey1,
1086 passphrase);
1087 else
1088 ret = import_ssh1(filename, realtype,
1089 &newkey1, passphrase);
1090 } else {
1091 if (realtype == type)
1092 newkey2 = ssh2_load_userkey(filename,
1093 passphrase);
1094 else
1095 newkey2 = import_ssh2(filename, realtype,
1096 passphrase);
1097 if (newkey2 == SSH2_WRONG_PASSPHRASE)
1098 ret = -1;
1099 else if (!newkey2)
1100 ret = 0;
1101 else
1102 ret = 1;
1103 }
1104 } while (ret == -1);
1105 if (comment)
1106 sfree(comment);
1107 if (ret == 0) {
1108 MessageBox(NULL, "Couldn't load private key.",
1109 "PuTTYgen Error", MB_OK | MB_ICONERROR);
1110 } else if (ret == 1) {
1111 /*
1112 * Now update the key controls with all the
1113 * key data.
1114 */
1115 {
1116 SetDlgItemText(hwnd, IDC_PASSPHRASE1EDIT,
1117 passphrase);
1118 SetDlgItemText(hwnd, IDC_PASSPHRASE2EDIT,
1119 passphrase);
1120 if (type == SSH_KEYTYPE_SSH1) {
1121 char buf[128];
1122 char *savecomment;
1123
1124 state->ssh2 = FALSE;
1125 state->commentptr = &state->key.comment;
1126 state->key = newkey1;
1127
1128 /*
1129 * Set the key fingerprint.
1130 */
1131 savecomment = state->key.comment;
1132 state->key.comment = NULL;
1133 rsa_fingerprint(buf, sizeof(buf),
1134 &state->key);
1135 state->key.comment = savecomment;
1136
1137 SetDlgItemText(hwnd, IDC_FINGERPRINT, buf);
1138 /*
1139 * Construct a decimal representation
1140 * of the key, for pasting into
1141 * .ssh/authorized_keys on a Unix box.
1142 */
1143 setupbigedit1(hwnd, IDC_KEYDISPLAY,
1144 IDC_PKSTATIC, &state->key);
1145 } else {
1146 char *fp;
1147 char *savecomment;
1148
1149 state->ssh2 = TRUE;
1150 state->commentptr =
1151 &state->ssh2key.comment;
1152 state->ssh2key = *newkey2; /* structure copy */
1153 sfree(newkey2);
1154
1155 savecomment = state->ssh2key.comment;
1156 state->ssh2key.comment = NULL;
1157 fp =
1158 state->ssh2key.alg->
1159 fingerprint(state->ssh2key.data);
1160 state->ssh2key.comment = savecomment;
1161
1162 SetDlgItemText(hwnd, IDC_FINGERPRINT, fp);
1163 sfree(fp);
1164
1165 setupbigedit2(hwnd, IDC_KEYDISPLAY,
1166 IDC_PKSTATIC, &state->ssh2key);
1167 }
1168 SetDlgItemText(hwnd, IDC_COMMENTEDIT,
1169 *state->commentptr);
1170 }
1171 /*
1172 * Finally, hide the progress bar and show
1173 * the key data.
1174 */
1175 ui_set_state(hwnd, state, 2);
1176 state->key_exists = TRUE;
1177 }
1178 }
1179 }
1180 break;
1181 }
1182 return 0;
1183 case WM_DONEKEY:
1184 state = (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
1185 state->generation_thread_exists = FALSE;
1186 state->key_exists = TRUE;
1187 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETRANGE, 0,
1188 MAKELPARAM(0, PROGRESSRANGE));
1189 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS, PROGRESSRANGE, 0);
1190 if (state->ssh2) {
1191 if (state->is_dsa) {
1192 state->ssh2key.data = &state->dsskey;
1193 state->ssh2key.alg = &ssh_dss;
1194 } else {
1195 state->ssh2key.data = &state->key;
1196 state->ssh2key.alg = &ssh_rsa;
1197 }
1198 state->commentptr = &state->ssh2key.comment;
1199 } else {
1200 state->commentptr = &state->key.comment;
1201 }
1202 /*
1203 * Invent a comment for the key. We'll do this by including
1204 * the date in it. This will be so horrifyingly ugly that
1205 * the user will immediately want to change it, which is
1206 * what we want :-)
1207 */
1208 *state->commentptr = smalloc(30);
1209 {
1210 time_t t;
1211 struct tm *tm;
1212 time(&t);
1213 tm = localtime(&t);
1214 if (state->is_dsa)
1215 strftime(*state->commentptr, 30, "dsa-key-%Y%m%d", tm);
1216 else
1217 strftime(*state->commentptr, 30, "rsa-key-%Y%m%d", tm);
1218 }
1219
1220 /*
1221 * Now update the key controls with all the key data.
1222 */
1223 {
1224 char *savecomment;
1225 /*
1226 * Blank passphrase, initially. This isn't dangerous,
1227 * because we will warn (Are You Sure?) before allowing
1228 * the user to save an unprotected private key.
1229 */
1230 SetDlgItemText(hwnd, IDC_PASSPHRASE1EDIT, "");
1231 SetDlgItemText(hwnd, IDC_PASSPHRASE2EDIT, "");
1232 /*
1233 * Set the comment.
1234 */
1235 SetDlgItemText(hwnd, IDC_COMMENTEDIT, *state->commentptr);
1236 /*
1237 * Set the key fingerprint.
1238 */
1239 savecomment = *state->commentptr;
1240 *state->commentptr = NULL;
1241 if (state->ssh2) {
1242 char *fp;
1243 fp = state->ssh2key.alg->fingerprint(state->ssh2key.data);
1244 SetDlgItemText(hwnd, IDC_FINGERPRINT, fp);
1245 sfree(fp);
1246 } else {
1247 char buf[128];
1248 rsa_fingerprint(buf, sizeof(buf), &state->key);
1249 SetDlgItemText(hwnd, IDC_FINGERPRINT, buf);
1250 }
1251 *state->commentptr = savecomment;
1252 /*
1253 * Construct a decimal representation of the key, for
1254 * pasting into .ssh/authorized_keys or
1255 * .ssh/authorized_keys2 on a Unix box.
1256 */
1257 if (state->ssh2) {
1258 setupbigedit2(hwnd, IDC_KEYDISPLAY,
1259 IDC_PKSTATIC, &state->ssh2key);
1260 } else {
1261 setupbigedit1(hwnd, IDC_KEYDISPLAY,
1262 IDC_PKSTATIC, &state->key);
1263 }
1264 }
1265 /*
1266 * Finally, hide the progress bar and show the key data.
1267 */
1268 ui_set_state(hwnd, state, 2);
1269 break;
1270 case WM_HELP:
1271 if (help_path) {
1272 int id = ((LPHELPINFO)lParam)->iCtrlId;
1273 char *cmd = NULL;
1274 switch (id) {
1275 case IDC_GENERATING:
1276 case IDC_PROGRESS:
1277 case IDC_GENSTATIC:
1278 case IDC_GENERATE:
1279 cmd = "JI(`',`puttygen.generate')"; break;
1280 case IDC_PKSTATIC:
1281 case IDC_KEYDISPLAY:
1282 cmd = "JI(`',`puttygen.pastekey')"; break;
1283 case IDC_FPSTATIC:
1284 case IDC_FINGERPRINT:
1285 cmd = "JI(`',`puttygen.fingerprint')"; break;
1286 case IDC_COMMENTSTATIC:
1287 case IDC_COMMENTEDIT:
1288 cmd = "JI(`',`puttygen.comment')"; break;
1289 case IDC_PASSPHRASE1STATIC:
1290 case IDC_PASSPHRASE1EDIT:
1291 case IDC_PASSPHRASE2STATIC:
1292 case IDC_PASSPHRASE2EDIT:
1293 cmd = "JI(`',`puttygen.passphrase')"; break;
1294 case IDC_LOADSTATIC:
1295 case IDC_LOAD:
1296 cmd = "JI(`',`puttygen.load')"; break;
1297 case IDC_SAVESTATIC:
1298 case IDC_SAVE:
1299 cmd = "JI(`',`puttygen.savepriv')"; break;
1300 case IDC_SAVEPUB:
1301 cmd = "JI(`',`puttygen.savepub')"; break;
1302 case IDC_TYPESTATIC:
1303 case IDC_KEYSSH1:
1304 case IDC_KEYSSH2RSA:
1305 case IDC_KEYSSH2DSA:
1306 cmd = "JI(`',`puttygen.keytype')"; break;
1307 case IDC_BITSSTATIC:
1308 case IDC_BITS:
1309 cmd = "JI(`',`puttygen.bits')"; break;
1310 case IDC_EXPORT_OPENSSH:
1311 case IDC_EXPORT_SSHCOM:
1312 cmd = "JI(`',`puttygen.export')"; break;
1313 }
1314 if (cmd) {
1315 WinHelp(hwnd, help_path, HELP_COMMAND, (DWORD)cmd);
1316 requested_help = TRUE;
1317 } else {
1318 MessageBeep(0);
1319 }
1320 }
1321 break;
1322 case WM_CLOSE:
1323 state = (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
1324 sfree(state);
1325 if (requested_help) {
1326 WinHelp(hwnd, help_path, HELP_QUIT, 0);
1327 requested_help = FALSE;
1328 }
1329 EndDialog(hwnd, 1);
1330 return 0;
1331 }
1332 return 0;
1333 }
1334
1335 void cleanup_exit(int code) { exit(code); }
1336
1337 int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show)
1338 {
1339 InitCommonControls();
1340 hinst = inst;
1341
1342 /*
1343 * See if we can find our Help file.
1344 */
1345 {
1346 char b[2048], *p, *q, *r;
1347 FILE *fp;
1348 GetModuleFileName(NULL, b, sizeof(b) - 1);
1349 r = b;
1350 p = strrchr(b, '\\');
1351 if (p && p >= r) r = p+1;
1352 q = strrchr(b, ':');
1353 if (q && q >= r) r = q+1;
1354 strcpy(r, "putty.hlp");
1355 if ( (fp = fopen(b, "r")) != NULL) {
1356 help_path = dupstr(b);
1357 fclose(fp);
1358 } else
1359 help_path = NULL;
1360 }
1361
1362 random_init();
1363 return DialogBox(hinst, MAKEINTRESOURCE(201), NULL,
1364 MainDlgProc) != IDOK;
1365 }
Simon Tatham's PuTTY GUI SSH client; import of svn://svn.tartarus.org/sgt/putty