trunk/Src/WinPT.cpp

/* WinPT.cpp - Windows Privacy Tray (WinPT)
 *      Copyright (C) 2000-2006 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
 */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <windows.h>
#include <shlobj.h>

#include "resource.h"
#include "wptTypes.h"
#include "wptW32API.h"
#include "wptVersion.h"
#include "wptErrors.h"
#include "wptGPG.h"
#include "wptRegistry.h"
#include "wptCommonCtl.h"
#include "wptDlgs.h"
#include "wptNLS.h"
#include "wptKeyserver.h"
#include "wptCard.h"
#include "wptFileManager.h"
#include "wptContext.h"
#include "wptCardEdit.h"
#include "wptCrypto.h"

void remove_crit_file_attrs (const char *fname, int force);


HINSTANCE glob_hinst;   /* global instance for the dialogs */
HWND glob_hwnd;         /* global window handle for the dialogs */
HWND activ_hwnd;
int scard_support = 0;
int debug = 0;
int mobile = 0;
int gpg_read_only = 0;
char gpgver[3];


/* Load the key cache and rebuild the signature cache. */
static void
update_keycache (HWND hwnd)
{
    refresh_cache_s rcs = {0};
    rcs.kr_reload = 0; 
    rcs.kr_update = 1;
    rcs.tr_update = 1;
    DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
                    keycache_dlg_proc, (LPARAM)&rcs);
}


/* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */
void
gpg_set_debug_mode (int val)
{       
    if (val)
        putenv ("GPGME_DEBUG=5:gpgme.dbg");
    else
        putenv ("GPGME_DEBUG=");
}


/* Return the name of the gettext language file. */
static char*
get_gettext_lang (void)
{    
    char *fname;
    fname = get_reg_entry_mo ();
    if (!fname)
        return NULL;
    return fname;
}


/* Initialize the gettext sub system. */
static void
load_gettext (int prev_inst)
{
    char *nls = NULL;

    nls = get_gettext_lang ();
    if (nls != NULL) {
        set_gettext_file ("winpt", nls);
        free_if_alloc (nls);
    }
}


/* Return true if the GPG environment is useable. */
static bool
gpg_prefs_ok (void)
{
    char *p;

    p = get_reg_entry_gpg4win ("gpg.exe");
    if (!p || file_exist_check (p) != 0) {
        free_if_alloc (p);
        p = get_reg_entry_gpg ("gpgProgram");
        if (!p || file_exist_check (p) != 0) {
            free_if_alloc (p);
            return false;
        }
    }
    free_if_alloc (p);
    p = get_reg_entry_gpg4win (NULL);    
    if (!p || dir_exist_check (p) != 0) {
        free_if_alloc (p);
        p = get_reg_entry_gpg ("HomeDir");
        if (!p || dir_exist_check (p) != 0) {
            free_if_alloc (p);
            return false;
        }
    }
    free_if_alloc (p);
    return true;
}


/* Check gpg files if they are read-only and ask the user
   if this should be corrected. */
static void
check_readonly_attr (const char *homedir)
{
    const char *files[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg", NULL};
    char *file;
    int i;

    for (i=0; files[i] != NULL; i++) {
        file = make_filename (homedir, files[i], NULL);
        remove_crit_file_attrs (file, 0);
        free_if_alloc (file);
    }
}


/* Load the GPG environment. On the first start, some
   checks are performed to find out in what state GPG is.
   Return value: 0  everything OK.
                 >0  fatal error.
                 -1 public keyring is empty or does not exist. */
static int
load_gpg_env (void)
{
    SECURITY_ATTRIBUTES sec_attr;
    char *p;
    char *pkr;

    p = get_reg_entry_gpg4win ("gpg.exe");
    if (!p)
        return (1);
    if (file_exist_check (p)) {
        free_if_alloc (p);
        return (1);
    }
    free_if_alloc (p);

    p = get_reg_entry_gpg ("HomeDir");
    if (!p || dir_exist_check (p) != 0) {
        free_if_alloc (p);
        p = multi_gnupg_path (0);
    }
    if (p && dir_exist_check (p)) {
        memset (&sec_attr, 0, sizeof (sec_attr));
        sec_attr.nLength = sizeof (sec_attr);
        if (!CreateDirectory (p, &sec_attr)) {
            msg_box (NULL, _("Could not create GPG home directory"), 
                     _("WinPT Error"), MB_ERR);
            free_if_alloc (p);
            return (2);
        }
    }
    check_readonly_attr (p);
    pkr = make_filename (p, "pubring", "gpg");
    free_if_alloc (p);
    if (!pkr)
        return -1;
    if (get_file_size (pkr) == 0) {
        free_if_alloc (pkr);
        return -1;
    }
    return 0;
}


/* check if the default key from the gpg.conf file is available in the
   keyring. if not, bail out because encryption won't work properly then. */
static int
check_default_key (gpg_keycache_t kc)
{
    gpgme_key_t key;
    gpgme_error_t err = GPG_ERR_NO_ERROR;
    char *defkey;

    defkey = get_gnupg_default_key ();
    if (defkey)
        err = gpg_keycache_find_key (kc, defkey, 0, &key);
    else
        msg_box (NULL, _("No useable secret key found."), 
                 _("WinPT Error"), MB_ERR);
    free_if_alloc (defkey);
    return err? -1 : 0;
}


/* Return the WinPT program file name (with full pathname). */
static const char*
get_prog_part (const char * fname, int use_cwd)
{
    static char program[512];
    char currdir[256];
    char *cmd = NULL;
    int j;
        
    memset (currdir, 0, DIM (currdir));
    memset (program, 0, DIM (program));
        
    if (use_cwd) {
        GetCurrentDirectory (DIM (currdir)-1, currdir);
        _snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);
    } 
    else {
        cmd = GetCommandLine ();
        if (cmd == NULL)
            return NULL;
        strncpy (currdir, cmd, sizeof (currdir)-1);
        j = strlen (currdir);
        while (j--) {
            if (currdir[j] == '\\')
                break;
        }
        currdir[j] = 0;
        _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);
    }
    return program;
}


