2 * PuTTY key generation front end (Windows).
9 #define PUTTY_DO_GLOBALS
20 #define WM_DONEKEY (WM_XUSER + 1)
22 #define DEFAULT_KEYSIZE 1024
24 static int requested_help;
26 static char *cmdline_keyfile = NULL;
29 * Print a modal (Really Bad) message box and perform a fatal exit.
31 void modalfatalbox(char *fmt, ...)
37 stuff = dupvprintf(fmt, ap);
39 MessageBox(NULL, stuff, "PuTTYgen Fatal Error",
40 MB_SYSTEMMODAL | MB_ICONERROR | MB_OK);
45 /* ----------------------------------------------------------------------
46 * Progress report code. This is really horrible :-)
48 #define PROGRESSRANGE 65535
54 unsigned startpoint, total;
55 unsigned param, current, n; /* if exponential */
56 unsigned mult; /* if linear */
58 unsigned total, divisor, range;
62 static void progress_update(void *param, int action, int phase, int iprogress)
64 struct progress *p = (struct progress *) param;
65 unsigned progress = iprogress;
68 if (action < PROGFN_READY && p->nphases < phase)
71 case PROGFN_INITIALISE:
74 case PROGFN_LIN_PHASE:
75 p->phases[phase-1].exponential = 0;
76 p->phases[phase-1].mult = p->phases[phase].total / progress;
78 case PROGFN_EXP_PHASE:
79 p->phases[phase-1].exponential = 1;
80 p->phases[phase-1].param = 0x10000 + progress;
81 p->phases[phase-1].current = p->phases[phase-1].total;
82 p->phases[phase-1].n = 0;
84 case PROGFN_PHASE_EXTENT:
85 p->phases[phase-1].total = progress;
91 for (i = 0; i < p->nphases; i++) {
92 p->phases[i].startpoint = total;
93 total += p->phases[i].total;
96 p->divisor = ((p->total + PROGRESSRANGE - 1) / PROGRESSRANGE);
97 p->range = p->total / p->divisor;
98 SendMessage(p->progbar, PBM_SETRANGE, 0, MAKELPARAM(0, p->range));
101 case PROGFN_PROGRESS:
102 if (p->phases[phase-1].exponential) {
103 while (p->phases[phase-1].n < progress) {
104 p->phases[phase-1].n++;
105 p->phases[phase-1].current *= p->phases[phase-1].param;
106 p->phases[phase-1].current /= 0x10000;
108 position = (p->phases[phase-1].startpoint +
109 p->phases[phase-1].total - p->phases[phase-1].current);
111 position = (p->phases[phase-1].startpoint +
112 progress * p->phases[phase-1].mult);
114 SendMessage(p->progbar, PBM_SETPOS, position / p->divisor, 0);
121 #define PASSPHRASE_MAXLEN 512
123 struct PassphraseProcStruct {
129 * Dialog-box function for the passphrase box.
131 static int CALLBACK PassphraseProc(HWND hwnd, UINT msg,
132 WPARAM wParam, LPARAM lParam)
134 static char *passphrase = NULL;
135 struct PassphraseProcStruct *p;
139 SetForegroundWindow(hwnd);
140 SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0,
141 SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
146 { /* centre the window */
150 hw = GetDesktopWindow();
151 if (GetWindowRect(hw, &rs) && GetWindowRect(hwnd, &rd))
153 (rs.right + rs.left + rd.left - rd.right) / 2,
154 (rs.bottom + rs.top + rd.top - rd.bottom) / 2,
155 rd.right - rd.left, rd.bottom - rd.top, TRUE);
158 p = (struct PassphraseProcStruct *) lParam;
159 passphrase = p->passphrase;
161 SetDlgItemText(hwnd, 101, p->comment);
163 SetDlgItemText(hwnd, 102, passphrase);
166 switch (LOWORD(wParam)) {
176 case 102: /* edit box */
177 if ((HIWORD(wParam) == EN_CHANGE) && passphrase) {
178 GetDlgItemText(hwnd, 102, passphrase,
179 PASSPHRASE_MAXLEN - 1);
180 passphrase[PASSPHRASE_MAXLEN - 1] = '\0';
193 * Prompt for a key file. Assumes the filename buffer is of size
196 static int prompt_keyfile(HWND hwnd, char *dlgtitle,
197 char *filename, int save, int ppk)
200 memset(&of, 0, sizeof(of));
201 #ifdef OPENFILENAME_SIZE_VERSION_400
202 of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
204 of.lStructSize = sizeof(of);
208 of.lpstrFilter = "PuTTY Private Key Files (*.ppk)\0*.ppk\0"
209 "All Files (*.*)\0*\0\0\0";
210 of.lpstrDefExt = ".ppk";
212 of.lpstrFilter = "All Files (*.*)\0*\0\0\0";
214 of.lpstrCustomFilter = NULL;
216 of.lpstrFile = filename;
218 of.nMaxFile = FILENAME_MAX;
219 of.lpstrFileTitle = NULL;
220 of.lpstrInitialDir = NULL;
221 of.lpstrTitle = dlgtitle;
224 return GetSaveFileName(&of);
226 return GetOpenFileName(&of);
230 * Dialog-box function for the Licence box.
232 static int CALLBACK LicenceProc(HWND hwnd, UINT msg,
233 WPARAM wParam, LPARAM lParam)
240 { /* centre the window */
244 hw = GetDesktopWindow();
245 if (GetWindowRect(hw, &rs) && GetWindowRect(hwnd, &rd))
247 (rs.right + rs.left + rd.left - rd.right) / 2,
248 (rs.bottom + rs.top + rd.top - rd.bottom) / 2,
249 rd.right - rd.left, rd.bottom - rd.top, TRUE);
254 switch (LOWORD(wParam)) {
269 * Dialog-box function for the About box.
271 static int CALLBACK AboutProc(HWND hwnd, UINT msg,
272 WPARAM wParam, LPARAM lParam)
279 { /* centre the window */
283 hw = GetDesktopWindow();
284 if (GetWindowRect(hw, &rs) && GetWindowRect(hwnd, &rd))
286 (rs.right + rs.left + rd.left - rd.right) / 2,
287 (rs.bottom + rs.top + rd.top - rd.bottom) / 2,
288 rd.right - rd.left, rd.bottom - rd.top, TRUE);
291 SetDlgItemText(hwnd, 100, ver);
294 switch (LOWORD(wParam)) {
300 EnableWindow(hwnd, 0);
301 DialogBox(hinst, MAKEINTRESOURCE(214), hwnd, LicenceProc);
302 EnableWindow(hwnd, 1);
303 SetActiveWindow(hwnd);
315 * Thread to generate a key.
317 struct rsa_key_thread_params {
318 HWND progressbar; /* notify this with progress */
319 HWND dialog; /* notify this on completion */
320 int keysize; /* bits in key */
323 struct dss_key *dsskey;
325 static DWORD WINAPI generate_rsa_key_thread(void *param)
327 struct rsa_key_thread_params *params =
328 (struct rsa_key_thread_params *) param;
329 struct progress prog;
330 prog.progbar = params->progressbar;
332 progress_update(&prog, PROGFN_INITIALISE, 0, 0);
335 dsa_generate(params->dsskey, params->keysize, progress_update, &prog);
337 rsa_generate(params->key, params->keysize, progress_update, &prog);
339 PostMessage(params->dialog, WM_DONEKEY, 0, 0);
345 struct MainDlgState {
346 int collecting_entropy;
347 int generation_thread_exists;
349 int entropy_got, entropy_required, entropy_size;
352 char **commentptr; /* points to key.comment or ssh2key.comment */
353 struct ssh2_userkey ssh2key;
356 struct dss_key dsskey;
357 HMENU filemenu, keymenu, cvtmenu;
360 static void hidemany(HWND hwnd, const int *ids, int hideit)
363 ShowWindow(GetDlgItem(hwnd, *ids++), (hideit ? SW_HIDE : SW_SHOW));
367 static void setupbigedit1(HWND hwnd, int id, int idstatic, struct RSAKey *key)
372 dec1 = bignum_decimal(key->exponent);
373 dec2 = bignum_decimal(key->modulus);
374 buffer = dupprintf("%d %s %s %s", bignum_bitcount(key->modulus),
375 dec1, dec2, key->comment);
376 SetDlgItemText(hwnd, id, buffer);
377 SetDlgItemText(hwnd, idstatic,
378 "&Public key for pasting into authorized_keys file:");
384 static void setupbigedit2(HWND hwnd, int id, int idstatic,
385 struct ssh2_userkey *key)
387 unsigned char *pub_blob;
392 pub_blob = key->alg->public_blob(key->data, &pub_len);
393 buffer = snewn(strlen(key->alg->name) + 4 * ((pub_len + 2) / 3) +
394 strlen(key->comment) + 3, char);
395 strcpy(buffer, key->alg->name);
396 p = buffer + strlen(buffer);
399 while (i < pub_len) {
400 int n = (pub_len - i < 3 ? pub_len - i : 3);
401 base64_encode_atom(pub_blob + i, n, p);
406 strcpy(p, key->comment);
407 SetDlgItemText(hwnd, id, buffer);
408 SetDlgItemText(hwnd, idstatic, "&Public key for pasting into "
409 "OpenSSH authorized_keys file:");
414 static int save_ssh1_pubkey(char *filename, struct RSAKey *key)
419 dec1 = bignum_decimal(key->exponent);
420 dec2 = bignum_decimal(key->modulus);
421 fp = fopen(filename, "wb");
424 fprintf(fp, "%d %s %s %s\n",
425 bignum_bitcount(key->modulus), dec1, dec2, key->comment);
433 * Warn about the obsolescent key file format.
435 void old_keyfile_warning(void)
437 static const char mbtitle[] = "PuTTY Key File Warning";
438 static const char message[] =
439 "You are loading an SSH 2 private key which has an\n"
440 "old version of the file format. This means your key\n"
441 "file is not fully tamperproof. Future versions of\n"
442 "PuTTY may stop supporting this private key format,\n"
443 "so we recommend you convert your key to the new\n"
446 "Once the key is loaded into PuTTYgen, you can perform\n"
447 "this conversion simply by saving it again.";
449 MessageBox(NULL, message, mbtitle, MB_OK);
452 static int save_ssh2_pubkey(char *filename, struct ssh2_userkey *key)
454 unsigned char *pub_blob;
460 pub_blob = key->alg->public_blob(key->data, &pub_len);
462 fp = fopen(filename, "wb");
466 fprintf(fp, "---- BEGIN SSH2 PUBLIC KEY ----\n");
468 fprintf(fp, "Comment: \"");
469 for (p = key->comment; *p; p++) {
470 if (*p == '\\' || *p == '\"')
478 while (i < pub_len) {
480 int n = (pub_len - i < 3 ? pub_len - i : 3);
481 base64_encode_atom(pub_blob + i, n, buf);
485 if (++column >= 16) {
493 fprintf(fp, "---- END SSH2 PUBLIC KEY ----\n");
500 controlidstart = 100,
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,
513 IDC_GENSTATIC, IDC_GENERATE,
514 IDC_LOADSTATIC, IDC_LOAD,
515 IDC_SAVESTATIC, IDC_SAVE, IDC_SAVEPUB,
517 IDC_TYPESTATIC, IDC_KEYSSH1, IDC_KEYSSH2RSA, IDC_KEYSSH2DSA,
518 IDC_BITSSTATIC, IDC_BITS,
521 IDC_IMPORT, IDC_EXPORT_OPENSSH, IDC_EXPORT_SSHCOM
524 static const int nokey_ids[] = { IDC_NOKEY, 0 };
525 static const int generating_ids[] = { IDC_GENERATING, IDC_PROGRESS, 0 };
526 static const int gotkey_ids[] = {
527 IDC_PKSTATIC, IDC_KEYDISPLAY,
528 IDC_FPSTATIC, IDC_FINGERPRINT,
529 IDC_COMMENTSTATIC, IDC_COMMENTEDIT,
530 IDC_PASSPHRASE1STATIC, IDC_PASSPHRASE1EDIT,
531 IDC_PASSPHRASE2STATIC, IDC_PASSPHRASE2EDIT, 0
535 * Small UI helper function to switch the state of the main dialog
536 * by enabling and disabling controls and menu items.
538 void ui_set_state(HWND hwnd, struct MainDlgState *state, int status)
544 hidemany(hwnd, nokey_ids, FALSE);
545 hidemany(hwnd, generating_ids, TRUE);
546 hidemany(hwnd, gotkey_ids, TRUE);
547 EnableWindow(GetDlgItem(hwnd, IDC_GENERATE), 1);
548 EnableWindow(GetDlgItem(hwnd, IDC_LOAD), 1);
549 EnableWindow(GetDlgItem(hwnd, IDC_SAVE), 0);
550 EnableWindow(GetDlgItem(hwnd, IDC_SAVEPUB), 0);
551 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH1), 1);
552 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2RSA), 1);
553 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2DSA), 1);
554 EnableWindow(GetDlgItem(hwnd, IDC_BITS), 1);
555 EnableMenuItem(state->filemenu, IDC_LOAD, MF_ENABLED|MF_BYCOMMAND);
556 EnableMenuItem(state->filemenu, IDC_SAVE, MF_GRAYED|MF_BYCOMMAND);
557 EnableMenuItem(state->filemenu, IDC_SAVEPUB, MF_GRAYED|MF_BYCOMMAND);
558 EnableMenuItem(state->keymenu, IDC_GENERATE, MF_ENABLED|MF_BYCOMMAND);
559 EnableMenuItem(state->keymenu, IDC_KEYSSH1, MF_ENABLED|MF_BYCOMMAND);
560 EnableMenuItem(state->keymenu, IDC_KEYSSH2RSA, MF_ENABLED|MF_BYCOMMAND);
561 EnableMenuItem(state->keymenu, IDC_KEYSSH2DSA, MF_ENABLED|MF_BYCOMMAND);
562 EnableMenuItem(state->cvtmenu, IDC_IMPORT, MF_ENABLED|MF_BYCOMMAND);
563 EnableMenuItem(state->cvtmenu, IDC_EXPORT_OPENSSH,
564 MF_GRAYED|MF_BYCOMMAND);
565 EnableMenuItem(state->cvtmenu, IDC_EXPORT_SSHCOM,
566 MF_GRAYED|MF_BYCOMMAND);
568 case 1: /* generating key */
569 hidemany(hwnd, nokey_ids, TRUE);
570 hidemany(hwnd, generating_ids, FALSE);
571 hidemany(hwnd, gotkey_ids, TRUE);
572 EnableWindow(GetDlgItem(hwnd, IDC_GENERATE), 0);
573 EnableWindow(GetDlgItem(hwnd, IDC_LOAD), 0);
574 EnableWindow(GetDlgItem(hwnd, IDC_SAVE), 0);
575 EnableWindow(GetDlgItem(hwnd, IDC_SAVEPUB), 0);
576 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH1), 0);
577 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2RSA), 0);
578 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2DSA), 0);
579 EnableWindow(GetDlgItem(hwnd, IDC_BITS), 0);
580 EnableMenuItem(state->filemenu, IDC_LOAD, MF_GRAYED|MF_BYCOMMAND);
581 EnableMenuItem(state->filemenu, IDC_SAVE, MF_GRAYED|MF_BYCOMMAND);
582 EnableMenuItem(state->filemenu, IDC_SAVEPUB, MF_GRAYED|MF_BYCOMMAND);
583 EnableMenuItem(state->keymenu, IDC_GENERATE, MF_GRAYED|MF_BYCOMMAND);
584 EnableMenuItem(state->keymenu, IDC_KEYSSH1, MF_GRAYED|MF_BYCOMMAND);
585 EnableMenuItem(state->keymenu, IDC_KEYSSH2RSA, MF_GRAYED|MF_BYCOMMAND);
586 EnableMenuItem(state->keymenu, IDC_KEYSSH2DSA, MF_GRAYED|MF_BYCOMMAND);
587 EnableMenuItem(state->cvtmenu, IDC_IMPORT, MF_GRAYED|MF_BYCOMMAND);
588 EnableMenuItem(state->cvtmenu, IDC_EXPORT_OPENSSH,
589 MF_GRAYED|MF_BYCOMMAND);
590 EnableMenuItem(state->cvtmenu, IDC_EXPORT_SSHCOM,
591 MF_GRAYED|MF_BYCOMMAND);
594 hidemany(hwnd, nokey_ids, TRUE);
595 hidemany(hwnd, generating_ids, TRUE);
596 hidemany(hwnd, gotkey_ids, FALSE);
597 EnableWindow(GetDlgItem(hwnd, IDC_GENERATE), 1);
598 EnableWindow(GetDlgItem(hwnd, IDC_LOAD), 1);
599 EnableWindow(GetDlgItem(hwnd, IDC_SAVE), 1);
600 EnableWindow(GetDlgItem(hwnd, IDC_SAVEPUB), 1);
601 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH1), 1);
602 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2RSA), 1);
603 EnableWindow(GetDlgItem(hwnd, IDC_KEYSSH2DSA), 1);
604 EnableWindow(GetDlgItem(hwnd, IDC_BITS), 1);
605 EnableMenuItem(state->filemenu, IDC_LOAD, MF_ENABLED|MF_BYCOMMAND);
606 EnableMenuItem(state->filemenu, IDC_SAVE, MF_ENABLED|MF_BYCOMMAND);
607 EnableMenuItem(state->filemenu, IDC_SAVEPUB, MF_ENABLED|MF_BYCOMMAND);
608 EnableMenuItem(state->keymenu, IDC_GENERATE, MF_ENABLED|MF_BYCOMMAND);
609 EnableMenuItem(state->keymenu, IDC_KEYSSH1, MF_ENABLED|MF_BYCOMMAND);
610 EnableMenuItem(state->keymenu, IDC_KEYSSH2RSA,MF_ENABLED|MF_BYCOMMAND);
611 EnableMenuItem(state->keymenu, IDC_KEYSSH2DSA,MF_ENABLED|MF_BYCOMMAND);
612 EnableMenuItem(state->cvtmenu, IDC_IMPORT, MF_ENABLED|MF_BYCOMMAND);
614 * Enable export menu items if and only if the key type
615 * supports this kind of export.
617 type = state->ssh2 ? SSH_KEYTYPE_SSH2 : SSH_KEYTYPE_SSH1;
618 #define do_export_menuitem(x,y) \
619 EnableMenuItem(state->cvtmenu, x, MF_BYCOMMAND | \
620 (import_target_type(y)==type?MF_ENABLED:MF_GRAYED))
621 do_export_menuitem(IDC_EXPORT_OPENSSH, SSH_KEYTYPE_OPENSSH);
622 do_export_menuitem(IDC_EXPORT_SSHCOM, SSH_KEYTYPE_SSHCOM);
623 #undef do_export_menuitem
628 void load_key_file(HWND hwnd, struct MainDlgState *state,
629 Filename filename, int was_import_cmd)
631 char passphrase[PASSPHRASE_MAXLEN];
636 struct PassphraseProcStruct pps;
637 struct RSAKey newkey1;
638 struct ssh2_userkey *newkey2 = NULL;
640 type = realtype = key_type(&filename);
641 if (type != SSH_KEYTYPE_SSH1 &&
642 type != SSH_KEYTYPE_SSH2 &&
643 !import_possible(type)) {
645 sprintf(msg, "Couldn't load private key (%s)",
646 key_type_to_str(type));
647 MessageBox(NULL, msg,
648 "PuTTYgen Error", MB_OK | MB_ICONERROR);
652 if (type != SSH_KEYTYPE_SSH1 &&
653 type != SSH_KEYTYPE_SSH2) {
655 type = import_target_type(type);
659 if (realtype == SSH_KEYTYPE_SSH1)
660 needs_pass = rsakey_encrypted(&filename, &comment);
661 else if (realtype == SSH_KEYTYPE_SSH2)
663 ssh2_userkey_encrypted(&filename, &comment);
665 needs_pass = import_encrypted(&filename, realtype,
667 pps.passphrase = passphrase;
668 pps.comment = comment;
672 dlgret = DialogBoxParam(hinst,
673 MAKEINTRESOURCE(210),
674 NULL, PassphraseProc,
682 if (type == SSH_KEYTYPE_SSH1) {
683 if (realtype == type)
684 ret = loadrsakey(&filename, &newkey1,
687 ret = import_ssh1(&filename, realtype,
688 &newkey1, passphrase);
690 if (realtype == type)
691 newkey2 = ssh2_load_userkey(&filename,
694 newkey2 = import_ssh2(&filename, realtype,
696 if (newkey2 == SSH2_WRONG_PASSPHRASE)
707 MessageBox(NULL, "Couldn't load private key.",
708 "PuTTYgen Error", MB_OK | MB_ICONERROR);
709 } else if (ret == 1) {
711 * Now update the key controls with all the
715 SetDlgItemText(hwnd, IDC_PASSPHRASE1EDIT,
717 SetDlgItemText(hwnd, IDC_PASSPHRASE2EDIT,
719 if (type == SSH_KEYTYPE_SSH1) {
724 state->commentptr = &state->key.comment;
725 state->key = newkey1;
728 * Set the key fingerprint.
730 savecomment = state->key.comment;
731 state->key.comment = NULL;
732 rsa_fingerprint(buf, sizeof(buf),
734 state->key.comment = savecomment;
736 SetDlgItemText(hwnd, IDC_FINGERPRINT, buf);
738 * Construct a decimal representation
739 * of the key, for pasting into
740 * .ssh/authorized_keys on a Unix box.
742 setupbigedit1(hwnd, IDC_KEYDISPLAY,
743 IDC_PKSTATIC, &state->key);
750 &state->ssh2key.comment;
751 state->ssh2key = *newkey2; /* structure copy */
754 savecomment = state->ssh2key.comment;
755 state->ssh2key.comment = NULL;
758 fingerprint(state->ssh2key.data);
759 state->ssh2key.comment = savecomment;
761 SetDlgItemText(hwnd, IDC_FINGERPRINT, fp);
764 setupbigedit2(hwnd, IDC_KEYDISPLAY,
765 IDC_PKSTATIC, &state->ssh2key);
767 SetDlgItemText(hwnd, IDC_COMMENTEDIT,
771 * Finally, hide the progress bar and show
774 ui_set_state(hwnd, state, 2);
775 state->key_exists = TRUE;
778 * If the user has imported a foreign key
779 * using the Load command, let them know.
780 * If they've used the Import command, be
783 if (realtype != type && !was_import_cmd) {
785 sprintf(msg, "Successfully imported foreign key\n"
787 "To use this key with PuTTY, you need to\n"
788 "use the \"Save private key\" command to\n"
789 "save it in PuTTY's own format.",
790 key_type_to_str(realtype));
791 MessageBox(NULL, msg, "PuTTYgen Notice",
792 MB_OK | MB_ICONINFORMATION);
798 * Dialog-box function for the main PuTTYgen dialog box.
800 static int CALLBACK MainDlgProc(HWND hwnd, UINT msg,
801 WPARAM wParam, LPARAM lParam)
803 static const char generating_msg[] =
804 "Please wait while a key is generated...";
805 static const char entropy_msg[] =
806 "Please generate some randomness by moving the mouse over the blank area.";
807 struct MainDlgState *state;
812 SetWindowLong(hwnd, GWL_EXSTYLE,
813 GetWindowLong(hwnd, GWL_EXSTYLE) | WS_EX_CONTEXTHELP);
816 * If we add a Help button, this is where we destroy it
817 * if the help file isn't present.
820 requested_help = FALSE;
821 SendMessage(hwnd, WM_SETICON, (WPARAM) ICON_BIG,
822 (LPARAM) LoadIcon(hinst, MAKEINTRESOURCE(200)));
824 state = snew(struct MainDlgState);
825 state->generation_thread_exists = FALSE;
826 state->collecting_entropy = FALSE;
827 state->entropy = NULL;
828 state->key_exists = FALSE;
829 SetWindowLong(hwnd, GWL_USERDATA, (LONG) state);
835 menu1 = CreateMenu();
836 AppendMenu(menu1, MF_ENABLED, IDC_LOAD, "&Load private key");
837 AppendMenu(menu1, MF_ENABLED, IDC_SAVEPUB, "Save p&ublic key");
838 AppendMenu(menu1, MF_ENABLED, IDC_SAVE, "&Save private key");
839 AppendMenu(menu1, MF_SEPARATOR, 0, 0);
840 AppendMenu(menu1, MF_ENABLED, IDC_QUIT, "E&xit");
841 AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1, "&File");
842 state->filemenu = menu1;
844 menu1 = CreateMenu();
845 AppendMenu(menu1, MF_ENABLED, IDC_GENERATE, "&Generate key pair");
846 AppendMenu(menu1, MF_SEPARATOR, 0, 0);
847 AppendMenu(menu1, MF_ENABLED, IDC_KEYSSH1, "SSH&1 key (RSA)");
848 AppendMenu(menu1, MF_ENABLED, IDC_KEYSSH2RSA, "SSH2 &RSA key");
849 AppendMenu(menu1, MF_ENABLED, IDC_KEYSSH2DSA, "SSH2 &DSA key");
850 AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1, "&Key");
851 state->keymenu = menu1;
853 menu1 = CreateMenu();
854 AppendMenu(menu1, MF_ENABLED, IDC_IMPORT, "&Import key");
855 AppendMenu(menu1, MF_SEPARATOR, 0, 0);
856 AppendMenu(menu1, MF_ENABLED, IDC_EXPORT_OPENSSH,
857 "Export &OpenSSH key");
858 AppendMenu(menu1, MF_ENABLED, IDC_EXPORT_SSHCOM,
859 "Export &ssh.com key");
860 AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1,
862 state->cvtmenu = menu1;
864 menu1 = CreateMenu();
865 AppendMenu(menu1, MF_ENABLED, IDC_ABOUT, "&About");
867 AppendMenu(menu1, MF_ENABLED, IDC_GIVEHELP, "&Help");
868 AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1, "&Help");
876 { /* centre the window */
880 hw = GetDesktopWindow();
881 if (GetWindowRect(hw, &rs) && GetWindowRect(hwnd, &rd))
883 (rs.right + rs.left + rd.left - rd.right) / 2,
884 (rs.bottom + rs.top + rd.top - rd.bottom) / 2,
885 rd.right - rd.left, rd.bottom - rd.top, TRUE);
889 struct ctlpos cp, cp2;
891 /* Accelerators used: acglops1rbd */
893 ctlposinit(&cp, hwnd, 4, 4, 4);
894 beginbox(&cp, "Key", IDC_BOX_KEY);
896 statictext(&cp2, "No key.", 1, IDC_NOKEY);
898 statictext(&cp2, "", 1, IDC_GENERATING);
899 progressbar(&cp2, IDC_PROGRESS);
901 "&Public key for pasting into authorized_keys file:",
902 IDC_PKSTATIC, IDC_KEYDISPLAY, 5);
903 SendDlgItemMessage(hwnd, IDC_KEYDISPLAY, EM_SETREADONLY, 1, 0);
904 staticedit(&cp, "Key f&ingerprint:", IDC_FPSTATIC,
905 IDC_FINGERPRINT, 75);
906 SendDlgItemMessage(hwnd, IDC_FINGERPRINT, EM_SETREADONLY, 1,
908 staticedit(&cp, "Key &comment:", IDC_COMMENTSTATIC,
909 IDC_COMMENTEDIT, 75);
910 staticpassedit(&cp, "Key p&assphrase:", IDC_PASSPHRASE1STATIC,
911 IDC_PASSPHRASE1EDIT, 75);
912 staticpassedit(&cp, "C&onfirm passphrase:",
913 IDC_PASSPHRASE2STATIC, IDC_PASSPHRASE2EDIT, 75);
915 beginbox(&cp, "Actions", IDC_BOX_ACTIONS);
916 staticbtn(&cp, "Generate a public/private key pair",
917 IDC_GENSTATIC, "&Generate", IDC_GENERATE);
918 staticbtn(&cp, "Load an existing private key file",
919 IDC_LOADSTATIC, "&Load", IDC_LOAD);
920 static2btn(&cp, "Save the generated key", IDC_SAVESTATIC,
921 "Save p&ublic key", IDC_SAVEPUB,
922 "&Save private key", IDC_SAVE);
924 beginbox(&cp, "Parameters", IDC_BOX_PARAMS);
925 radioline(&cp, "Type of key to generate:", IDC_TYPESTATIC, 3,
926 "SSH&1 (RSA)", IDC_KEYSSH1,
927 "SSH2 &RSA", IDC_KEYSSH2RSA,
928 "SSH2 &DSA", IDC_KEYSSH2DSA, NULL);
929 staticedit(&cp, "Number of &bits in a generated key:",
930 IDC_BITSSTATIC, IDC_BITS, 20);
933 CheckRadioButton(hwnd, IDC_KEYSSH1, IDC_KEYSSH2DSA, IDC_KEYSSH2RSA);
934 CheckMenuRadioItem(state->keymenu, IDC_KEYSSH1, IDC_KEYSSH2DSA,
935 IDC_KEYSSH2RSA, MF_BYCOMMAND);
936 SetDlgItemInt(hwnd, IDC_BITS, DEFAULT_KEYSIZE, FALSE);
939 * Initially, hide the progress bar and the key display,
940 * and show the no-key display. Also disable the Save
941 * buttons, because with no key we obviously can't save
944 ui_set_state(hwnd, state, 0);
947 * Load a key file if one was provided on the command line.
950 load_key_file(hwnd, state, filename_from_str(cmdline_keyfile), 0);
954 state = (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
955 if (state->collecting_entropy &&
956 state->entropy && state->entropy_got < state->entropy_required) {
957 state->entropy[state->entropy_got++] = lParam;
958 state->entropy[state->entropy_got++] = GetMessageTime();
959 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS,
960 state->entropy_got, 0);
961 if (state->entropy_got >= state->entropy_required) {
962 struct rsa_key_thread_params *params;
966 * Seed the entropy pool
968 random_add_heavynoise(state->entropy, state->entropy_size);
969 memset(state->entropy, 0, state->entropy_size);
970 sfree(state->entropy);
971 state->collecting_entropy = FALSE;
973 SetDlgItemText(hwnd, IDC_GENERATING, generating_msg);
974 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETRANGE, 0,
975 MAKELPARAM(0, PROGRESSRANGE));
976 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS, 0, 0);
978 params = snew(struct rsa_key_thread_params);
979 params->progressbar = GetDlgItem(hwnd, IDC_PROGRESS);
980 params->dialog = hwnd;
981 params->keysize = state->keysize;
982 params->is_dsa = state->is_dsa;
983 params->key = &state->key;
984 params->dsskey = &state->dsskey;
986 if (!CreateThread(NULL, 0, generate_rsa_key_thread,
987 params, 0, &threadid)) {
988 MessageBox(hwnd, "Out of thread resources",
989 "Key generation error",
990 MB_OK | MB_ICONERROR);
993 state->generation_thread_exists = TRUE;
999 switch (LOWORD(wParam)) {
1001 case IDC_KEYSSH2RSA:
1002 case IDC_KEYSSH2DSA:
1004 state = (struct MainDlgState *)
1005 GetWindowLong(hwnd, GWL_USERDATA);
1006 if (!IsDlgButtonChecked(hwnd, LOWORD(wParam)))
1007 CheckRadioButton(hwnd, IDC_KEYSSH1, IDC_KEYSSH2DSA,
1009 CheckMenuRadioItem(state->keymenu, IDC_KEYSSH1, IDC_KEYSSH2DSA,
1010 LOWORD(wParam), MF_BYCOMMAND);
1014 PostMessage(hwnd, WM_CLOSE, 0, 0);
1016 case IDC_COMMENTEDIT:
1017 if (HIWORD(wParam) == EN_CHANGE) {
1018 state = (struct MainDlgState *)
1019 GetWindowLong(hwnd, GWL_USERDATA);
1020 if (state->key_exists) {
1021 HWND editctl = GetDlgItem(hwnd, IDC_COMMENTEDIT);
1022 int len = GetWindowTextLength(editctl);
1023 if (*state->commentptr)
1024 sfree(*state->commentptr);
1025 *state->commentptr = snewn(len + 1, char);
1026 GetWindowText(editctl, *state->commentptr, len + 1);
1028 setupbigedit2(hwnd, IDC_KEYDISPLAY, IDC_PKSTATIC,
1031 setupbigedit1(hwnd, IDC_KEYDISPLAY, IDC_PKSTATIC,
1038 EnableWindow(hwnd, 0);
1039 DialogBox(hinst, MAKEINTRESOURCE(213), hwnd, AboutProc);
1040 EnableWindow(hwnd, 1);
1041 SetActiveWindow(hwnd);
1044 if (HIWORD(wParam) == BN_CLICKED ||
1045 HIWORD(wParam) == BN_DOUBLECLICKED) {
1047 WinHelp(hwnd, help_path, HELP_COMMAND,
1048 (DWORD)"JI(`',`puttygen.general')");
1049 requested_help = TRUE;
1054 if (HIWORD(wParam) != BN_CLICKED &&
1055 HIWORD(wParam) != BN_DOUBLECLICKED)
1058 (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
1059 if (!state->generation_thread_exists) {
1061 state->keysize = GetDlgItemInt(hwnd, IDC_BITS, &ok, FALSE);
1063 state->keysize = DEFAULT_KEYSIZE;
1064 /* If we ever introduce a new key type, check it here! */
1065 state->ssh2 = !IsDlgButtonChecked(hwnd, IDC_KEYSSH1);
1066 state->is_dsa = IsDlgButtonChecked(hwnd, IDC_KEYSSH2DSA);
1067 if (state->keysize < 256) {
1068 int ret = MessageBox(hwnd,
1069 "PuTTYgen will not generate a key"
1070 " smaller than 256 bits.\n"
1071 "Key length reset to 256. Continue?",
1073 MB_ICONWARNING | MB_OKCANCEL);
1076 state->keysize = 256;
1077 SetDlgItemInt(hwnd, IDC_BITS, 256, FALSE);
1079 ui_set_state(hwnd, state, 1);
1080 SetDlgItemText(hwnd, IDC_GENERATING, entropy_msg);
1081 state->key_exists = FALSE;
1082 state->collecting_entropy = TRUE;
1085 * My brief statistical tests on mouse movements
1086 * suggest that there are about 2.5 bits of
1087 * randomness in the x position, 2.5 in the y
1088 * position, and 1.7 in the message time, making
1089 * 5.7 bits of unpredictability per mouse movement.
1090 * However, other people have told me it's far less
1091 * than that, so I'm going to be stupidly cautious
1092 * and knock that down to a nice round 2. With this
1093 * method, we require two words per mouse movement,
1094 * so with 2 bits per mouse movement we expect 2
1095 * bits every 2 words.
1097 state->entropy_required = (state->keysize / 2) * 2;
1098 state->entropy_got = 0;
1099 state->entropy_size = (state->entropy_required *
1101 state->entropy = snewn(state->entropy_required, unsigned);
1103 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETRANGE, 0,
1104 MAKELPARAM(0, state->entropy_required));
1105 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS, 0, 0);
1109 case IDC_EXPORT_OPENSSH:
1110 case IDC_EXPORT_SSHCOM:
1111 if (HIWORD(wParam) != BN_CLICKED)
1114 (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
1115 if (state->key_exists) {
1116 char filename[FILENAME_MAX];
1117 char passphrase[PASSPHRASE_MAXLEN];
1118 char passphrase2[PASSPHRASE_MAXLEN];
1122 realtype = SSH_KEYTYPE_SSH2;
1124 realtype = SSH_KEYTYPE_SSH1;
1126 if (LOWORD(wParam) == IDC_EXPORT_OPENSSH)
1127 type = SSH_KEYTYPE_OPENSSH;
1128 else if (LOWORD(wParam) == IDC_EXPORT_SSHCOM)
1129 type = SSH_KEYTYPE_SSHCOM;
1133 if (type != realtype &&
1134 import_target_type(type) != realtype) {
1136 sprintf(msg, "Cannot export an SSH%d key in an SSH%d"
1137 " format", (state->ssh2 ? 2 : 1),
1138 (state->ssh2 ? 1 : 2));
1139 MessageBox(hwnd, msg,
1140 "PuTTYgen Error", MB_OK | MB_ICONERROR);
1144 GetDlgItemText(hwnd, IDC_PASSPHRASE1EDIT,
1145 passphrase, sizeof(passphrase));
1146 GetDlgItemText(hwnd, IDC_PASSPHRASE2EDIT,
1147 passphrase2, sizeof(passphrase2));
1148 if (strcmp(passphrase, passphrase2)) {
1150 "The two passphrases given do not match.",
1151 "PuTTYgen Error", MB_OK | MB_ICONERROR);
1156 ret = MessageBox(hwnd,
1157 "Are you sure you want to save this key\n"
1158 "without a passphrase to protect it?",
1160 MB_YESNO | MB_ICONWARNING);
1164 if (prompt_keyfile(hwnd, "Save private key as:",
1165 filename, 1, (type == realtype))) {
1167 FILE *fp = fopen(filename, "r");
1171 buffer = dupprintf("Overwrite existing file\n%s?",
1173 ret = MessageBox(hwnd, buffer, "PuTTYgen Warning",
1174 MB_YESNO | MB_ICONWARNING);
1181 Filename fn = filename_from_str(filename);
1182 if (type != realtype)
1183 ret = export_ssh2(&fn, type, &state->ssh2key,
1184 *passphrase ? passphrase : NULL);
1186 ret = ssh2_save_userkey(&fn, &state->ssh2key,
1187 *passphrase ? passphrase :
1190 Filename fn = filename_from_str(filename);
1191 if (type != realtype)
1192 ret = export_ssh1(&fn, type, &state->key,
1193 *passphrase ? passphrase : NULL);
1195 ret = saversakey(&fn, &state->key,
1196 *passphrase ? passphrase : NULL);
1199 MessageBox(hwnd, "Unable to save key file",
1200 "PuTTYgen Error", MB_OK | MB_ICONERROR);
1206 if (HIWORD(wParam) != BN_CLICKED)
1209 (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
1210 if (state->key_exists) {
1211 char filename[FILENAME_MAX];
1212 if (prompt_keyfile(hwnd, "Save public key as:",
1215 FILE *fp = fopen(filename, "r");
1219 buffer = dupprintf("Overwrite existing file\n%s?",
1221 ret = MessageBox(hwnd, buffer, "PuTTYgen Warning",
1222 MB_YESNO | MB_ICONWARNING);
1228 ret = save_ssh2_pubkey(filename, &state->ssh2key);
1230 ret = save_ssh1_pubkey(filename, &state->key);
1233 MessageBox(hwnd, "Unable to save key file",
1234 "PuTTYgen Error", MB_OK | MB_ICONERROR);
1241 if (HIWORD(wParam) != BN_CLICKED)
1244 (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
1245 if (!state->generation_thread_exists) {
1246 char filename[FILENAME_MAX];
1247 if (prompt_keyfile(hwnd, "Load private key:",
1248 filename, 0, LOWORD(wParam)==IDC_LOAD))
1249 load_key_file(hwnd, state, filename_from_str(filename),
1250 LOWORD(wParam) != IDC_LOAD);
1256 state = (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
1257 state->generation_thread_exists = FALSE;
1258 state->key_exists = TRUE;
1259 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETRANGE, 0,
1260 MAKELPARAM(0, PROGRESSRANGE));
1261 SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS, PROGRESSRANGE, 0);
1263 if (state->is_dsa) {
1264 state->ssh2key.data = &state->dsskey;
1265 state->ssh2key.alg = &ssh_dss;
1267 state->ssh2key.data = &state->key;
1268 state->ssh2key.alg = &ssh_rsa;
1270 state->commentptr = &state->ssh2key.comment;
1272 state->commentptr = &state->key.comment;
1275 * Invent a comment for the key. We'll do this by including
1276 * the date in it. This will be so horrifyingly ugly that
1277 * the user will immediately want to change it, which is
1280 *state->commentptr = snewn(30, char);
1287 strftime(*state->commentptr, 30, "dsa-key-%Y%m%d", tm);
1289 strftime(*state->commentptr, 30, "rsa-key-%Y%m%d", tm);
1293 * Now update the key controls with all the key data.
1298 * Blank passphrase, initially. This isn't dangerous,
1299 * because we will warn (Are You Sure?) before allowing
1300 * the user to save an unprotected private key.
1302 SetDlgItemText(hwnd, IDC_PASSPHRASE1EDIT, "");
1303 SetDlgItemText(hwnd, IDC_PASSPHRASE2EDIT, "");
1307 SetDlgItemText(hwnd, IDC_COMMENTEDIT, *state->commentptr);
1309 * Set the key fingerprint.
1311 savecomment = *state->commentptr;
1312 *state->commentptr = NULL;
1315 fp = state->ssh2key.alg->fingerprint(state->ssh2key.data);
1316 SetDlgItemText(hwnd, IDC_FINGERPRINT, fp);
1320 rsa_fingerprint(buf, sizeof(buf), &state->key);
1321 SetDlgItemText(hwnd, IDC_FINGERPRINT, buf);
1323 *state->commentptr = savecomment;
1325 * Construct a decimal representation of the key, for
1326 * pasting into .ssh/authorized_keys or
1327 * .ssh/authorized_keys2 on a Unix box.
1330 setupbigedit2(hwnd, IDC_KEYDISPLAY,
1331 IDC_PKSTATIC, &state->ssh2key);
1333 setupbigedit1(hwnd, IDC_KEYDISPLAY,
1334 IDC_PKSTATIC, &state->key);
1338 * Finally, hide the progress bar and show the key data.
1340 ui_set_state(hwnd, state, 2);
1344 int id = ((LPHELPINFO)lParam)->iCtrlId;
1347 case IDC_GENERATING:
1351 cmd = "JI(`',`puttygen.generate')"; break;
1353 case IDC_KEYDISPLAY:
1354 cmd = "JI(`',`puttygen.pastekey')"; break;
1356 case IDC_FINGERPRINT:
1357 cmd = "JI(`',`puttygen.fingerprint')"; break;
1358 case IDC_COMMENTSTATIC:
1359 case IDC_COMMENTEDIT:
1360 cmd = "JI(`',`puttygen.comment')"; break;
1361 case IDC_PASSPHRASE1STATIC:
1362 case IDC_PASSPHRASE1EDIT:
1363 case IDC_PASSPHRASE2STATIC:
1364 case IDC_PASSPHRASE2EDIT:
1365 cmd = "JI(`',`puttygen.passphrase')"; break;
1366 case IDC_LOADSTATIC:
1368 cmd = "JI(`',`puttygen.load')"; break;
1369 case IDC_SAVESTATIC:
1371 cmd = "JI(`',`puttygen.savepriv')"; break;
1373 cmd = "JI(`',`puttygen.savepub')"; break;
1374 case IDC_TYPESTATIC:
1376 case IDC_KEYSSH2RSA:
1377 case IDC_KEYSSH2DSA:
1378 cmd = "JI(`',`puttygen.keytype')"; break;
1379 case IDC_BITSSTATIC:
1381 cmd = "JI(`',`puttygen.bits')"; break;
1383 case IDC_EXPORT_OPENSSH:
1384 case IDC_EXPORT_SSHCOM:
1385 cmd = "JI(`',`puttygen.conversions')"; break;
1388 WinHelp(hwnd, help_path, HELP_COMMAND, (DWORD)cmd);
1389 requested_help = TRUE;
1396 state = (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
1398 if (requested_help) {
1399 WinHelp(hwnd, help_path, HELP_QUIT, 0);
1400 requested_help = FALSE;
1408 void cleanup_exit(int code) { exit(code); }
1410 int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show)
1415 split_into_argv(cmdline, &argc, &argv, NULL);
1419 * Assume the first argument to be a private key file, and
1420 * attempt to load it.
1422 cmdline_keyfile = argv[0];
1425 InitCommonControls();
1429 * See if we can find our Help file.
1432 char b[2048], *p, *q, *r;
1434 GetModuleFileName(NULL, b, sizeof(b) - 1);
1436 p = strrchr(b, '\\');
1437 if (p && p >= r) r = p+1;
1438 q = strrchr(b, ':');
1439 if (q && q >= r) r = q+1;
1440 strcpy(r, "putty.hlp");
1441 if ( (fp = fopen(b, "r")) != NULL) {
1442 help_path = dupstr(b);
1449 return DialogBox(hinst, MAKEINTRESOURCE(201), NULL,
1450 MainDlgProc) != IDOK;