trunk/Src/wptKeygenDlg.cpp

/* wptKeygenDlg.cpp - Key Generation dialog
 *      Copyright (C) 2000-2004 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( strlen( pwd ) < 8 ) {
                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 != 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"), &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, 2048, 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 != NULL) {
                get_pubkey (fpr, &ctx->newkey);
                log_box ("debug", 0, "%s %p", fpr, ctx->newkey);
            }
            safe_free (fpr);

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

        case IDCANCEL:
            EndDialog( dlg, FALSE );
            break;
        }
        break;
    }
    return FALSE;
}
1	twoaday	2	/* wptKeygenDlg.cpp - Key Generation dialog
2			* Copyright (C) 2000-2004 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	twoaday	20	ask_for_backup (HWND dlg)
51	twoaday	2	{
52			int id;
53			char * path = NULL, * keyring = NULL;
54			const char * name;
55
56	twoaday	20	path = get_gnupg_path ();
57	twoaday	2	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	twoaday	20	static genkey_s *ctx;
132	twoaday	2	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	twoaday	20	char t[64], expire = NULL, fpr=NULL;
139	twoaday	2	int bits, use_comment, keytype = 0;
140			char * p;
141
142			switch ( msg ) {
143			case WM_INITDIALOG:
144	twoaday	20	if (lparam != NULL)
145			ctx = (genkey_s *)lparam;
146	twoaday	2	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	twoaday	12	if (bits > DFAULT_KEYSIZE) {
207	twoaday	2	int id = msg_box (dlg, _("Do you really need such a large key?"),
208			_("Key Generation"), MB_YESNO);
209			if (id == IDNO)
210	twoaday	12	bits = DFAULT_KEYSIZE;
211	twoaday	2	}
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( strlen( pwd ) < 8 ) {
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	twoaday	20	err = gpgme_op_genkey_auto (p, keygen_cb, &fpr);
301	twoaday	2	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	twoaday	20	safe_free (fpr);
311			msg_box (dlg, gpgme_strerror( err ), _("Key Generation"), MB_ERR);
312	twoaday	2	return FALSE;
313			}
314			status_box( dlg, _("Key Generation completed"), _("GnuPG Status") );
315	twoaday	20
316			keycache_update (0, fpr);
317			keycache_update (1, fpr);
318			if (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	twoaday	2	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	twoaday	20	static genkey_s *ctx;
344	twoaday	2	static int pubkey_algo = GPGME_KEYGEN_DSA_ELG;
345			gpgme_error_t err;
346			char name[128], email[128];
347	twoaday	20	char * utf8_name, * p, *fpr=NULL;
348	twoaday	2	char * pass = NULL;
349			int cancel = 0;
350
351
352			switch( msg ) {
353			case WM_INITDIALOG:
354	twoaday	20	ctx = (genkey_s *)lparam;
355	twoaday	2	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	twoaday	20	_("Key Generation Wizard"), MB_WARN);
388	twoaday	2	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	twoaday	20	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	twoaday	2	pass = request_passphrase2 (_("Key Generation"), &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, 2048, utf8_name,
410			NULL, email, NULL, pass);
411			free( utf8_name );
412			keygen_cb_dlg_create();
413	twoaday	20	err = gpgme_op_genkey_auto (p, keygen_cb, &fpr);
414	twoaday	2	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	twoaday	20	safe_free (fpr);
424	twoaday	2	return FALSE;
425			}
426			status_box( dlg, _("Key Generation completed"), _("GnuPG Status") );
427	twoaday	20
428			keycache_update (0, fpr);
429			keycache_update (1, fpr);
430			if (ctx != NULL) {
431			get_pubkey (fpr, &ctx->newkey);
432			log_box ("debug", 0, "%s %p", fpr, ctx->newkey);
433			}
434			safe_free (fpr);
435
436			ask_for_backup (dlg);
437			EndDialog (dlg, TRUE);
438	twoaday	2	break;
439
440			case IDCANCEL:
441			EndDialog( dlg, FALSE );
442			break;
443			}
444			break;
445			}
446			return FALSE;
447			}