2 * PuTTY key generation front end.
11 #define PUTTY_DO_GLOBALS
17 #define WM_DONEKEY (WM_XUSER + 1)
19 #define DEFAULT_KEYSIZE 1024
21 static int requested_help
;
23 /* ----------------------------------------------------------------------
24 * Progress report code. This is really horrible :-)
26 #define PROGRESSRANGE 65535
32 unsigned startpoint
, total
;
33 unsigned param
, current
, n
; /* if exponential */
34 unsigned mult
; /* if linear */
36 unsigned total
, divisor
, range
;
40 static void progress_update(void *param
, int action
, int phase
, int iprogress
)
42 struct progress
*p
= (struct progress
*) param
;
43 unsigned progress
= iprogress
;
46 if (action
< PROGFN_READY
&& p
->nphases
< phase
)
49 case PROGFN_INITIALISE
:
52 case PROGFN_LIN_PHASE
:
53 p
->phases
[phase
-1].exponential
= 0;
54 p
->phases
[phase
-1].mult
= p
->phases
[phase
].total
/ progress
;
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;
62 case PROGFN_PHASE_EXTENT
:
63 p
->phases
[phase
-1].total
= progress
;
69 for (i
= 0; i
< p
->nphases
; i
++) {
70 p
->phases
[i
].startpoint
= total
;
71 total
+= p
->phases
[i
].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
));
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;
86 position
= (p
->phases
[phase
-1].startpoint
+
87 p
->phases
[phase
-1].total
- p
->phases
[phase
-1].current
);
89 position
= (p
->phases
[phase
-1].startpoint
+
90 progress
* p
->phases
[phase
-1].mult
);
92 SendMessage(p
->progbar
, PBM_SETPOS
, position
/ p
->divisor
, 0);
99 #define PASSPHRASE_MAXLEN 512
101 struct PassphraseProcStruct
{
107 * Dialog-box function for the passphrase box.
109 static int CALLBACK
PassphraseProc(HWND hwnd
, UINT msg
,
110 WPARAM wParam
, LPARAM lParam
)
112 static char *passphrase
= NULL
;
113 struct PassphraseProcStruct
*p
;
117 SetForegroundWindow(hwnd
);
118 SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0,
119 SWP_NOMOVE
| SWP_NOSIZE
| SWP_SHOWWINDOW
);
124 { /* centre the window */
128 hw
= GetDesktopWindow();
129 if (GetWindowRect(hw
, &rs
) && GetWindowRect(hwnd
, &rd
))
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
);
136 p
= (struct PassphraseProcStruct
*) lParam
;
137 passphrase
= p
->passphrase
;
139 SetDlgItemText(hwnd
, 101, p
->comment
);
141 SetDlgItemText(hwnd
, 102, passphrase
);
144 switch (LOWORD(wParam
)) {
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';
171 * Prompt for a key file. Assumes the filename buffer is of size
174 static int prompt_keyfile(HWND hwnd
, char *dlgtitle
,
175 char *filename
, int save
)
178 memset(&of
, 0, sizeof(of
));
179 #ifdef OPENFILENAME_SIZE_VERSION_400
180 of
.lStructSize
= OPENFILENAME_SIZE_VERSION_400
;
182 of
.lStructSize
= sizeof(of
);
185 of
.lpstrFilter
= "All Files\0*\0\0\0";
186 of
.lpstrCustomFilter
= NULL
;
188 of
.lpstrFile
= filename
;
190 of
.nMaxFile
= FILENAME_MAX
;
191 of
.lpstrFileTitle
= NULL
;
192 of
.lpstrInitialDir
= NULL
;
193 of
.lpstrTitle
= dlgtitle
;
196 return GetSaveFileName(&of
);
198 return GetOpenFileName(&of
);
202 * This function is needed to link with the DES code. We need not
203 * have it do anything at all.
205 void logevent(char *msg
)
210 * Dialog-box function for the Licence box.
212 static int CALLBACK
LicenceProc(HWND hwnd
, UINT msg
,
213 WPARAM wParam
, LPARAM lParam
)
220 { /* centre the window */
224 hw
= GetDesktopWindow();
225 if (GetWindowRect(hw
, &rs
) && GetWindowRect(hwnd
, &rd
))
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
);
234 switch (LOWORD(wParam
)) {
248 * Dialog-box function for the About box.
250 static int CALLBACK
AboutProc(HWND hwnd
, UINT msg
,
251 WPARAM wParam
, LPARAM lParam
)
258 { /* centre the window */
262 hw
= GetDesktopWindow();
263 if (GetWindowRect(hw
, &rs
) && GetWindowRect(hwnd
, &rd
))
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
);
270 SetDlgItemText(hwnd
, 100, ver
);
273 switch (LOWORD(wParam
)) {
278 EnableWindow(hwnd
, 0);
279 DialogBox(hinst
, MAKEINTRESOURCE(214), NULL
, LicenceProc
);
280 EnableWindow(hwnd
, 1);
281 SetActiveWindow(hwnd
);
293 * Thread to generate a key.
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 */
301 struct dss_key
*dsskey
;
303 static DWORD WINAPI
generate_rsa_key_thread(void *param
)
305 struct rsa_key_thread_params
*params
=
306 (struct rsa_key_thread_params
*) param
;
307 struct progress prog
;
308 prog
.progbar
= params
->progressbar
;
310 progress_update(&prog
, PROGFN_INITIALISE
, 0, 0);
313 dsa_generate(params
->dsskey
, params
->keysize
, progress_update
, &prog
);
315 rsa_generate(params
->key
, params
->keysize
, progress_update
, &prog
);
317 PostMessage(params
->dialog
, WM_DONEKEY
, 0, 0);
323 struct MainDlgState
{
324 int collecting_entropy
;
325 int generation_thread_exists
;
327 int entropy_got
, entropy_required
, entropy_size
;
330 char **commentptr
; /* points to key.comment or ssh2key.comment */
331 struct ssh2_userkey ssh2key
;
334 struct dss_key dsskey
;
337 static void hidemany(HWND hwnd
, const int *ids
, int hideit
)
340 ShowWindow(GetDlgItem(hwnd
, *ids
++), (hideit ? SW_HIDE
: SW_SHOW
));
344 static void setupbigedit1(HWND hwnd
, int id
, int idstatic
, struct RSAKey
*key
)
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:");
363 static void setupbigedit2(HWND hwnd
, int id
, int idstatic
,
364 struct ssh2_userkey
*key
)
366 unsigned char *pub_blob
;
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
);
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
);
385 strcpy(p
, key
->comment
);
386 SetDlgItemText(hwnd
, id
, buffer
);
387 SetDlgItemText(hwnd
, idstatic
, "&Public key for pasting into "
388 "OpenSSH authorized_keys2 file:");
393 static int save_ssh1_pubkey(char *filename
, struct RSAKey
*key
)
398 dec1
= bignum_decimal(key
->exponent
);
399 dec2
= bignum_decimal(key
->modulus
);
400 fp
= fopen(filename
, "wb");
403 fprintf(fp
, "%d %s %s %s\n",
404 bignum_bitcount(key
->modulus
), dec1
, dec2
, key
->comment
);
412 * Warn about the obsolescent key file format.
414 void old_keyfile_warning(void)
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"
425 "Once the key is loaded into PuTTYgen, you can perform\n"
426 "this conversion simply by saving it again.";
428 MessageBox(NULL
, message
, mbtitle
, MB_OK
);
431 static int save_ssh2_pubkey(char *filename
, struct ssh2_userkey
*key
)
433 unsigned char *pub_blob
;
439 pub_blob
= key
->alg
->public_blob(key
->data
, &pub_len
);
441 fp
= fopen(filename
, "wb");
445 fprintf(fp
, "---- BEGIN SSH2 PUBLIC KEY ----\n");
447 fprintf(fp
, "Comment: \"");
448 for (p
= key
->comment
; *p
; p
++) {
449 if (*p
== '\\' || *p
== '\"')
457 while (i
< pub_len
) {
459 int n
= (pub_len
- i
< 3 ? pub_len
- i
: 3);
460 base64_encode_atom(pub_blob
+ i
, n
, buf
);
464 if (++column
>= 16) {
472 fprintf(fp
, "---- END SSH2 PUBLIC KEY ----\n");
479 * Dialog-box function for the main PuTTYgen dialog box.
481 static int CALLBACK
MainDlgProc(HWND hwnd
, UINT msg
,
482 WPARAM wParam
, LPARAM lParam
)
485 controlidstart
= 100,
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
,
497 IDC_GENSTATIC
, IDC_GENERATE
,
498 IDC_LOADSTATIC
, IDC_LOAD
,
499 IDC_SAVESTATIC
, IDC_SAVE
, IDC_SAVEPUB
,
501 IDC_TYPESTATIC
, IDC_KEYSSH1
, IDC_KEYSSH2RSA
, IDC_KEYSSH2DSA
,
502 IDC_BITSSTATIC
, IDC_BITS
,
505 IDC_IMPORT
, IDC_EXPORT_OPENSSH
, IDC_EXPORT_SSHCOM
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
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
;
526 SetWindowLong(hwnd
, GWL_EXSTYLE
,
527 GetWindowLong(hwnd
, GWL_EXSTYLE
) | WS_EX_CONTEXTHELP
);
530 * If we add a Help button, this is where we destroy it
531 * if the help file isn't present.
534 requested_help
= FALSE
;
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");
547 AppendMenu(menu
, MF_POPUP
| MF_ENABLED
, (UINT
) menu1
, "&File");
551 * Exporting not yet supported, but when we do it we
552 * should just put this lot back in.
554 menu1
= CreateMenu();
555 AppendMenu(menu1
, MF_ENABLED
, IDC_EXPORT_OPENSSH
,
556 "Export &OpenSSH key");
557 AppendMenu(menu1
, MF_ENABLED
, IDC_EXPORT_SSHCOM
,
558 "Export &ssh.com key");
560 AppendMenu(menu
, MF_POPUP
| MF_ENABLED
, (UINT
) menu1
,
564 menu1
= CreateMenu();
565 AppendMenu(menu1
, MF_ENABLED
, IDC_ABOUT
, "&About");
567 AppendMenu(menu1
, MF_ENABLED
, IDC_GIVEHELP
, "&Help");
569 AppendMenu(menu
, MF_POPUP
| MF_ENABLED
, (UINT
) menu1
, "&Help");
577 { /* centre the window */
581 hw
= GetDesktopWindow();
582 if (GetWindowRect(hw
, &rs
) && GetWindowRect(hwnd
, &rd
))
584 (rs
.right
+ rs
.left
+ rd
.left
- rd
.right
) / 2,
585 (rs
.bottom
+ rs
.top
+ rd
.top
- rd
.bottom
) / 2,
586 rd
.right
- rd
.left
, rd
.bottom
- rd
.top
, TRUE
);
589 state
= smalloc(sizeof(*state
));
590 state
->generation_thread_exists
= FALSE
;
591 state
->collecting_entropy
= FALSE
;
592 state
->entropy
= NULL
;
593 state
->key_exists
= FALSE
;
594 SetWindowLong(hwnd
, GWL_USERDATA
, (LONG
) state
);
596 struct ctlpos cp
, cp2
;
598 /* Accelerators used: acglops1rbd */
600 ctlposinit(&cp
, hwnd
, 4, 4, 4);
601 beginbox(&cp
, "Key", IDC_BOX_KEY
);
603 statictext(&cp2
, "No key.", 1, IDC_NOKEY
);
605 statictext(&cp2
, "", 1, IDC_GENERATING
);
606 progressbar(&cp2
, IDC_PROGRESS
);
608 "&Public key for pasting into authorized_keys file:",
609 IDC_PKSTATIC
, IDC_KEYDISPLAY
, 5);
610 SendDlgItemMessage(hwnd
, IDC_KEYDISPLAY
, EM_SETREADONLY
, 1, 0);
611 staticedit(&cp
, "Key fingerprint:", IDC_FPSTATIC
,
612 IDC_FINGERPRINT
, 75);
613 SendDlgItemMessage(hwnd
, IDC_FINGERPRINT
, EM_SETREADONLY
, 1,
615 staticedit(&cp
, "Key &comment:", IDC_COMMENTSTATIC
,
616 IDC_COMMENTEDIT
, 75);
617 staticpassedit(&cp
, "Key p&assphrase:", IDC_PASSPHRASE1STATIC
,
618 IDC_PASSPHRASE1EDIT
, 75);
619 staticpassedit(&cp
, "C&onfirm passphrase:",
620 IDC_PASSPHRASE2STATIC
, IDC_PASSPHRASE2EDIT
, 75);
622 beginbox(&cp
, "Actions", IDC_BOX_ACTIONS
);
623 staticbtn(&cp
, "Generate a public/private key pair",
624 IDC_GENSTATIC
, "&Generate", IDC_GENERATE
);
625 staticbtn(&cp
, "Load an existing private key file",
626 IDC_LOADSTATIC
, "&Load", IDC_LOAD
);
627 static2btn(&cp
, "Save the generated key", IDC_SAVESTATIC
,
628 "Save p&ublic key", IDC_SAVEPUB
,
629 "&Save private key", IDC_SAVE
);
631 beginbox(&cp
, "Parameters", IDC_BOX_PARAMS
);
632 radioline(&cp
, "Type of key to generate:", IDC_TYPESTATIC
, 3,
633 "SSH&1 (RSA)", IDC_KEYSSH1
,
634 "SSH2 &RSA", IDC_KEYSSH2RSA
,
635 "SSH2 &DSA", IDC_KEYSSH2DSA
, NULL
);
636 staticedit(&cp
, "Number of &bits in a generated key:",
637 IDC_BITSSTATIC
, IDC_BITS
, 20);
640 CheckRadioButton(hwnd
, IDC_KEYSSH1
, IDC_KEYSSH2DSA
, IDC_KEYSSH1
);
641 SetDlgItemInt(hwnd
, IDC_BITS
, DEFAULT_KEYSIZE
, FALSE
);
644 * Initially, hide the progress bar and the key display,
645 * and show the no-key display. Also disable the Save
646 * buttons, because with no key we obviously can't save
649 hidemany(hwnd
, nokey_ids
, FALSE
);
650 hidemany(hwnd
, generating_ids
, TRUE
);
651 hidemany(hwnd
, gotkey_ids
, TRUE
);
652 EnableWindow(GetDlgItem(hwnd
, IDC_SAVE
), 0);
653 EnableWindow(GetDlgItem(hwnd
, IDC_SAVEPUB
), 0);
657 state
= (struct MainDlgState
*) GetWindowLong(hwnd
, GWL_USERDATA
);
658 if (state
->collecting_entropy
&&
659 state
->entropy
&& state
->entropy_got
< state
->entropy_required
) {
660 state
->entropy
[state
->entropy_got
++] = lParam
;
661 state
->entropy
[state
->entropy_got
++] = GetMessageTime();
662 SendDlgItemMessage(hwnd
, IDC_PROGRESS
, PBM_SETPOS
,
663 state
->entropy_got
, 0);
664 if (state
->entropy_got
>= state
->entropy_required
) {
665 struct rsa_key_thread_params
*params
;
669 * Seed the entropy pool
671 random_add_heavynoise(state
->entropy
, state
->entropy_size
);
672 memset(state
->entropy
, 0, state
->entropy_size
);
673 sfree(state
->entropy
);
674 state
->collecting_entropy
= FALSE
;
676 SetDlgItemText(hwnd
, IDC_GENERATING
, generating_msg
);
677 SendDlgItemMessage(hwnd
, IDC_PROGRESS
, PBM_SETRANGE
, 0,
678 MAKELPARAM(0, PROGRESSRANGE
));
679 SendDlgItemMessage(hwnd
, IDC_PROGRESS
, PBM_SETPOS
, 0, 0);
681 params
= smalloc(sizeof(*params
));
682 params
->progressbar
= GetDlgItem(hwnd
, IDC_PROGRESS
);
683 params
->dialog
= hwnd
;
684 params
->keysize
= state
->keysize
;
685 params
->is_dsa
= state
->is_dsa
;
686 params
->key
= &state
->key
;
687 params
->dsskey
= &state
->dsskey
;
689 if (!CreateThread(NULL
, 0, generate_rsa_key_thread
,
690 params
, 0, &threadid
)) {
691 MessageBox(hwnd
, "Out of thread resources",
692 "Key generation error",
693 MB_OK
| MB_ICONERROR
);
696 state
->generation_thread_exists
= TRUE
;
702 switch (LOWORD(wParam
)) {
703 case IDC_COMMENTEDIT
:
704 if (HIWORD(wParam
) == EN_CHANGE
) {
705 state
= (struct MainDlgState
*)
706 GetWindowLong(hwnd
, GWL_USERDATA
);
707 if (state
->key_exists
) {
708 HWND editctl
= GetDlgItem(hwnd
, IDC_COMMENTEDIT
);
709 int len
= GetWindowTextLength(editctl
);
710 if (*state
->commentptr
)
711 sfree(*state
->commentptr
);
712 *state
->commentptr
= smalloc(len
+ 1);
713 GetWindowText(editctl
, *state
->commentptr
, len
+ 1);
715 setupbigedit2(hwnd
, IDC_KEYDISPLAY
, IDC_PKSTATIC
,
718 setupbigedit1(hwnd
, IDC_KEYDISPLAY
, IDC_PKSTATIC
,
725 EnableWindow(hwnd
, 0);
726 DialogBox(hinst
, MAKEINTRESOURCE(213), NULL
, AboutProc
);
727 EnableWindow(hwnd
, 1);
728 SetActiveWindow(hwnd
);
731 if (HIWORD(wParam
) == BN_CLICKED
||
732 HIWORD(wParam
) == BN_DOUBLECLICKED
) {
734 WinHelp(hwnd
, help_path
, HELP_COMMAND
,
735 (DWORD
)"JI(`',`puttygen.general')");
736 requested_help
= TRUE
;
742 (struct MainDlgState
*) GetWindowLong(hwnd
, GWL_USERDATA
);
743 if (!state
->generation_thread_exists
) {
745 state
->keysize
= GetDlgItemInt(hwnd
, IDC_BITS
, &ok
, FALSE
);
747 state
->keysize
= DEFAULT_KEYSIZE
;
748 /* If we ever introduce a new key type, check it here! */
749 state
->ssh2
= !IsDlgButtonChecked(hwnd
, IDC_KEYSSH1
);
750 state
->is_dsa
= IsDlgButtonChecked(hwnd
, IDC_KEYSSH2DSA
);
751 if (state
->keysize
< 256) {
752 int ret
= MessageBox(hwnd
,
753 "PuTTYgen will not generate a key"
754 " smaller than 256 bits.\n"
755 "Key length reset to 256. Continue?",
757 MB_ICONWARNING
| MB_OKCANCEL
);
760 state
->keysize
= 256;
761 SetDlgItemInt(hwnd
, IDC_BITS
, 256, FALSE
);
763 hidemany(hwnd
, nokey_ids
, TRUE
);
764 hidemany(hwnd
, generating_ids
, FALSE
);
765 hidemany(hwnd
, gotkey_ids
, TRUE
);
766 EnableWindow(GetDlgItem(hwnd
, IDC_GENERATE
), 0);
767 EnableWindow(GetDlgItem(hwnd
, IDC_LOAD
), 0);
768 EnableWindow(GetDlgItem(hwnd
, IDC_SAVE
), 0);
769 EnableWindow(GetDlgItem(hwnd
, IDC_SAVEPUB
), 0);
770 EnableWindow(GetDlgItem(hwnd
, IDC_KEYSSH1
), 0);
771 EnableWindow(GetDlgItem(hwnd
, IDC_KEYSSH2RSA
), 0);
772 EnableWindow(GetDlgItem(hwnd
, IDC_KEYSSH2DSA
), 0);
773 EnableWindow(GetDlgItem(hwnd
, IDC_BITS
), 0);
774 state
->key_exists
= FALSE
;
775 SetDlgItemText(hwnd
, IDC_GENERATING
, entropy_msg
);
776 state
->collecting_entropy
= TRUE
;
779 * My brief statistical tests on mouse movements
780 * suggest that there are about 2.5 bits of
781 * randomness in the x position, 2.5 in the y
782 * position, and 1.7 in the message time, making
783 * 5.7 bits of unpredictability per mouse movement.
784 * However, other people have told me it's far less
785 * than that, so I'm going to be stupidly cautious
786 * and knock that down to a nice round 2. With this
787 * method, we require two words per mouse movement,
788 * so with 2 bits per mouse movement we expect 2
789 * bits every 2 words.
791 state
->entropy_required
= (state
->keysize
/ 2) * 2;
792 state
->entropy_got
= 0;
793 state
->entropy_size
= (state
->entropy_required
*
794 sizeof(*state
->entropy
));
795 state
->entropy
= smalloc(state
->entropy_size
);
797 SendDlgItemMessage(hwnd
, IDC_PROGRESS
, PBM_SETRANGE
, 0,
798 MAKELPARAM(0, state
->entropy_required
));
799 SendDlgItemMessage(hwnd
, IDC_PROGRESS
, PBM_SETPOS
, 0, 0);
804 (struct MainDlgState
*) GetWindowLong(hwnd
, GWL_USERDATA
);
805 if (state
->key_exists
) {
806 char filename
[FILENAME_MAX
];
807 char passphrase
[PASSPHRASE_MAXLEN
];
808 char passphrase2
[PASSPHRASE_MAXLEN
];
809 GetDlgItemText(hwnd
, IDC_PASSPHRASE1EDIT
,
810 passphrase
, sizeof(passphrase
));
811 GetDlgItemText(hwnd
, IDC_PASSPHRASE2EDIT
,
812 passphrase2
, sizeof(passphrase2
));
813 if (strcmp(passphrase
, passphrase2
)) {
815 "The two passphrases given do not match.",
816 "PuTTYgen Error", MB_OK
| MB_ICONERROR
);
821 ret
= MessageBox(hwnd
,
822 "Are you sure you want to save this key\n"
823 "without a passphrase to protect it?",
825 MB_YESNO
| MB_ICONWARNING
);
829 if (prompt_keyfile(hwnd
, "Save private key as:",
832 FILE *fp
= fopen(filename
, "r");
834 char buffer
[FILENAME_MAX
+ 80];
836 sprintf(buffer
, "Overwrite existing file\n%.*s?",
837 FILENAME_MAX
, filename
);
838 ret
= MessageBox(hwnd
, buffer
, "PuTTYgen Warning",
839 MB_YESNO
| MB_ICONWARNING
);
844 ret
= ssh2_save_userkey(filename
, &state
->ssh2key
,
845 *passphrase ? passphrase
:
848 ret
= saversakey(filename
, &state
->key
,
849 *passphrase ? passphrase
: NULL
);
852 MessageBox(hwnd
, "Unable to save key file",
853 "PuTTYgen Error", MB_OK
| MB_ICONERROR
);
860 (struct MainDlgState
*) GetWindowLong(hwnd
, GWL_USERDATA
);
861 if (state
->key_exists
) {
862 char filename
[FILENAME_MAX
];
863 if (prompt_keyfile(hwnd
, "Save public key as:",
866 FILE *fp
= fopen(filename
, "r");
868 char buffer
[FILENAME_MAX
+ 80];
870 sprintf(buffer
, "Overwrite existing file\n%.*s?",
871 FILENAME_MAX
, filename
);
872 ret
= MessageBox(hwnd
, buffer
, "PuTTYgen Warning",
873 MB_YESNO
| MB_ICONWARNING
);
878 ret
= save_ssh2_pubkey(filename
, &state
->ssh2key
);
880 ret
= save_ssh1_pubkey(filename
, &state
->key
);
883 MessageBox(hwnd
, "Unable to save key file",
884 "PuTTYgen Error", MB_OK
| MB_ICONERROR
);
891 (struct MainDlgState
*) GetWindowLong(hwnd
, GWL_USERDATA
);
892 if (!state
->generation_thread_exists
) {
893 char filename
[FILENAME_MAX
];
894 if (prompt_keyfile(hwnd
, "Load private key:", filename
, 0)) {
895 char passphrase
[PASSPHRASE_MAXLEN
];
900 struct PassphraseProcStruct pps
;
901 struct RSAKey newkey1
;
902 struct ssh2_userkey
*newkey2
= NULL
;
904 type
= realtype
= key_type(filename
);
905 if (type
!= SSH_KEYTYPE_SSH1
&&
906 type
!= SSH_KEYTYPE_SSH2
&&
907 !import_possible(type
)) {
909 sprintf(msg
, "Couldn't load private key (%s)",
910 key_type_to_str(type
));
911 MessageBox(NULL
, msg
,
912 "PuTTYgen Error", MB_OK
| MB_ICONERROR
);
916 if (type
!= SSH_KEYTYPE_SSH1
&&
917 type
!= SSH_KEYTYPE_SSH2
) {
919 type
= import_target_type(type
);
923 if (realtype
== SSH_KEYTYPE_SSH1
)
924 needs_pass
= rsakey_encrypted(filename
, &comment
);
925 else if (realtype
== SSH_KEYTYPE_SSH2
)
927 ssh2_userkey_encrypted(filename
, &comment
);
929 needs_pass
= import_encrypted(filename
, realtype
,
931 pps
.passphrase
= passphrase
;
932 pps
.comment
= comment
;
936 dlgret
= DialogBoxParam(hinst
,
937 MAKEINTRESOURCE(210),
938 NULL
, PassphraseProc
,
946 if (type
== SSH_KEYTYPE_SSH1
) {
947 if (realtype
== type
)
948 ret
= loadrsakey(filename
, &newkey1
,
951 ret
= import_ssh1(filename
, realtype
,
952 &newkey1
, passphrase
);
954 if (realtype
== type
)
955 newkey2
= ssh2_load_userkey(filename
,
958 newkey2
= import_ssh2(filename
, realtype
,
960 if (newkey2
== SSH2_WRONG_PASSPHRASE
)
971 MessageBox(NULL
, "Couldn't load private key.",
972 "PuTTYgen Error", MB_OK
| MB_ICONERROR
);
973 } else if (ret
== 1) {
974 EnableWindow(GetDlgItem(hwnd
, IDC_GENERATE
), 1);
975 EnableWindow(GetDlgItem(hwnd
, IDC_LOAD
), 1);
976 EnableWindow(GetDlgItem(hwnd
, IDC_SAVE
), 1);
977 EnableWindow(GetDlgItem(hwnd
, IDC_SAVEPUB
), 1);
978 EnableWindow(GetDlgItem(hwnd
, IDC_KEYSSH1
), 1);
979 EnableWindow(GetDlgItem(hwnd
, IDC_KEYSSH2RSA
), 1);
980 EnableWindow(GetDlgItem(hwnd
, IDC_KEYSSH2DSA
), 1);
981 EnableWindow(GetDlgItem(hwnd
, IDC_BITS
), 1);
983 * Now update the key controls with all the
987 SetDlgItemText(hwnd
, IDC_PASSPHRASE1EDIT
,
989 SetDlgItemText(hwnd
, IDC_PASSPHRASE2EDIT
,
991 if (type
== SSH_KEYTYPE_SSH1
) {
996 state
->commentptr
= &state
->key
.comment
;
997 state
->key
= newkey1
;
1000 * Set the key fingerprint.
1002 savecomment
= state
->key
.comment
;
1003 state
->key
.comment
= NULL
;
1004 rsa_fingerprint(buf
, sizeof(buf
),
1006 state
->key
.comment
= savecomment
;
1008 SetDlgItemText(hwnd
, IDC_FINGERPRINT
, buf
);
1010 * Construct a decimal representation
1011 * of the key, for pasting into
1012 * .ssh/authorized_keys on a Unix box.
1014 setupbigedit1(hwnd
, IDC_KEYDISPLAY
,
1015 IDC_PKSTATIC
, &state
->key
);
1022 &state
->ssh2key
.comment
;
1023 state
->ssh2key
= *newkey2
; /* structure copy */
1026 savecomment
= state
->ssh2key
.comment
;
1027 state
->ssh2key
.comment
= NULL
;
1029 state
->ssh2key
.alg
->
1030 fingerprint(state
->ssh2key
.data
);
1031 state
->ssh2key
.comment
= savecomment
;
1033 SetDlgItemText(hwnd
, IDC_FINGERPRINT
, fp
);
1036 setupbigedit2(hwnd
, IDC_KEYDISPLAY
,
1037 IDC_PKSTATIC
, &state
->ssh2key
);
1039 SetDlgItemText(hwnd
, IDC_COMMENTEDIT
,
1040 *state
->commentptr
);
1043 * Finally, hide the progress bar and show
1046 hidemany(hwnd
, nokey_ids
, TRUE
);
1047 hidemany(hwnd
, generating_ids
, TRUE
);
1048 hidemany(hwnd
, gotkey_ids
, FALSE
);
1049 state
->key_exists
= TRUE
;
1057 state
= (struct MainDlgState
*) GetWindowLong(hwnd
, GWL_USERDATA
);
1058 state
->generation_thread_exists
= FALSE
;
1059 state
->key_exists
= TRUE
;
1060 SendDlgItemMessage(hwnd
, IDC_PROGRESS
, PBM_SETRANGE
, 0,
1061 MAKELPARAM(0, PROGRESSRANGE
));
1062 SendDlgItemMessage(hwnd
, IDC_PROGRESS
, PBM_SETPOS
, PROGRESSRANGE
, 0);
1063 EnableWindow(GetDlgItem(hwnd
, IDC_GENERATE
), 1);
1064 EnableWindow(GetDlgItem(hwnd
, IDC_LOAD
), 1);
1065 EnableWindow(GetDlgItem(hwnd
, IDC_SAVE
), 1);
1066 EnableWindow(GetDlgItem(hwnd
, IDC_SAVEPUB
), 1);
1067 EnableWindow(GetDlgItem(hwnd
, IDC_KEYSSH1
), 1);
1068 EnableWindow(GetDlgItem(hwnd
, IDC_KEYSSH2RSA
), 1);
1069 EnableWindow(GetDlgItem(hwnd
, IDC_KEYSSH2DSA
), 1);
1070 EnableWindow(GetDlgItem(hwnd
, IDC_BITS
), 1);
1072 if (state
->is_dsa
) {
1073 state
->ssh2key
.data
= &state
->dsskey
;
1074 state
->ssh2key
.alg
= &ssh_dss
;
1076 state
->ssh2key
.data
= &state
->key
;
1077 state
->ssh2key
.alg
= &ssh_rsa
;
1079 state
->commentptr
= &state
->ssh2key
.comment
;
1081 state
->commentptr
= &state
->key
.comment
;
1084 * Invent a comment for the key. We'll do this by including
1085 * the date in it. This will be so horrifyingly ugly that
1086 * the user will immediately want to change it, which is
1089 *state
->commentptr
= smalloc(30);
1096 strftime(*state
->commentptr
, 30, "dsa-key-%Y%m%d", tm
);
1098 strftime(*state
->commentptr
, 30, "rsa-key-%Y%m%d", tm
);
1102 * Now update the key controls with all the key data.
1107 * Blank passphrase, initially. This isn't dangerous,
1108 * because we will warn (Are You Sure?) before allowing
1109 * the user to save an unprotected private key.
1111 SetDlgItemText(hwnd
, IDC_PASSPHRASE1EDIT
, "");
1112 SetDlgItemText(hwnd
, IDC_PASSPHRASE2EDIT
, "");
1116 SetDlgItemText(hwnd
, IDC_COMMENTEDIT
, *state
->commentptr
);
1118 * Set the key fingerprint.
1120 savecomment
= *state
->commentptr
;
1121 *state
->commentptr
= NULL
;
1124 fp
= state
->ssh2key
.alg
->fingerprint(state
->ssh2key
.data
);
1125 SetDlgItemText(hwnd
, IDC_FINGERPRINT
, fp
);
1129 rsa_fingerprint(buf
, sizeof(buf
), &state
->key
);
1130 SetDlgItemText(hwnd
, IDC_FINGERPRINT
, buf
);
1132 *state
->commentptr
= savecomment
;
1134 * Construct a decimal representation of the key, for
1135 * pasting into .ssh/authorized_keys or
1136 * .ssh/authorized_keys2 on a Unix box.
1139 setupbigedit2(hwnd
, IDC_KEYDISPLAY
,
1140 IDC_PKSTATIC
, &state
->ssh2key
);
1142 setupbigedit1(hwnd
, IDC_KEYDISPLAY
,
1143 IDC_PKSTATIC
, &state
->key
);
1147 * Finally, hide the progress bar and show the key data.
1149 hidemany(hwnd
, nokey_ids
, TRUE
);
1150 hidemany(hwnd
, generating_ids
, TRUE
);
1151 hidemany(hwnd
, gotkey_ids
, FALSE
);
1155 int id
= ((LPHELPINFO
)lParam
)->iCtrlId
;
1158 case IDC_GENERATING
:
1162 cmd
= "JI(`',`puttygen.generate')"; break;
1164 case IDC_KEYDISPLAY
:
1165 cmd
= "JI(`',`puttygen.pastekey')"; break;
1167 case IDC_FINGERPRINT
:
1168 cmd
= "JI(`',`puttygen.fingerprint')"; break;
1169 case IDC_COMMENTSTATIC
:
1170 case IDC_COMMENTEDIT
:
1171 cmd
= "JI(`',`puttygen.comment')"; break;
1172 case IDC_PASSPHRASE1STATIC
:
1173 case IDC_PASSPHRASE1EDIT
:
1174 case IDC_PASSPHRASE2STATIC
:
1175 case IDC_PASSPHRASE2EDIT
:
1176 cmd
= "JI(`',`puttygen.passphrase')"; break;
1177 case IDC_LOADSTATIC
:
1179 cmd
= "JI(`',`puttygen.load')"; break;
1180 case IDC_SAVESTATIC
:
1182 cmd
= "JI(`',`puttygen.savepriv')"; break;
1184 cmd
= "JI(`',`puttygen.savepub')"; break;
1185 case IDC_TYPESTATIC
:
1187 case IDC_KEYSSH2RSA
:
1188 case IDC_KEYSSH2DSA
:
1189 cmd
= "JI(`',`puttygen.keytype')"; break;
1190 case IDC_BITSSTATIC
:
1192 cmd
= "JI(`',`puttygen.bits')"; break;
1195 WinHelp(hwnd
, help_path
, HELP_COMMAND
, (DWORD
)cmd
);
1196 requested_help
= TRUE
;
1203 state
= (struct MainDlgState
*) GetWindowLong(hwnd
, GWL_USERDATA
);
1205 if (requested_help
) {
1206 WinHelp(hwnd
, help_path
, HELP_QUIT
, 0);
1207 requested_help
= FALSE
;
1215 void cleanup_exit(int code
) { exit(code
); }
1217 int WINAPI
WinMain(HINSTANCE inst
, HINSTANCE prev
, LPSTR cmdline
, int show
)
1219 InitCommonControls();
1223 * See if we can find our Help file.
1226 char b
[2048], *p
, *q
, *r
;
1228 GetModuleFileName(NULL
, b
, sizeof(b
) - 1);
1230 p
= strrchr(b
, '\\');
1231 if (p
&& p
>= r
) r
= p
+1;
1232 q
= strrchr(b
, ':');
1233 if (q
&& q
>= r
) r
= q
+1;
1234 strcpy(r
, "putty.hlp");
1235 if ( (fp
= fopen(b
, "r")) != NULL
) {
1236 help_path
= dupstr(b
);
1243 return DialogBox(hinst
, MAKEINTRESOURCE(201), NULL
,
1244 MainDlgProc
) != IDOK
;