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