trunk/Src/wptKeygenDlg.cpp

/* wptKeygenDlg.cpp - Key Generation dialog
 *      Copyright (C) 2000-2005 Timo Schulz
 *
 * This file is part of WinPT.
 *
 * WinPT is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * WinPT is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with WinPT; if not, write to the Free Software Foundation, 
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */

#include <windows.h>

#include "../resource.h"
#include "wptTypes.h"
#include "wptNLS.h"
#include "wptGPG.h"
#include "wptCommonCtl.h"
#include "wptContext.h" /* for passphrase_s */
#include "wptDlgs.h"
#include "wptW32API.h"
#include "wptVersion.h"
#include "wptErrors.h"
#include "wptUTF8.h"


static void 
clear_dlg_fields( HWND dlg )
{
    SetDlgItemText( dlg, IDC_KEYGEN_SUBKEYBITS, "" );
    SetDlgItemText( dlg, IDC_KEYGEN_NAME, "" );
    SetDlgItemText( dlg, IDC_KEYGEN_EMAIL, "" );
    SetDlgItemText( dlg, IDC_KEYGEN_COMMENT, "" );
    SetDlgItemText( dlg, IDC_KEYGEN_EXPDATE, "" );
    SetDlgItemText( dlg, IDC_KEYGEN_PASSPHRASE, "" );
    SetDlgItemText( dlg, IDC_KEYGEN_PWDCHECK, "" );
} /* clear_dlg_fields */


static void
ask_for_backup (HWND dlg)
{
    int id;
    char * path = NULL, * keyring = NULL;
    const char * name;
    
    path = get_gnupg_path ();
    if( !path )
        BUG( dlg );
    id = msg_box( dlg, 
                 _("It is STRONGLY recommend that you backup your keyrings because they both "
                   "contain VERY important data.\nRemember that your hard disk can crash or the "
                   "files can be deleted by accident; so it is a good\nidea to store them on "
                   "a different mass stoarge like a floppy or CDR!\n\n"
                   "Backup your keyrings now?"),
                 _("WARNING - Important hint" ), MB_YESNO );
    if( id == IDYES ) {
        name = get_filename_dlg( dlg, 1, _("Destination for Public Keyring"), NULL, "pubring.gpg" );
        if( name ) {
            keyring = make_filename( path, "pubring", "gpg" );
            if( !CopyFile( keyring, name, FALSE ) )
                log_box( _("Key Generation"), MB_ERR, 
                         _("Could not copy %s -> %s"), keyring, name );     
            free_if_alloc( keyring );
        }
        name = get_filename_dlg( dlg, 1, _("Destination for Secret Keyring"), NULL, "secring.gpg" );
        if( name ) {
            keyring = make_filename( path, "secring", "gpg" );
            if( !CopyFile( keyring, name, FALSE ) )
                log_box( _("Key Generation"), MB_ERR,
                         _("Could not copy %s -> %s"), keyring, name );
            free_if_alloc( keyring );
        }
    }
    free_if_alloc( path );
} /* ask_for_backup */


static void
fill_keytype_box( HWND dlg )
{
    HWND cb = GetDlgItem( dlg, IDC_KEYGEN_KEYTYPE );

#define addstr( cb, str ) \
    SendMessage( (cb), CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)(str) )
    addstr( cb, _("DSA and ELG (default)") );
    addstr( cb, _("DSA and RSA") );
    addstr( cb, _("DSA sign only") );
    addstr( cb, _("RSA sign only") );
    addstr( cb, _("RSA sign and encrypt") );
    addstr( cb, _("RSA and RSA (PGP)") );
    SendMessage( cb, CB_SETCURSEL, 0, 0 );
#undef addstr
} /* fill_keytype_box */


static inline int
get_keytype( HWND dlg )
{
    HWND cb = GetDlgItem( dlg, IDC_KEYGEN_KEYTYPE );
    return SendMessage( cb, CB_GETCURSEL, 0, 0 ) + 1;
} /* get_keytype */


int
keygen_check_date( SYSTEMTIME *st )
{       
    SYSTEMTIME t;
        
    GetSystemTime( &t );
    if( st->wYear > t.wYear || st->wMonth > t.wMonth )
        return 1;
    else if( st->wYear < t.wYear || st->wMonth < t.wMonth || st->wDay < t.wDay)
        return 0;       
    return 1;
} /* keygen_check_date */