/* Check that the underlying crypto engine fullfills the minimal
   requirements so all commands work properly. */
static bool
check_crypto_engine (void)
{
    int ma=0, mi=0, pa=0;
    int rc;

    rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
    if (rc == -1) {
        msg_box (NULL, _("Could not read GnuPG version."), 
                 _("WinPT Error"), MB_ERR);
        return false;
    }
    else if (rc) {
        log_box (_("WinPT Error"), MB_ERR,
                 _("Sorry, you need a newer GPG version.\n"
                   "GPG version %d.%d.%d required GPG version "NEED_GPG_VERSION),
                   ma, mi, pa);
        return false;
    }
    /* We enable smartcard support for GPG: >= 2 or >= 1.4.3 */
    if (ma > 1 || pa >= 3)    
        scard_support = 1;

    gpgver[0] = ma;
    gpgver[1] = mi;
    gpgver[2] = pa;
    return true;
}


/* Try to load the keyserver config file. If @quiet is 1
   do not show any errors. */
static int
load_keyserver_conf (int quiet)
{
    char *buf;
    const char *t;
    int rc;

    /* Create $APPDATA\winpt if needed. */
    buf = make_special_filename (CSIDL_APPDATA, "winpt", NULL);
    if (buf && dir_exist_check (buf) && !CreateDirectory (buf, NULL)) {
        MessageBox (NULL, _("Failed to create WinPT directory"), 
                    _("Keyserver"), MB_ERR);
        free_if_alloc (buf);
        return -1;
    }
    free_if_alloc (buf);

    /* Check for $APPDATA\winpt\keyserver.conf */
    buf = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);

    if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))
        t = get_prog_part ("keyserver.conf", 0);
    else
        t = "keyserver.conf";
    if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {
        //log_box (_("Keyserver"), MB_INFO, 
        //       _("keyserver.conf will be copied to \"%s\"\r\n"), buf);
        if (!CopyFile (t, buf, FALSE)) {
            MessageBox (NULL, _("Failed to copy the keyserver.conf"), 
                        _("Keyserver"), MB_ERR);
            free_if_alloc (buf);
            return -1;
        }
        t = buf;
    }
    else
        t = buf;
    
    rc = kserver_load_conf (t);
    if (rc && !quiet)
        msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);
    else {
        free_if_alloc (reg_prefs.kserv_conf);
        reg_prefs.kserv_conf = m_strdup (t);
    }
    free_if_alloc (buf);
    return rc;
}


/* Check if both keyrings are empty. This indicates that
   WinPT should offer to generate a key pair. */
static bool
check_for_empty_keyrings (bool pub_only)
{
    char *p;
    int n = 0;

    p = get_gnupg_keyring (1, 0);
    if (file_exist_check (p) == 0 && get_file_size (p) == 0)
        n++;
    free_if_alloc (p);
    if (pub_only)
        return n == 1? true : false;
    p = get_gnupg_keyring (0, 0);
    if (file_exist_check (p) == 0 && get_file_size (p) == 0)
        n++;
    free_if_alloc (p);
    return n==2? true : false;
}


/* Enable the mobility mode. */
static void
enable_mobile_mode (void)
{
    memset (&reg_prefs, 0, sizeof (reg_prefs));
    reg_prefs.always_trust = 0;
    reg_prefs.auto_backup = 0;
    reg_prefs.cache_time = 0;
    reg_prefs.expert = 0;
    reg_prefs.kserv_conf = m_strdup ("keyserver.conf");
    reg_prefs.no_zip_mmedia = 1;
    reg_prefs.use_tmpfiles = 1;
    reg_prefs.word_wrap = 80;
    reg_prefs.use_viewer = 0; /* XXX */
}


