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