BOOL CALLBACK
keygen_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static genkey_s *ctx;
    static int hide = 1;
    static int act_expdate = 0;
    SYSTEMTIME st;
    gpgme_error_t err;
    char name[128] = {0}, email[128] = {0}, comment[128] = {0};
    char pwd[128], pwd2[128];
    char t[64], *expire = NULL, *fpr=NULL;
    int bits, use_comment, keytype = 0;    
    char * p;   
    
    switch ( msg ) {
    case WM_INITDIALOG:
        if (lparam != NULL)
            ctx = (genkey_s *)lparam;
        hide = 1;
#ifndef LANG_DE
        SetWindowText( dlg, _("Key Generation") );
        SetDlgItemText( dlg, IDC_KEYGEN_INFO, 
                        _("NOTE: Key generation can be a lengthy process! Please wait until "
                          "you get the message that key generation was finished.") );
        SetDlgItemText( dlg, IDC_KEYGEN_SUBKEYINF, _("Subkey size in &bits"));
        SetDlgItemText( dlg, IDC_KEYGEN_NAMEINF, _("&Real name") );
        SetDlgItemText( dlg, IDC_KEYGEN_COMMINF, _("&Comment (optional)") );
        SetDlgItemText( dlg, IDC_KEYGEN_EMAILINF, _("Email &address") );
        SetDlgItemText( dlg, IDC_KEYGEN_EXPINF, _("Key &expiration") );
        SetDlgItemText( dlg, IDC_KEYGEN_PWDINF, _("&Passphrase") );
        SetDlgItemText( dlg, IDC_KEYGEN_REPWDINF, _("&Repeat passphrase") );
        SetDlgItemText( dlg, IDC_KEYGEN_KEYTYPEINF, _("Key &type") );
        SetDlgItemText (dlg, IDC_KEYGEN_CLEAR, _("&Never"));
        SetDlgItemText (dlg, IDC_KEYGEN_HIDEPWD, _("&Hide Typing"));
#endif
        SetDlgItemInt( dlg, IDC_KEYGEN_SUBKEYBITS, 2048, FALSE );
        CheckDlgButton (dlg, IDC_KEYGEN_HIDEPWD, BST_CHECKED);
        CheckDlgButton (dlg, IDC_KEYGEN_EXPNEVER, BST_CHECKED);
        EnableWindow (GetDlgItem (dlg, IDC_KEYGEN_EXPDATE), FALSE);
        fill_keytype_box( dlg );
        center_window( dlg );
        SetForegroundWindow( dlg );
        return TRUE;
        
    case WM_SYSCOMMAND:
        if( LOWORD( wparam ) == SC_CLOSE ) {
            SetDlgItemText( dlg, IDC_KEYGEN_PASSPHRASE, "" );
            SetDlgItemText( dlg, IDC_KEYGEN_PWDCHECK, "" );
            EndDialog( dlg, TRUE );
        }
        return FALSE;
        
    case WM_COMMAND:
        if (HIWORD (wparam) == BN_CLICKED &&
            LOWORD (wparam) == IDC_KEYGEN_EXPNEVER) {
            act_expdate ^= 1;
            EnableWindow (GetDlgItem (dlg, IDC_KEYGEN_EXPDATE), act_expdate);
        }
        if( HIWORD( wparam ) == BN_CLICKED 
            && LOWORD( wparam ) == IDC_KEYGEN_HIDEPWD ) {
            HWND hwnd_a = GetDlgItem( dlg, IDC_KEYGEN_PASSPHRASE );
            HWND hwnd_b = GetDlgItem( dlg, IDC_KEYGEN_PWDCHECK );
            hide ^= 1;
            SendMessage( hwnd_a, EM_SETPASSWORDCHAR, hide? '*' : 0, 0 );
            SetFocus( hwnd_a );
            SendMessage( hwnd_b, EM_SETPASSWORDCHAR, hide? '*' : 0, 0 );
            SetFocus( hwnd_b );

        }

        switch( LOWORD( wparam ) ) {
        case IDOK:
            bits = GetDlgItemInt (dlg, IDC_KEYGEN_SUBKEYBITS, NULL, FALSE);
            if (bits < 1024 || bits > 4096) {
                msg_box (dlg, _("Invalid value. Allowed values 1024-4096 bits."), 
                         _("Key Generation"), MB_ERR);
                return FALSE;
            }
            if (bits > DFAULT_KEYSIZE) {
                int id = msg_box (dlg, _("Do you really need such a large key?"), 
                                  _("Key Generation"), MB_YESNO);
                if (id == IDNO)
                    bits = DFAULT_KEYSIZE;
            }
            if( !GetDlgItemText( dlg, IDC_KEYGEN_NAME, name, sizeof name - 1 ) ) {
                msg_box( dlg, _("Please enter the name."), _("Key Generation"), MB_ERR );
                return FALSE;
            }
            if (strchr (name, '@')) {
                msg_box (dlg, _("Please do not enter the email address in the name field."),
                         _("Key Generation"), MB_INFO);
                return FALSE;
            }
            if( !GetDlgItemText(dlg, IDC_KEYGEN_EMAIL, email, sizeof email -1 )
                || !strchr( email, '@') ) {
                msg_box( dlg, _("Please enter a valid email address."), 
                         _("Key Generation"), MB_ERR );
                return FALSE;
            }
            use_comment = GetDlgItemText( dlg, IDC_KEYGEN_COMMENT, comment, sizeof comment -1 );
            if( use_comment > 0 && strchr( comment, '@' ) ) {
                msg_box( dlg, _("Please do NOT enter the email address in the comment field."),
                         _("Key Generation"), MB_INFO );
                return FALSE;
            }
            keytype = get_keytype( dlg );
            if (IsDlgButtonChecked (dlg, IDC_KEYGEN_EXPNEVER))
                expire = NULL;
            else {
                DateTime_GetSystemtime (GetDlgItem (dlg, IDC_KEYGEN_EXPDATE), &st);
                _snprintf (t, DIM (t)-1, "%04d-%02d-%02d", st.wYear, st.wMonth, st.wDay);
                expire = t;
            }
            
            if( !GetDlgItemText( dlg, IDC_KEYGEN_PASSPHRASE, pwd, sizeof pwd -1 ) ) {
                msg_box( dlg, _("Please enter the passphrase."), 
                         _("Key Generation"), MB_ERR );
                return FALSE;
            }
            else if (check_passwd_quality (pwd, 0)) {
                int id = msg_box( dlg, _("Your passphrase should be at least 8 characters"
                                         " long\nand should contain non-alphabetic characters."
                                         "\n\nStill proceed?"),
                                    _("Key Generation"), MB_ICONWARNING|MB_YESNO );
                if( id == IDNO ) {
                    SetDlgItemText( dlg, IDC_KEYGEN_PASSPHRASE, "" );
                    SetDlgItemText( dlg, IDC_KEYGEN_PWDCHECK, "" );
                    return FALSE;
                }
            }
            if( !GetDlgItemText( dlg, IDC_KEYGEN_PWDCHECK, pwd2, sizeof pwd2 -1 ) ) {
                msg_box( dlg, _("Please repeat the passphrase."), 
                         _("Key Generation"), MB_ERR );
                return FALSE;
            }
            if( strcmp( pwd, pwd2 ) ) {
                msg_box( dlg,  _("Passphrases are NOT identical!" ), 
                         _("Key Generation"), MB_ERR );
                memset( pwd, 0, sizeof pwd );
                memset( pwd2, 0, sizeof pwd2 );
                return FALSE;
            }
            if( is_8bit_string( pwd ) ) {
                msg_box( dlg, _("The passphrase contains 8-bit characters.\n"
                                "It is not suggested to use charset specific characters."),
                         _("Key Generation"), MB_ERR );
                memset( pwd, 0, sizeof pwd );
                memset( pwd2, 0, sizeof pwd2 );
                SetDlgItemText( dlg, IDC_KEYGEN_PASSPHRASE, "" );
                SetDlgItemText( dlg, IDC_KEYGEN_PWDCHECK, "" );
                return FALSE;
            }
                                 
            if( !use_comment && !strlen( comment ) ) {
                char *utf8_name;
                utf8_name = wincp_to_utf8 (name, strlen (name));
                if( !utf8_name )
                    BUG( dlg );
                p = gpgme_genkey_params( keytype, bits, utf8_name, NULL, email, expire, pwd );
                free( utf8_name );
            }
            else {
                char *utf8_name, *utf8_comment;
                utf8_name = wincp_to_utf8 (name, strlen (name));
                utf8_comment = wincp_to_utf8 (comment, strlen (comment));               
                if( !utf8_name || !utf8_comment )
                    BUG( dlg );
                p = gpgme_genkey_params( keytype, bits, utf8_name, utf8_comment, email, expire, pwd );
                free( utf8_name );
                free( utf8_comment );
            }
            keygen_cb_dlg_create( );
            err = gpgme_op_genkey_auto (p, keygen_cb, &fpr);
            memset( pwd, 0, sizeof pwd );
            memset( pwd2, 0, sizeof pwd2 );
            if( p ) {
                memset( p, 0, strlen( p ) ); /* burn the passphrase! */
                free( p );
            }
            keygen_cb_dlg_destroy( );
            keygen_cb( NULL, NULL, 0, 0, 0 ); /* flush */
            if( err ) {
                safe_free (fpr);
                msg_box (dlg, gpgme_strerror( err ), _("Key Generation"), MB_ERR);
                return FALSE;
            }
            status_box( dlg, _("Key Generation completed"), _("GnuPG Status") );
            
            keycache_update (0, fpr);
            keycache_update (1, fpr);
            if (ctx->first_start == 0 && ctx != NULL)
                get_pubkey (fpr, &ctx->newkey);
            safe_free (fpr);

            clear_dlg_fields (dlg);
            ask_for_backup (dlg);
            EndDialog (dlg, TRUE);
            return TRUE;
            
        case IDCANCEL:
            SetDlgItemText (dlg, IDC_KEYGEN_PASSPHRASE, "");
            SetDlgItemText (dlg, IDC_KEYGEN_PWDCHECK, "");
            EndDialog (dlg, FALSE);
            return FALSE;
        }
        break;
    }
    
    return FALSE;
} /* keygen_dlg_proc */