/* Main entry point. */
int WINAPI
WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
{
    WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};
    HACCEL accel_tab;
    MSG msg;
    HWND hwnd = NULL;
    WORD ver[3], ptdver[4];
    int rc, ec, created = 0;
    int first_start = 0, start_gpgprefs = 0;
    int winpt_inst_found = 0;
    int start_manager = 0;
    const char *s;

    glob_hinst = hinst;
    if (cmdline && stristr (cmdline, "--stop")) {
        hwnd = FindWindow ("WinPT", "WinPT");
        if (hwnd != NULL)
            PostMessage (hwnd, WM_DESTROY, 0, 0);
        return 0;
    }

    /*
    OSVERSIONINFO osinf;
    memset (&osinf, 0, sizeof (osinf));
    if (GetVersionEx (&osinf) && 
        osinf.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&
        osinf.dwMinorVersion == 0) {
        msg_box (NULL, "WinPT propably does not work on Windows 95 without restrictions",
                 "WinPT Warning", MB_INFO);
    }
    */

    #ifdef _DEBUG
    gpg_set_debug_mode (1);
    debug = 1;
    #endif

    get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
    get_file_version ("PTD.dll", &ptdver[0], &ptdver[1], 
                                 &ptdver[2], &ptdver[3]);
    /* XXX
    if (ptdver[0] != ver[0] || ptdver[1] != ver[1]|| ptdver[2] != ver[2]) {
        log_box (_("WinPT Error"), MB_ERR, 
                 _("The PTD.dll file has a different version than WinPT.exe\n"
                   "Please update the PTD.dll to version %d.%d.%d"),
                   ver[0], ver[1], ver[2]);
        return 0;
    }
    */

    if (gpg_md_selftest ()) {
        msg_box (NULL, _("Cryptographic selftest failed."),
                 _("WinPT Error"), MB_ERR);
        return 0;
    }

    s = gpgme_check_version (NEED_GPGME_VERSION);
    if (!s || !*s) {
        msg_box (NULL, _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),
                 _("WinPT Error"), MB_ERR);
        return 0;
    }

    CreateMutex (NULL, TRUE, PGM_NAME);
    if (GetLastError () == ERROR_ALREADY_EXISTS)
        winpt_inst_found = 1;

    if (cmdline && stristr (cmdline, "--mobile")) {
        msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!", 
                 "WinPT", MB_INFO);
        mobile = 1;
    }

    set_default_kserver ();
    load_gettext (winpt_inst_found);

    if (!mobile) {
        regist_inst_gnupg (1);
        regist_inst_winpt (1, &created);
    }
    else {
        enable_mobile_mode ();
        /* XXX: ask for GPG path */
        created = 1; /* Disable registry writing */
    }

    if (!created) {
        memset (&reg_prefs, 0, sizeof (reg_prefs));
        reg_prefs.use_tmpfiles = 1; /* default */
        reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
        get_reg_winpt_prefs (&reg_prefs);
        gnupg_load_config ();
    }

    if (is_gpg4win_installed ())
        load_gpg_env (); /* XXX: check return code. */

    rc = gnupg_check_homedir ();
    if (rc) {
        log_box (_("WinPT Error"), MB_ERR, 
                 _("GPG home directory is not set correctly.\n"
                   "Please check the GPG registry settings:\n%s."),
                 winpt_strerror (rc));
        s = get_fileopen_dlg (GetActiveWindow (),
                              _("Select GPG Public Keyring"),
                              "GPG Keyrings (*.gpg)\0*.gpg\0\0",
                              NULL);
        if (s != NULL) {
            size_t n;
            char *p = strrchr (s, '\\');
            if (!p)
                BUG (0);
            n = p - s;
            if (n) {
                char *file = new char[n+1];
                if (!file)
                    BUG (NULL);
                memset (file, 0, n);
                memcpy (file, s, n);
                file[n] = '\0';         
                set_reg_entry_gpg ("HomeDir", file);
                free_if_alloc (file);
                gnupg_check_homedir (); /* change gpgProgram if needed */
            }
        }
        else {
            msg_box (NULL, _("GPG home directory could not be determited."),
                     _("WinPT Error"), MB_ERR);
            goto start;
        }
    }

    rc = check_gnupg_prog ();
    if (rc) {
        if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"
                             "Do you want to start the GPG preferences to "
                             "correct  this problem?"), _("WinPT Error"),
                             MB_INFO|MB_YESNO) == IDYES)
            start_gpgprefs = 1;
        else {
            msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
            return 0;
        }
    }

    rc = gnupg_access_files ();
    if (!start_gpgprefs && rc) {
        if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {
            ec = msg_box (NULL,
                _("Could not access and/or find the public and secret keyring.\n"
                  "If this is an accident, quit the program and fix it.\n\n"
                  "Continue if you want that WinPT offers you more choices.\n"),
                  "WinPT", MB_INFO|MB_YESNO);
            if (ec == IDYES)
                first_start = 1;
        }
        if (!first_start) {
            msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
            return 0;
        }
    }
    if (check_for_empty_keyrings (false))
        first_start = 1;

    if (!first_start) {
        rc = gpg_check_permissions (1);
        if (rc && rc == 2)
            gpg_read_only = 1;
        else if (rc)
            return 0;
    }
    
    init_gnupg_table ();

    if (fm_parse_command_line (cmdline) > 0) {
        free_gnupg_table ();
        return 0;
    }

    if (cmdline && stristr (cmdline, "--wipe-freespace")) {
        dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
                            GetDesktopWindow(), space_wipefrees_dlg_proc, 0,
                            _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
        free_gnupg_table ();
        return 0;
    }

    load_keyserver_conf (cmdline? 1 : 0);

    if (cmdline && (stristr (cmdline, "--keymanager")
                || stristr (cmdline, "--cardmanager"))) {
        /* If an instance of WinPT is running, just send the command
           to open the key manager. Otherwise start a new instance.
         */
        HWND tray = FindWindow ("WinPT", "WinPT");
        if (stristr (cmdline, "keymanager"))
            start_manager = ID_WINPT_KEY;
        else
            start_manager = ID_WINPT_CARD;
        if (tray != NULL) {
            PostMessage (tray, WM_COMMAND, start_manager, 0);
            free_gnupg_table ();
            return 0;
        }
    }

    /* If we found another WinPT instance, just quit to avoid it
       will be executed twice. */
    if (winpt_inst_found) {
        log_debug ("%s", "WinMain: WinPT is already running."); 
        free_gnupg_table ();
        return 0;
    }

    if (cmdline) {
        if (stristr (cmdline, "--enable-debug") || 
            stristr (cmdline, "--debug")) {
            gpg_set_debug_mode (1);
            winpt_debug_msg ();
            debug = 1;
        }
    }

    wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
    rc = RegisterClass (&wc);
    if (rc == FALSE) {
        msg_box (NULL, _("Could not register window class"), 
                 _("WinPT Error"), MB_ERR);
        free_gnupg_table ();
        return 0;
    }

    hwnd = CreateWindow (PGM_NAME, 
                         PGM_NAME, 
                         0, 0, 0, 0, 0, 
                         NULL, 
                         NULL, 
                         hinst, 
                         NULL);
    if (hwnd == NULL) {
        msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);
        free_gnupg_table ();
        return 0;
    }
    glob_hwnd = hwnd;
    UpdateWindow (hwnd);

    if (!first_start && !start_gpgprefs) {
        gnupg_backup_options ();        
        if (!check_crypto_engine ()) {
            DestroyWindow (hwnd);
            free_gnupg_table ();
            return 0;
        }
    }
    
    if (start_gpgprefs) {
        DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
                        gpgprefs_dlg_proc, 0);
        if (check_for_empty_keyrings (true))
            first_start = 1; /* The public keyring is empty! */
    }

    if (first_start) {
        struct genkey_s c;
        int choice;
        HWND h;
start:
        h = GetDesktopWindow ();
        if (!gpg_prefs_ok ())
            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
                            gpgprefs_dlg_proc, 0);
        choice = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
                                 first_run_dlg_proc, 0);
        switch (choice) {
        case SETUP_KEYGEN:
            c.interactive = 1;
            c.first_start = 1;
            rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
                                 h, keygen_wizard_dlg_proc, (LPARAM)&c);
            if (!rc)
                goto start;
            break;

        case SETUP_IMPORT:
            rc = gnupg_copy_keyrings ();
            if (rc) {
                msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
                goto start;
            }
            break;

        case 0: /* Cancel/Abort. */
        default:
            DestroyWindow (hwnd);
            free_gnupg_table ();
            return 0;
        }
        update_keycache (hwnd);
        if (!check_crypto_engine ()) {
            DestroyWindow (hwnd);
            free_gnupg_table ();
            return 0;
        }
    }
    else {
        gpg_keycache_t c, sec_c;
        update_keycache (hwnd);
        c = keycache_get_ctx (1);
        if (!c || !gpg_keycache_get_size (c)) {
            gnupg_display_error ();
            msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
                             "Please check your GPG config (keyrings, pathes...)"),
                             _("WinPT Error"), MB_ERR);
            ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"
                                  "Do you want to start the GPG preferences dialog?"),
                            "WinPT", MB_INFO|MB_YESNO);
            if (ec == IDYES) {
                DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
                                gpgprefs_dlg_proc, 0);
                update_keycache (hwnd);
            }
            else {
                DestroyWindow (hwnd);
                free_gnupg_table ();
                return 0;
            }
        }
        sec_c = keycache_get_ctx (0);
        if (check_default_key (sec_c)) {
            char *p = get_gnupg_default_key ();
            log_box (_("WinPT Error"), MB_ERR, 
                     _("Default key (from the GPG config file) could not be found.\n"
                       "Please check your gpg.conf or set a new default key to correct it:\n\n"
                       "%s: public key not found."), p? p : "[null]");
            free_if_alloc (p);
            DestroyWindow (hwnd);
            free_gnupg_table ();
            return 0;
        }
        if (count_insecure_elgkeys ())
            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
                            elgamal_warn_dlg_proc, 0);
    }

    if (start_manager)
        PostMessage (hwnd, WM_COMMAND, start_manager, 0);

    accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
    keyring_check_last_access (); /* init */
    while (GetMessage (&msg, hwnd, 0, 0)) {
        if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {
            TranslateMessage (&msg);
            DispatchMessage (&msg);
        }
    }
        
    return 0;
}
1	/* WinPT.cpp - Windows Privacy Tray (WinPT)
2	* Copyright (C) 2000-2006 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	#ifdef HAVE_CONFIG_H
21	#include <config.h>
22	#endif
23
24	#include <windows.h>
25	#include <shlobj.h>
26
27	#include "resource.h"
28	#include "wptTypes.h"
29	#include "wptW32API.h"
30	#include "wptVersion.h"
31	#include "wptErrors.h"
32	#include "wptGPG.h"
33	#include "wptRegistry.h"
34	#include "wptCommonCtl.h"
35	#include "wptDlgs.h"
36	#include "wptNLS.h"
37	#include "wptKeyserver.h"
38	#include "wptCard.h"
39	#include "wptFileManager.h"
40	#include "wptContext.h"
41	#include "wptCardEdit.h"
42	#include "wptCrypto.h"
43
44	void remove_crit_file_attrs (const char *fname, int force);
45
46
47	HINSTANCE glob_hinst; /* global instance for the dialogs */
48	HWND glob_hwnd; /* global window handle for the dialogs */
49	HWND activ_hwnd;
50	int scard_support = 0;
51	int debug = 0;
52	int mobile = 0;
53	int gpg_read_only = 0;
54	char gpgver[3];
55
56
57	/* Load the key cache and rebuild the signature cache. */
58	static void
59	update_keycache (HWND hwnd)
60	{
61	refresh_cache_s rcs = {0};
62	rcs.kr_reload = 0;
63	rcs.kr_update = 1;
64	rcs.tr_update = 1;
65	DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
66	keycache_dlg_proc, (LPARAM)&rcs);
67	}
68
69
70	/* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */
71	void
72	gpg_set_debug_mode (int val)
73	{
74	if (val)
75	putenv ("GPGME_DEBUG=5:gpgme.dbg");
76	else
77	putenv ("GPGME_DEBUG=");
78	}
79
80
81	/* Return the name of the gettext language file. */
82	static char*
83	get_gettext_lang (void)
84	{
85	char *fname;
86	fname = get_reg_entry_mo ();
87	if (!fname)
88	return NULL;
89	return fname;
90	}
91
92
93	/* Initialize the gettext sub system. */
94	static void
95	load_gettext (int prev_inst)
96	{
97	char *nls = NULL;
98
99	nls = get_gettext_lang ();
100	if (nls != NULL) {
101	set_gettext_file ("winpt", nls);
102	free_if_alloc (nls);
103	}
104	}
105
106
107	/* Return true if the GPG environment is useable. */
108	static bool
109	gpg_prefs_ok (void)
110	{
111	char *p;
112
113	p = get_reg_entry_gpg4win ("gpg.exe");
114	if (!p \|\| file_exist_check (p) != 0) {
115	free_if_alloc (p);
116	p = get_reg_entry_gpg ("gpgProgram");
117	if (!p \|\| file_exist_check (p) != 0) {
118	free_if_alloc (p);
119	return false;
120	}
121	}
122	free_if_alloc (p);
123	p = get_reg_entry_gpg4win (NULL);
124	if (!p \|\| dir_exist_check (p) != 0) {
125	free_if_alloc (p);
126	p = get_reg_entry_gpg ("HomeDir");
127	if (!p \|\| dir_exist_check (p) != 0) {
128	free_if_alloc (p);
129	return false;
130	}
131	}
132	free_if_alloc (p);
133	return true;
134	}
135
136
137	/* Check gpg files if they are read-only and ask the user
138	if this should be corrected. */
139	static void
140	check_readonly_attr (const char *homedir)
141	{
142	const char *files[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg", NULL};
143	char *file;
144	int i;
145
146	for (i=0; files[i] != NULL; i++) {
147	file = make_filename (homedir, files[i], NULL);
148	remove_crit_file_attrs (file, 0);
149	free_if_alloc (file);
150	}
151	}
152
153
154	/* Load the GPG environment. On the first start, some
155	checks are performed to find out in what state GPG is.
156	Return value: 0 everything OK.
157	>0 fatal error.
158	-1 public keyring is empty or does not exist. */
159	static int
160	load_gpg_env (void)
161	{
162	SECURITY_ATTRIBUTES sec_attr;
163	char *p;
164	char *pkr;
165
166	p = get_reg_entry_gpg4win ("gpg.exe");
167	if (!p)
168	return (1);
169	if (file_exist_check (p)) {
170	free_if_alloc (p);
171	return (1);
172	}
173	free_if_alloc (p);
174
175	p = get_reg_entry_gpg ("HomeDir");
176	if (!p \|\| dir_exist_check (p) != 0) {
177	free_if_alloc (p);
178	p = multi_gnupg_path (0);
179	}
180	if (p && dir_exist_check (p)) {
181	memset (&sec_attr, 0, sizeof (sec_attr));
182	sec_attr.nLength = sizeof (sec_attr);
183	if (!CreateDirectory (p, &sec_attr)) {
184	msg_box (NULL, _("Could not create GPG home directory"),
185	_("WinPT Error"), MB_ERR);
186	free_if_alloc (p);
187	return (2);
188	}
189	}
190	check_readonly_attr (p);
191	pkr = make_filename (p, "pubring", "gpg");
192	free_if_alloc (p);
193	if (!pkr)
194	return -1;
195	if (get_file_size (pkr) == 0) {
196	free_if_alloc (pkr);
197	return -1;
198	}
199	return 0;
200	}
201
202
203	/* check if the default key from the gpg.conf file is available in the
204	keyring. if not, bail out because encryption won't work properly then. */
205	static int
206	check_default_key (gpg_keycache_t kc)
207	{
208	gpgme_key_t key;
209	gpgme_error_t err = GPG_ERR_NO_ERROR;
210	char *defkey;
211
212	defkey = get_gnupg_default_key ();
213	if (defkey)
214	err = gpg_keycache_find_key (kc, defkey, 0, &key);
215	else
216	msg_box (NULL, _("No useable secret key found."),
217	_("WinPT Error"), MB_ERR);
218	free_if_alloc (defkey);
219	return err? -1 : 0;
220	}
221
222
223	/* Return the WinPT program file name (with full pathname). */
224	static const char*
225	get_prog_part (const char * fname, int use_cwd)
226	{
227	static char program[512];
228	char currdir[256];
229	char *cmd = NULL;
230	int j;
231
232	memset (currdir, 0, DIM (currdir));
233	memset (program, 0, DIM (program));
234
235	if (use_cwd) {
236	GetCurrentDirectory (DIM (currdir)-1, currdir);
237	_snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);
238	}
239	else {
240	cmd = GetCommandLine ();
241	if (cmd == NULL)
242	return NULL;
243	strncpy (currdir, cmd, sizeof (currdir)-1);
244	j = strlen (currdir);
245	while (j--) {
246	if (currdir[j] == '\\')
247	break;
248	}
249	currdir[j] = 0;
250	_snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);
251	}
252	return program;
253	}
254
255
256	/* Check that the underlying crypto engine fullfills the minimal
257	requirements so all commands work properly. */
258	static bool
259	check_crypto_engine (void)
260	{
261	int ma=0, mi=0, pa=0;
262	int rc;
263
264	rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
265	if (rc == -1) {
266	msg_box (NULL, _("Could not read GnuPG version."),
267	_("WinPT Error"), MB_ERR);
268	return false;
269	}
270	else if (rc) {
271	log_box (_("WinPT Error"), MB_ERR,
272	_("Sorry, you need a newer GPG version.\n"
273	"GPG version %d.%d.%d required GPG version "NEED_GPG_VERSION),
274	ma, mi, pa);
275	return false;
276	}
277	/* We enable smartcard support for GPG: >= 2 or >= 1.4.3 */
278	if (ma > 1 \|\| pa >= 3)
279	scard_support = 1;
280
281	gpgver[0] = ma;
282	gpgver[1] = mi;
283	gpgver[2] = pa;
284	return true;
285	}
286
287
288	/* Try to load the keyserver config file. If @quiet is 1
289	do not show any errors. */
290	static int
291	load_keyserver_conf (int quiet)
292	{
293	char *buf;
294	const char *t;
295	int rc;
296
297	/* Create $APPDATA\winpt if needed. */
298	buf = make_special_filename (CSIDL_APPDATA, "winpt", NULL);
299	if (buf && dir_exist_check (buf) && !CreateDirectory (buf, NULL)) {
300	MessageBox (NULL, _("Failed to create WinPT directory"),
301	_("Keyserver"), MB_ERR);
302	free_if_alloc (buf);
303	return -1;
304	}
305	free_if_alloc (buf);
306
307	/* Check for $APPDATA\winpt\keyserver.conf */
308	buf = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);
309
310	if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))
311	t = get_prog_part ("keyserver.conf", 0);
312	else
313	t = "keyserver.conf";
314	if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {
315	//log_box (_("Keyserver"), MB_INFO,
316	// _("keyserver.conf will be copied to \"%s\"\r\n"), buf);
317	if (!CopyFile (t, buf, FALSE)) {
318	MessageBox (NULL, _("Failed to copy the keyserver.conf"),
319	_("Keyserver"), MB_ERR);
320	free_if_alloc (buf);
321	return -1;
322	}
323	t = buf;
324	}
325	else
326	t = buf;
327
328	rc = kserver_load_conf (t);
329	if (rc && !quiet)
330	msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);
331	else {
332	free_if_alloc (reg_prefs.kserv_conf);
333	reg_prefs.kserv_conf = m_strdup (t);
334	}
335	free_if_alloc (buf);
336	return rc;
337	}
338
339
340	/* Check if both keyrings are empty. This indicates that
341	WinPT should offer to generate a key pair. */
342	static bool
343	check_for_empty_keyrings (bool pub_only)
344	{
345	char *p;
346	int n = 0;
347
348	p = get_gnupg_keyring (1, 0);
349	if (file_exist_check (p) == 0 && get_file_size (p) == 0)
350	n++;
351	free_if_alloc (p);
352	if (pub_only)
353	return n == 1? true : false;
354	p = get_gnupg_keyring (0, 0);
355	if (file_exist_check (p) == 0 && get_file_size (p) == 0)
356	n++;
357	free_if_alloc (p);
358	return n==2? true : false;
359	}
360
361
362	/* Enable the mobility mode. */
363	static void
364	enable_mobile_mode (void)
365	{
366	memset (&reg_prefs, 0, sizeof (reg_prefs));
367	reg_prefs.always_trust = 0;
368	reg_prefs.auto_backup = 0;
369	reg_prefs.cache_time = 0;
370	reg_prefs.expert = 0;
371	reg_prefs.kserv_conf = m_strdup ("keyserver.conf");
372	reg_prefs.no_zip_mmedia = 1;
373	reg_prefs.use_tmpfiles = 1;
374	reg_prefs.word_wrap = 80;
375	reg_prefs.use_viewer = 0; /* XXX */
376	}
377
378
379	/* Main entry point. */
380	int WINAPI
381	WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
382	{
383	WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};
384	HACCEL accel_tab;
385	MSG msg;
386	HWND hwnd = NULL;
387	WORD ver[3], ptdver[4];
388	int rc, ec, created = 0;
389	int first_start = 0, start_gpgprefs = 0;
390	int winpt_inst_found = 0;
391	int start_manager = 0;
392	const char *s;
393
394	glob_hinst = hinst;
395	if (cmdline && stristr (cmdline, "--stop")) {
396	hwnd = FindWindow ("WinPT", "WinPT");
397	if (hwnd != NULL)
398	PostMessage (hwnd, WM_DESTROY, 0, 0);
399	return 0;
400	}
401
402	/*
403	OSVERSIONINFO osinf;
404	memset (&osinf, 0, sizeof (osinf));
405	if (GetVersionEx (&osinf) &&
406	osinf.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&
407	osinf.dwMinorVersion == 0) {
408	msg_box (NULL, "WinPT propably does not work on Windows 95 without restrictions",
409	"WinPT Warning", MB_INFO);
410	}
411	*/
412
413	#ifdef _DEBUG
414	gpg_set_debug_mode (1);
415	debug = 1;
416	#endif
417
418	get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
419	get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],
420	&ptdver[2], &ptdver[3]);
421	/* XXX
422	if (ptdver[0] != ver[0] \|\| ptdver[1] != ver[1]\|\| ptdver[2] != ver[2]) {
423	log_box (_("WinPT Error"), MB_ERR,
424	_("The PTD.dll file has a different version than WinPT.exe\n"
425	"Please update the PTD.dll to version %d.%d.%d"),
426	ver[0], ver[1], ver[2]);
427	return 0;
428	}
429	*/
430
431	if (gpg_md_selftest ()) {
432	msg_box (NULL, _("Cryptographic selftest failed."),
433	_("WinPT Error"), MB_ERR);
434	return 0;
435	}
436
437	s = gpgme_check_version (NEED_GPGME_VERSION);
438	if (!s \|\| !*s) {
439	msg_box (NULL, _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),
440	_("WinPT Error"), MB_ERR);
441	return 0;
442	}
443
444	CreateMutex (NULL, TRUE, PGM_NAME);
445	if (GetLastError () == ERROR_ALREADY_EXISTS)
446	winpt_inst_found = 1;
447
448	if (cmdline && stristr (cmdline, "--mobile")) {
449	msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",
450	"WinPT", MB_INFO);
451	mobile = 1;
452	}
453
454	set_default_kserver ();
455	load_gettext (winpt_inst_found);
456
457	if (!mobile) {
458	regist_inst_gnupg (1);
459	regist_inst_winpt (1, &created);
460	}
461	else {
462	enable_mobile_mode ();
463	/* XXX: ask for GPG path */
464	created = 1; /* Disable registry writing */
465	}
466
467	if (!created) {
468	memset (&reg_prefs, 0, sizeof (reg_prefs));
469	reg_prefs.use_tmpfiles = 1; /* default */
470	reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
471	get_reg_winpt_prefs (&reg_prefs);
472	gnupg_load_config ();
473	}
474
475	if (is_gpg4win_installed ())
476	load_gpg_env (); /* XXX: check return code. */
477
478	rc = gnupg_check_homedir ();
479	if (rc) {
480	log_box (_("WinPT Error"), MB_ERR,
481	_("GPG home directory is not set correctly.\n"
482	"Please check the GPG registry settings:\n%s."),
483	winpt_strerror (rc));
484	s = get_fileopen_dlg (GetActiveWindow (),
485	_("Select GPG Public Keyring"),
486	"GPG Keyrings (.gpg)\0.gpg\0\0",
487	NULL);
488	if (s != NULL) {
489	size_t n;
490	char *p = strrchr (s, '\\');
491	if (!p)
492	BUG (0);
493	n = p - s;
494	if (n) {
495	char *file = new char[n+1];
496	if (!file)
497	BUG (NULL);
498	memset (file, 0, n);
499	memcpy (file, s, n);
500	file[n] = '\0';
501	set_reg_entry_gpg ("HomeDir", file);
502	free_if_alloc (file);
503	gnupg_check_homedir (); /* change gpgProgram if needed */
504	}
505	}
506	else {
507	msg_box (NULL, _("GPG home directory could not be determited."),
508	_("WinPT Error"), MB_ERR);
509	goto start;
510	}
511	}
512
513	rc = check_gnupg_prog ();
514	if (rc) {
515	if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"
516	"Do you want to start the GPG preferences to "
517	"correct this problem?"), _("WinPT Error"),
518	MB_INFO\|MB_YESNO) == IDYES)
519	start_gpgprefs = 1;
520	else {
521	msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
522	return 0;
523	}
524	}
525
526	rc = gnupg_access_files ();
527	if (!start_gpgprefs && rc) {
528	if (rc == WPTERR_GPG_KEYRINGS \|\| rc == WPTERR_GPG_OPT_KEYRINGS) {
529	ec = msg_box (NULL,
530	_("Could not access and/or find the public and secret keyring.\n"
531	"If this is an accident, quit the program and fix it.\n\n"
532	"Continue if you want that WinPT offers you more choices.\n"),
533	"WinPT", MB_INFO\|MB_YESNO);
534	if (ec == IDYES)
535	first_start = 1;
536	}
537	if (!first_start) {
538	msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
539	return 0;
540	}
541	}
542	if (check_for_empty_keyrings (false))
543	first_start = 1;
544
545	if (!first_start) {
546	rc = gpg_check_permissions (1);
547	if (rc && rc == 2)
548	gpg_read_only = 1;
549	else if (rc)
550	return 0;
551	}
552
553	init_gnupg_table ();
554
555	if (fm_parse_command_line (cmdline) > 0) {
556	free_gnupg_table ();
557	return 0;
558	}
559
560	if (cmdline && stristr (cmdline, "--wipe-freespace")) {
561	dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
562	GetDesktopWindow(), space_wipefrees_dlg_proc, 0,
563	_("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
564	free_gnupg_table ();
565	return 0;
566	}
567
568	load_keyserver_conf (cmdline? 1 : 0);
569
570	if (cmdline && (stristr (cmdline, "--keymanager")
571	\|\| stristr (cmdline, "--cardmanager"))) {
572	/* If an instance of WinPT is running, just send the command
573	to open the key manager. Otherwise start a new instance.
574	*/
575	HWND tray = FindWindow ("WinPT", "WinPT");
576	if (stristr (cmdline, "keymanager"))
577	start_manager = ID_WINPT_KEY;
578	else
579	start_manager = ID_WINPT_CARD;
580	if (tray != NULL) {
581	PostMessage (tray, WM_COMMAND, start_manager, 0);
582	free_gnupg_table ();
583	return 0;
584	}
585	}
586
587	/* If we found another WinPT instance, just quit to avoid it
588	will be executed twice. */
589	if (winpt_inst_found) {
590	log_debug ("%s", "WinMain: WinPT is already running.");
591	free_gnupg_table ();
592	return 0;
593	}
594
595	if (cmdline) {
596	if (stristr (cmdline, "--enable-debug") \|\|
597	stristr (cmdline, "--debug")) {
598	gpg_set_debug_mode (1);
599	winpt_debug_msg ();
600	debug = 1;
601	}
602	}
603
604	wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
605	rc = RegisterClass (&wc);
606	if (rc == FALSE) {
607	msg_box (NULL, _("Could not register window class"),
608	_("WinPT Error"), MB_ERR);
609	free_gnupg_table ();
610	return 0;
611	}
612
613	hwnd = CreateWindow (PGM_NAME,
614	PGM_NAME,
615	0, 0, 0, 0, 0,
616	NULL,
617	NULL,
618	hinst,
619	NULL);
620	if (hwnd == NULL) {
621	msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);
622	free_gnupg_table ();
623	return 0;
624	}
625	glob_hwnd = hwnd;
626	UpdateWindow (hwnd);
627
628	if (!first_start && !start_gpgprefs) {
629	gnupg_backup_options ();
630	if (!check_crypto_engine ()) {
631	DestroyWindow (hwnd);
632	free_gnupg_table ();
633	return 0;
634	}
635	}
636
637	if (start_gpgprefs) {
638	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
639	gpgprefs_dlg_proc, 0);
640	if (check_for_empty_keyrings (true))
641	first_start = 1; /* The public keyring is empty! */
642	}
643
644	if (first_start) {
645	struct genkey_s c;
646	int choice;
647	HWND h;
648	start:
649	h = GetDesktopWindow ();
650	if (!gpg_prefs_ok ())
651	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
652	gpgprefs_dlg_proc, 0);
653	choice = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
654	first_run_dlg_proc, 0);
655	switch (choice) {
656	case SETUP_KEYGEN:
657	c.interactive = 1;
658	c.first_start = 1;
659	rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
660	h, keygen_wizard_dlg_proc, (LPARAM)&c);
661	if (!rc)
662	goto start;
663	break;
664
665	case SETUP_IMPORT:
666	rc = gnupg_copy_keyrings ();
667	if (rc) {
668	msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
669	goto start;
670	}
671	break;
672
673	case 0: /* Cancel/Abort. */
674	default:
675	DestroyWindow (hwnd);
676	free_gnupg_table ();
677	return 0;
678	}
679	update_keycache (hwnd);
680	if (!check_crypto_engine ()) {
681	DestroyWindow (hwnd);
682	free_gnupg_table ();
683	return 0;
684	}
685	}
686	else {
687	gpg_keycache_t c, sec_c;
688	update_keycache (hwnd);
689	c = keycache_get_ctx (1);
690	if (!c \|\| !gpg_keycache_get_size (c)) {
691	gnupg_display_error ();
692	msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
693	"Please check your GPG config (keyrings, pathes...)"),
694	_("WinPT Error"), MB_ERR);
695	ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"
696	"Do you want to start the GPG preferences dialog?"),
697	"WinPT", MB_INFO\|MB_YESNO);
698	if (ec == IDYES) {
699	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
700	gpgprefs_dlg_proc, 0);
701	update_keycache (hwnd);
702	}
703	else {
704	DestroyWindow (hwnd);
705	free_gnupg_table ();
706	return 0;
707	}
708	}
709	sec_c = keycache_get_ctx (0);
710	if (check_default_key (sec_c)) {
711	char *p = get_gnupg_default_key ();
712	log_box (_("WinPT Error"), MB_ERR,
713	_("Default key (from the GPG config file) could not be found.\n"
714	"Please check your gpg.conf or set a new default key to correct it:\n\n"
715	"%s: public key not found."), p? p : "[null]");
716	free_if_alloc (p);
717	DestroyWindow (hwnd);
718	free_gnupg_table ();
719	return 0;
720	}
721	if (count_insecure_elgkeys ())
722	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
723	elgamal_warn_dlg_proc, 0);
724	}
725
726	if (start_manager)
727	PostMessage (hwnd, WM_COMMAND, start_manager, 0);
728
729	accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
730	keyring_check_last_access (); /* init */
731	while (GetMessage (&msg, hwnd, 0, 0)) {
732	if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {
733	TranslateMessage (&msg);
734	DispatchMessage (&msg);
735	}
736	}
737
738	return 0;
739	}