BOOL CALLBACK
keygen_wizard_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static genkey_s *ctx;
    static int pubkey_algo = GPGME_KEYGEN_DSA_ELG;
    gpgme_error_t err;
    char name[128], email[128];
    char * utf8_name, * p, *fpr=NULL;
    char * pass = NULL;
    int cancel = 0;
    

    switch( msg ) {
    case WM_INITDIALOG:
        ctx = (genkey_s *)lparam;
        if (!ctx || (ctx && ctx->interactive == 0))
            EnableWindow (GetDlgItem (dlg, IDC_KEYWIZARD_EXPERT), FALSE);
        SetDlgItemText (dlg, IDC_KEYWIZARD_USERSA, _("&Prefer RSA keys"));
        SetDlgItemText (dlg, IDC_KEYWIZARD_NAMEINF, _("Real name:"));
        SetDlgItemText (dlg, IDC_KEYWIZARD_EMAILINF, _("Email address:"));
        SetDlgItemText (dlg, IDC_KEYWIZARD_TITLEINF, _("Name and E-Mail Assignment"));
        SetDlgItemText (dlg, IDC_KEYWIZARD_TEXT1INF, _("Every key pair must have a name associated with it. The name and\nemail address let your correspondents that your public key they are\nusing belongs to us."));
        SetDlgItemText (dlg, IDC_KEYWIZARD_TEXT2INF, _("By accosiating an email address with your key pair, you will enable WinPT to assist your correspondents in selecting the correct public\nkey when communicating with you."));
        SetForegroundWindow (dlg);
        center_window (dlg);
        break;

    case WM_SYSCOMMAND:
        if( LOWORD( wparam ) == SC_CLOSE )
            EndDialog( dlg, FALSE );

    case WM_COMMAND:
        switch( LOWORD( wparam ) ) {
        case IDC_KEYWIZARD_EXPERT:
            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_KEYGEN, dlg,
                            keygen_dlg_proc, NULL);
            EndDialog (dlg, TRUE);
            break;

        case IDOK:
            if( !GetDlgItemText( dlg, IDC_KEYWIZARD_NAME, name, sizeof name-1 ) ) {
                msg_box( dlg, _("Please enter the name."), 
                         _("Key Generation Wizard"), MB_ERR );
                return FALSE;
            }
            if (strchr (name, '@')) {
                msg_box (dlg, _("Please do not enter the email address in the name field."),
                         _("Key Generation Wizard"), MB_WARN);
                return FALSE;
            }
            if( !GetDlgItemText( dlg, IDC_KEYWIZARD_EMAIL, email, sizeof email-1 )
                || !strchr( email, '@' ) ) { 
                msg_box( dlg, _("Please enter a valid email address."), 
                         _("Key Generation Wizard"), MB_ERR );
                return FALSE;
            }
            if (strchr (email, '<') || strchr (email, '>')) {
                msg_box (dlg, _("Please do not add '<' or '>' to the email address."),
                         _("Key Generation Wizard"), MB_WARN);
                return FALSE;
            }
            pass = request_passphrase2 (_("Key Generation"), PASSDLG_STRICT, &cancel);
            if (cancel)
                return FALSE;
            utf8_name = wincp_to_utf8 (name, strlen (name));
            if( !utf8_name )
                BUG( NULL );
            if (IsDlgButtonChecked (dlg, IDC_KEYWIZARD_USERSA))
                pubkey_algo = GPGME_KEYGEN_DSA_RSA;
            p = gpgme_genkey_params (pubkey_algo, DFAULT_KEYSIZE, utf8_name, 
                                     NULL, email, NULL, pass);
            free( utf8_name );
            keygen_cb_dlg_create();
            err = gpgme_op_genkey_auto (p, keygen_cb, &fpr);
            keygen_cb_dlg_destroy();
            keygen_cb( NULL, NULL, 0, 0, 0 );
            if( p ) {
                memset( p, 0, strlen( p ) );
                free( p );
            }
            sfree_if_alloc (pass);
            if( err ) {
                msg_box( dlg, gpgme_strerror( err ), _("Key Generation Wizard"), MB_ERR );
                safe_free (fpr);
                return FALSE;
            }
            status_box( dlg, _("Key Generation completed"), _("GnuPG Status") );
            
            keycache_update (0, fpr);
            keycache_update (1, fpr);
            if (ctx->first_start == 0 && ctx != NULL)
                get_pubkey (fpr, &ctx->newkey);
            safe_free (fpr);

            ask_for_backup (dlg);
            EndDialog (dlg, TRUE);
            break;

        case IDCANCEL:
            EndDialog( dlg, FALSE );
            break;
        }
        break;
    }
    return FALSE;
}
1	/* wptKeygenDlg.cpp - Key Generation dialog
2	* Copyright (C) 2000-2005 Timo Schulz
3	*
4	* This file is part of WinPT.
5	*
6	* WinPT is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation; either version 2 of the License, or
9	* (at your option) any later version.
10	*
11	* WinPT is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with WinPT; if not, write to the Free Software Foundation,
18	* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19	*/
20
21	#include <windows.h>
22
23	#include "../resource.h"
24	#include "wptTypes.h"
25	#include "wptNLS.h"
26	#include "wptGPG.h"
27	#include "wptCommonCtl.h"
28	#include "wptContext.h" /* for passphrase_s */
29	#include "wptDlgs.h"
30	#include "wptW32API.h"
31	#include "wptVersion.h"
32	#include "wptErrors.h"
33	#include "wptUTF8.h"
34
35
36	static void
37	clear_dlg_fields( HWND dlg )
38	{
39	SetDlgItemText( dlg, IDC_KEYGEN_SUBKEYBITS, "" );
40	SetDlgItemText( dlg, IDC_KEYGEN_NAME, "" );
41	SetDlgItemText( dlg, IDC_KEYGEN_EMAIL, "" );
42	SetDlgItemText( dlg, IDC_KEYGEN_COMMENT, "" );
43	SetDlgItemText( dlg, IDC_KEYGEN_EXPDATE, "" );
44	SetDlgItemText( dlg, IDC_KEYGEN_PASSPHRASE, "" );
45	SetDlgItemText( dlg, IDC_KEYGEN_PWDCHECK, "" );
46	} /* clear_dlg_fields */
47
48
49	static void
50	ask_for_backup (HWND dlg)
51	{
52	int id;
53	char * path = NULL, * keyring = NULL;
54	const char * name;
55
56	path = get_gnupg_path ();
57	if( !path )
58	BUG( dlg );
59	id = msg_box( dlg,
60	_("It is STRONGLY recommend that you backup your keyrings because they both "
61	"contain VERY important data.\nRemember that your hard disk can crash or the "
62	"files can be deleted by accident; so it is a good\nidea to store them on "
63	"a different mass stoarge like a floppy or CDR!\n\n"
64	"Backup your keyrings now?"),
65	_("WARNING - Important hint" ), MB_YESNO );
66	if( id == IDYES ) {
67	name = get_filename_dlg( dlg, 1, _("Destination for Public Keyring"), NULL, "pubring.gpg" );
68	if( name ) {
69	keyring = make_filename( path, "pubring", "gpg" );
70	if( !CopyFile( keyring, name, FALSE ) )
71	log_box( _("Key Generation"), MB_ERR,
72	_("Could not copy %s -> %s"), keyring, name );
73	free_if_alloc( keyring );
74	}
75	name = get_filename_dlg( dlg, 1, _("Destination for Secret Keyring"), NULL, "secring.gpg" );
76	if( name ) {
77	keyring = make_filename( path, "secring", "gpg" );
78	if( !CopyFile( keyring, name, FALSE ) )
79	log_box( _("Key Generation"), MB_ERR,
80	_("Could not copy %s -> %s"), keyring, name );
81	free_if_alloc( keyring );
82	}
83	}
84	free_if_alloc( path );
85	} /* ask_for_backup */
86
87
88	static void
89	fill_keytype_box( HWND dlg )
90	{
91	HWND cb = GetDlgItem( dlg, IDC_KEYGEN_KEYTYPE );
92
93	#define addstr( cb, str ) \
94	SendMessage( (cb), CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)(str) )
95	addstr( cb, _("DSA and ELG (default)") );
96	addstr( cb, _("DSA and RSA") );
97	addstr( cb, _("DSA sign only") );
98	addstr( cb, _("RSA sign only") );
99	addstr( cb, _("RSA sign and encrypt") );
100	addstr( cb, _("RSA and RSA (PGP)") );
101	SendMessage( cb, CB_SETCURSEL, 0, 0 );
102	#undef addstr
103	} /* fill_keytype_box */
104
105
106	static inline int
107	get_keytype( HWND dlg )
108	{
109	HWND cb = GetDlgItem( dlg, IDC_KEYGEN_KEYTYPE );
110	return SendMessage( cb, CB_GETCURSEL, 0, 0 ) + 1;
111	} /* get_keytype */
112
113
114	int
115	keygen_check_date( SYSTEMTIME *st )
116	{
117	SYSTEMTIME t;
118
119	GetSystemTime( &t );
120	if( st->wYear > t.wYear \|\| st->wMonth > t.wMonth )
121	return 1;
122	else if( st->wYear < t.wYear \|\| st->wMonth < t.wMonth \|\| st->wDay < t.wDay)
123	return 0;
124	return 1;
125	} /* keygen_check_date */
126
127
128	BOOL CALLBACK
129	keygen_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
130	{
131	static genkey_s *ctx;
132	static int hide = 1;
133	static int act_expdate = 0;
134	SYSTEMTIME st;
135	gpgme_error_t err;
136	char name[128] = {0}, email[128] = {0}, comment[128] = {0};
137	char pwd[128], pwd2[128];
138	char t[64], expire = NULL, fpr=NULL;
139	int bits, use_comment, keytype = 0;
140	char * p;
141
142	switch ( msg ) {
143	case WM_INITDIALOG:
144	if (lparam != NULL)
145	ctx = (genkey_s *)lparam;
146	hide = 1;
147	#ifndef LANG_DE
148	SetWindowText( dlg, _("Key Generation") );
149	SetDlgItemText( dlg, IDC_KEYGEN_INFO,
150	_("NOTE: Key generation can be a lengthy process! Please wait until "
151	"you get the message that key generation was finished.") );
152	SetDlgItemText( dlg, IDC_KEYGEN_SUBKEYINF, _("Subkey size in &bits"));
153	SetDlgItemText( dlg, IDC_KEYGEN_NAMEINF, _("&Real name") );
154	SetDlgItemText( dlg, IDC_KEYGEN_COMMINF, _("&Comment (optional)") );
155	SetDlgItemText( dlg, IDC_KEYGEN_EMAILINF, _("Email &address") );
156	SetDlgItemText( dlg, IDC_KEYGEN_EXPINF, _("Key &expiration") );
157	SetDlgItemText( dlg, IDC_KEYGEN_PWDINF, _("&Passphrase") );
158	SetDlgItemText( dlg, IDC_KEYGEN_REPWDINF, _("&Repeat passphrase") );
159	SetDlgItemText( dlg, IDC_KEYGEN_KEYTYPEINF, _("Key &type") );
160	SetDlgItemText (dlg, IDC_KEYGEN_CLEAR, _("&Never"));
161	SetDlgItemText (dlg, IDC_KEYGEN_HIDEPWD, _("&Hide Typing"));
162	#endif
163	SetDlgItemInt( dlg, IDC_KEYGEN_SUBKEYBITS, 2048, FALSE );
164	CheckDlgButton (dlg, IDC_KEYGEN_HIDEPWD, BST_CHECKED);
165	CheckDlgButton (dlg, IDC_KEYGEN_EXPNEVER, BST_CHECKED);
166	EnableWindow (GetDlgItem (dlg, IDC_KEYGEN_EXPDATE), FALSE);
167	fill_keytype_box( dlg );
168	center_window( dlg );
169	SetForegroundWindow( dlg );
170	return TRUE;
171
172	case WM_SYSCOMMAND:
173	if( LOWORD( wparam ) == SC_CLOSE ) {
174	SetDlgItemText( dlg, IDC_KEYGEN_PASSPHRASE, "" );
175	SetDlgItemText( dlg, IDC_KEYGEN_PWDCHECK, "" );
176	EndDialog( dlg, TRUE );
177	}
178	return FALSE;
179
180	case WM_COMMAND:
181	if (HIWORD (wparam) == BN_CLICKED &&
182	LOWORD (wparam) == IDC_KEYGEN_EXPNEVER) {
183	act_expdate ^= 1;
184	EnableWindow (GetDlgItem (dlg, IDC_KEYGEN_EXPDATE), act_expdate);
185	}
186	if( HIWORD( wparam ) == BN_CLICKED
187	&& LOWORD( wparam ) == IDC_KEYGEN_HIDEPWD ) {
188	HWND hwnd_a = GetDlgItem( dlg, IDC_KEYGEN_PASSPHRASE );
189	HWND hwnd_b = GetDlgItem( dlg, IDC_KEYGEN_PWDCHECK );
190	hide ^= 1;
191	SendMessage( hwnd_a, EM_SETPASSWORDCHAR, hide? '*' : 0, 0 );
192	SetFocus( hwnd_a );
193	SendMessage( hwnd_b, EM_SETPASSWORDCHAR, hide? '*' : 0, 0 );
194	SetFocus( hwnd_b );
195
196	}
197
198	switch( LOWORD( wparam ) ) {
199	case IDOK:
200	bits = GetDlgItemInt (dlg, IDC_KEYGEN_SUBKEYBITS, NULL, FALSE);
201	if (bits < 1024 \|\| bits > 4096) {
202	msg_box (dlg, _("Invalid value. Allowed values 1024-4096 bits."),
203	_("Key Generation"), MB_ERR);
204	return FALSE;
205	}
206	if (bits > DFAULT_KEYSIZE) {
207	int id = msg_box (dlg, _("Do you really need such a large key?"),
208	_("Key Generation"), MB_YESNO);
209	if (id == IDNO)
210	bits = DFAULT_KEYSIZE;
211	}
212	if( !GetDlgItemText( dlg, IDC_KEYGEN_NAME, name, sizeof name - 1 ) ) {
213	msg_box( dlg, _("Please enter the name."), _("Key Generation"), MB_ERR );
214	return FALSE;
215	}
216	if (strchr (name, '@')) {
217	msg_box (dlg, _("Please do not enter the email address in the name field."),
218	_("Key Generation"), MB_INFO);
219	return FALSE;
220	}
221	if( !GetDlgItemText(dlg, IDC_KEYGEN_EMAIL, email, sizeof email -1 )
222	\|\| !strchr( email, '@') ) {
223	msg_box( dlg, _("Please enter a valid email address."),
224	_("Key Generation"), MB_ERR );
225	return FALSE;
226	}
227	use_comment = GetDlgItemText( dlg, IDC_KEYGEN_COMMENT, comment, sizeof comment -1 );
228	if( use_comment > 0 && strchr( comment, '@' ) ) {
229	msg_box( dlg, _("Please do NOT enter the email address in the comment field."),
230	_("Key Generation"), MB_INFO );
231	return FALSE;
232	}
233	keytype = get_keytype( dlg );
234	if (IsDlgButtonChecked (dlg, IDC_KEYGEN_EXPNEVER))
235	expire = NULL;
236	else {
237	DateTime_GetSystemtime (GetDlgItem (dlg, IDC_KEYGEN_EXPDATE), &st);
238	_snprintf (t, DIM (t)-1, "%04d-%02d-%02d", st.wYear, st.wMonth, st.wDay);
239	expire = t;
240	}
241
242	if( !GetDlgItemText( dlg, IDC_KEYGEN_PASSPHRASE, pwd, sizeof pwd -1 ) ) {
243	msg_box( dlg, _("Please enter the passphrase."),
244	_("Key Generation"), MB_ERR );
245	return FALSE;
246	}
247	else if (check_passwd_quality (pwd, 0)) {
248	int id = msg_box( dlg, _("Your passphrase should be at least 8 characters"
249	" long\nand should contain non-alphabetic characters."
250	"\n\nStill proceed?"),
251	_("Key Generation"), MB_ICONWARNING\|MB_YESNO );
252	if( id == IDNO ) {
253	SetDlgItemText( dlg, IDC_KEYGEN_PASSPHRASE, "" );
254	SetDlgItemText( dlg, IDC_KEYGEN_PWDCHECK, "" );
255	return FALSE;
256	}
257	}
258	if( !GetDlgItemText( dlg, IDC_KEYGEN_PWDCHECK, pwd2, sizeof pwd2 -1 ) ) {
259	msg_box( dlg, _("Please repeat the passphrase."),
260	_("Key Generation"), MB_ERR );
261	return FALSE;
262	}
263	if( strcmp( pwd, pwd2 ) ) {
264	msg_box( dlg, _("Passphrases are NOT identical!" ),
265	_("Key Generation"), MB_ERR );
266	memset( pwd, 0, sizeof pwd );
267	memset( pwd2, 0, sizeof pwd2 );
268	return FALSE;
269	}
270	if( is_8bit_string( pwd ) ) {
271	msg_box( dlg, _("The passphrase contains 8-bit characters.\n"
272	"It is not suggested to use charset specific characters."),
273	_("Key Generation"), MB_ERR );
274	memset( pwd, 0, sizeof pwd );
275	memset( pwd2, 0, sizeof pwd2 );
276	SetDlgItemText( dlg, IDC_KEYGEN_PASSPHRASE, "" );
277	SetDlgItemText( dlg, IDC_KEYGEN_PWDCHECK, "" );
278	return FALSE;
279	}
280
281	if( !use_comment && !strlen( comment ) ) {
282	char *utf8_name;
283	utf8_name = wincp_to_utf8 (name, strlen (name));
284	if( !utf8_name )
285	BUG( dlg );
286	p = gpgme_genkey_params( keytype, bits, utf8_name, NULL, email, expire, pwd );
287	free( utf8_name );
288	}
289	else {
290	char utf8_name, utf8_comment;
291	utf8_name = wincp_to_utf8 (name, strlen (name));
292	utf8_comment = wincp_to_utf8 (comment, strlen (comment));
293	if( !utf8_name \|\| !utf8_comment )
294	BUG( dlg );
295	p = gpgme_genkey_params( keytype, bits, utf8_name, utf8_comment, email, expire, pwd );
296	free( utf8_name );
297	free( utf8_comment );
298	}
299	keygen_cb_dlg_create( );
300	err = gpgme_op_genkey_auto (p, keygen_cb, &fpr);
301	memset( pwd, 0, sizeof pwd );
302	memset( pwd2, 0, sizeof pwd2 );
303	if( p ) {
304	memset( p, 0, strlen( p ) ); /* burn the passphrase! */
305	free( p );
306	}
307	keygen_cb_dlg_destroy( );
308	keygen_cb( NULL, NULL, 0, 0, 0 ); /* flush */
309	if( err ) {
310	safe_free (fpr);
311	msg_box (dlg, gpgme_strerror( err ), _("Key Generation"), MB_ERR);
312	return FALSE;
313	}
314	status_box( dlg, _("Key Generation completed"), _("GnuPG Status") );
315
316	keycache_update (0, fpr);
317	keycache_update (1, fpr);
318	if (ctx->first_start == 0 && ctx != NULL)
319	get_pubkey (fpr, &ctx->newkey);
320	safe_free (fpr);
321
322	clear_dlg_fields (dlg);
323	ask_for_backup (dlg);
324	EndDialog (dlg, TRUE);
325	return TRUE;
326
327	case IDCANCEL:
328	SetDlgItemText (dlg, IDC_KEYGEN_PASSPHRASE, "");
329	SetDlgItemText (dlg, IDC_KEYGEN_PWDCHECK, "");
330	EndDialog (dlg, FALSE);
331	return FALSE;
332	}
333	break;
334	}
335
336	return FALSE;
337	} /* keygen_dlg_proc */
338
339
340	BOOL CALLBACK
341	keygen_wizard_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
342	{
343	static genkey_s *ctx;
344	static int pubkey_algo = GPGME_KEYGEN_DSA_ELG;
345	gpgme_error_t err;
346	char name[128], email[128];
347	char * utf8_name, * p, *fpr=NULL;
348	char * pass = NULL;
349	int cancel = 0;
350
351
352	switch( msg ) {
353	case WM_INITDIALOG:
354	ctx = (genkey_s *)lparam;
355	if (!ctx \|\| (ctx && ctx->interactive == 0))
356	EnableWindow (GetDlgItem (dlg, IDC_KEYWIZARD_EXPERT), FALSE);
357	SetDlgItemText (dlg, IDC_KEYWIZARD_USERSA, _("&Prefer RSA keys"));
358	SetDlgItemText (dlg, IDC_KEYWIZARD_NAMEINF, _("Real name:"));
359	SetDlgItemText (dlg, IDC_KEYWIZARD_EMAILINF, _("Email address:"));
360	SetDlgItemText (dlg, IDC_KEYWIZARD_TITLEINF, _("Name and E-Mail Assignment"));
361	SetDlgItemText (dlg, IDC_KEYWIZARD_TEXT1INF, _("Every key pair must have a name associated with it. The name and\nemail address let your correspondents that your public key they are\nusing belongs to us."));
362	SetDlgItemText (dlg, IDC_KEYWIZARD_TEXT2INF, _("By accosiating an email address with your key pair, you will enable WinPT to assist your correspondents in selecting the correct public\nkey when communicating with you."));
363	SetForegroundWindow (dlg);
364	center_window (dlg);
365	break;
366
367	case WM_SYSCOMMAND:
368	if( LOWORD( wparam ) == SC_CLOSE )
369	EndDialog( dlg, FALSE );
370
371	case WM_COMMAND:
372	switch( LOWORD( wparam ) ) {
373	case IDC_KEYWIZARD_EXPERT:
374	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_KEYGEN, dlg,
375	keygen_dlg_proc, NULL);
376	EndDialog (dlg, TRUE);
377	break;
378
379	case IDOK:
380	if( !GetDlgItemText( dlg, IDC_KEYWIZARD_NAME, name, sizeof name-1 ) ) {
381	msg_box( dlg, _("Please enter the name."),
382	_("Key Generation Wizard"), MB_ERR );
383	return FALSE;
384	}
385	if (strchr (name, '@')) {
386	msg_box (dlg, _("Please do not enter the email address in the name field."),
387	_("Key Generation Wizard"), MB_WARN);
388	return FALSE;
389	}
390	if( !GetDlgItemText( dlg, IDC_KEYWIZARD_EMAIL, email, sizeof email-1 )
391	\|\| !strchr( email, '@' ) ) {
392	msg_box( dlg, _("Please enter a valid email address."),
393	_("Key Generation Wizard"), MB_ERR );
394	return FALSE;
395	}
396	if (strchr (email, '<') \|\| strchr (email, '>')) {
397	msg_box (dlg, _("Please do not add '<' or '>' to the email address."),
398	_("Key Generation Wizard"), MB_WARN);
399	return FALSE;
400	}
401	pass = request_passphrase2 (_("Key Generation"), PASSDLG_STRICT, &cancel);
402	if (cancel)
403	return FALSE;
404	utf8_name = wincp_to_utf8 (name, strlen (name));
405	if( !utf8_name )
406	BUG( NULL );
407	if (IsDlgButtonChecked (dlg, IDC_KEYWIZARD_USERSA))
408	pubkey_algo = GPGME_KEYGEN_DSA_RSA;
409	p = gpgme_genkey_params (pubkey_algo, DFAULT_KEYSIZE, utf8_name,
410	NULL, email, NULL, pass);
411	free( utf8_name );
412	keygen_cb_dlg_create();
413	err = gpgme_op_genkey_auto (p, keygen_cb, &fpr);
414	keygen_cb_dlg_destroy();
415	keygen_cb( NULL, NULL, 0, 0, 0 );
416	if( p ) {
417	memset( p, 0, strlen( p ) );
418	free( p );
419	}
420	sfree_if_alloc (pass);
421	if( err ) {
422	msg_box( dlg, gpgme_strerror( err ), _("Key Generation Wizard"), MB_ERR );
423	safe_free (fpr);
424	return FALSE;
425	}
426	status_box( dlg, _("Key Generation completed"), _("GnuPG Status") );
427
428	keycache_update (0, fpr);
429	keycache_update (1, fpr);
430	if (ctx->first_start == 0 && ctx != NULL)
431	get_pubkey (fpr, &ctx->newkey);
432	safe_free (fpr);
433
434	ask_for_backup (dlg);
435	EndDialog (dlg, TRUE);
436	break;
437
438	case IDCANCEL:
439	EndDialog( dlg, FALSE );
440	break;
441	}
442	break;
443	}
444	return FALSE;
445	}