trunk/Src/WinPT.cpp

/* WinPT.cpp - Windows Privacy Tray (WinPT)
 *      Copyright (C) 2000-2009 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.
 */
#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"
#include "wptUTF8.h"

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

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


/* Retrieve the product verion of the given file @fname.
   Format: MAJOR.MINOR.PATCH1.PATCH2
   Return value: 0 on success. */
int
get_file_version (const char *fname, WORD *major, WORD *minor, WORD *patch1, WORD *patch2)
{
    VS_FIXEDFILEINFO *inf;
    char file[MAX_PATH+1] = {0};
    LPVOID buf, data;
    DWORD size;
    UINT qlen;
    int err = 0;

    strncpy (file, fname, MAX_PATH);
    size = GetFileVersionInfoSize (file, NULL);
    if (!size)
        return -1;
    
    buf = (LPVOID)new char[size];
    if (!buf)
        BUG (NULL);
    if (!GetFileVersionInfo (file, 0, size, buf)) {
        err = -1;
        goto fail;
    }

    qlen = 0;
    VerQueryValue (buf, (char*)"\\", &data, &qlen);
    if (!qlen) {
        err = -1;
        goto fail;
    }
    
    inf = (VS_FIXEDFILEINFO*)data;
    *major = HIWORD (inf->dwProductVersionMS);
    *minor = LOWORD (inf->dwProductVersionMS);
    *patch1 = HIWORD (inf->dwProductVersionLS); 
    *patch2 = LOWORD (inf->dwProductVersionLS);

fail:
    delete [](char*)buf;
    return err;
}


/* Load the key cache and rebuild the signature cache. */
int
update_keycache (HWND hwnd)
{
    int err;
    refresh_cache_s rcs;

    /* no need to rebuild the sig cache each time. */
    memset (&rcs, 0, sizeof (rcs));
    rcs.kring_update = 1;
    err = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
                    keycache_dlg_proc, (LPARAM)&rcs);
    if (err) {
        char *cfgf = get_gnupg_config ();
        if (cfgf && check_gnupg_options (cfgf, 0) == WPTERR_FILE_EXIST)
            msg_box (GetDesktopWindow (), 
                     _("The gpg.conf contains at least one argument which points to a non-existing file."), "WinPT", MB_ERR);
        free_if_alloc (cfgf);
        return -1;
    }
    return 0;
}


/* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */
void
gpg_set_debug_mode (int val)
{
    static char buf[MAX_PATH+1];
    char tmp[128];
    
    /* XXX: no gpgme.dbg is created. */
    if (val > 0) {
        GetTempPath (DIM (tmp)-1, tmp);
        _snprintf (buf, DIM (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);
        putenv (buf);
    }
    else
        putenv ("GPGME_DEBUG=");
}


/* Return true if the GPG environment is useable. */
static bool
gpg_prefs_ok (void)
{
    char *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);
            log_debug ("gpg_prefs_ok: could not locate gpg.exe");
            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);
            log_debug ("gpg_prefs_ok: could not determine home directory");
            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};

    for (int i=0; files[i] != NULL; i++) {
        char *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;
    int err = 0;

    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 (GetDesktopWindow (), 
                     _("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 (get_file_size (pkr) == 0)
        err = -1;
    free_if_alloc (pkr);
    return err;
}


/* 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 (void)
{
    gpgme_key_t key;
    gpgme_error_t err = gpg_error (GPG_ERR_NO_ERROR);
    gpg_keycache_t kc;
    char *defkey;

    kc = keycache_get_ctx (0);
    defkey = get_gnupg_default_key ();
    if (defkey != NULL) {
        err = gpg_keycache_find_key (kc, defkey, 0, &key);
        if (err) {
            free_if_alloc (defkey);
            return -1;
        }
    }
    else {
        /* Actually this is just a warning but we still continue. */
        msg_box (GetDesktopWindow (), _("No useable secret key found."), 
                 _("WinPT Warning"), MB_WARN);
        return 0;
    }

    /* Because the secret key listing has no information
       about the validity/status, we need to check the public key. */
    kc = keycache_get_ctx (1);
    if (!gpg_keycache_find_key (kc, defkey, 0, &key) &&
        (key->revoked || key->expired)) {
        msg_box (GetDesktopWindow (), _("Default secret key is unuseable"), 
                 _("WinPT Warning"), MB_ERR);
        free_if_alloc (defkey);
        return -1;
    }
    free_if_alloc (defkey);
    return 0;
}


/* 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 (GetDesktopWindow (), _("Could not read GnuPG version."), 
                 _("WinPT Error"), MB_ERR);
        return false;
    }
    else if (rc) {
        log_box (_("WinPT Error"), MB_ERR,
                 _("A newer GPG version is needed.\n"
                   "Current GPG version %d.%d.%d, required "NEED_GPG_VERSION),
                   ma, mi, pa);
        return false;
    }
    
    // TODO: smart card support needs to be revamped
    // and adjusted according to newer OpenPGP cards.
    /*
    if ((ma > 1 || pa >= 4) && pcsc_available ())
        scard_support = 1;
    */
    scard_support = 0;
    
    gpgver[0] = ma;
    gpgver[1] = mi;
    gpgver[2] = pa;
    return true;
}


/* 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;

    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;
}


/* Display info message that WinPT is now in debug mode. */
void
winpt_debug_msg (void)
{       
    char output[512];
    char temp[MAX_PATH+1];
        
    GetTempPath (DIM (temp) -1, temp);
    _snprintf (output, DIM (output)-1,
        "The GPGME output file is %sgpgme.dbg\n"
        "The WinPT output file is %swinpt.log\n", temp, temp);
    MessageBox (NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO);
}


/* Search for insecure ElGamal keys and return the
   number of founded keys. */
static int
count_insecure_elgkeys (void)
{
    gpg_keycache_t pc;
    gpgme_key_t key;
    int n;

    n=0;
    pc = keycache_get_ctx (1);
    while (!gpg_keycache_next_key (pc, 0, &key)) {
        if (key->subkeys->pubkey_algo == GPGME_PK_ELG)
            n++;
    }
    gpg_keycache_rewind (pc);
    return n;
}


/* Return 1 if the current OS version is at least Windows XP */
static int 
check_os_version (void)
{
    OSVERSIONINFOA osver;    
    memset (&osver, 0, sizeof (osver));
    osver.dwOSVersionInfoSize = sizeof (osver);
    
    if (!GetVersionEx (&osver)) {
        MessageBox (NULL, _("Could not read the OS version."), _("WinPT Error"), MB_ERR);
        return 0;
    }

    if (osver.dwMajorVersion < 5 ||
        (osver.dwMajorVersion == 5 && osver.dwMinorVersion == 0)) {
        MessageBox (NULL, _("WinPT requires Windows XP or higher."), _("WinPT Error"), MB_ERR);
        return 0;
    }
    
    return 1;
}
    
/* 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];
    
    const char *s;
    int rc, ec, created = 0;
    int first_start = 0, start_gpgprefs = 0;
    int winpt_inst_found = 0;
    int start_manager = 0;    

    if (!check_os_version ())
        return 0;
    
    glob_hinst = hinst;
    
    /* Allow to shutdown the process, for instance by an installer */
    if (cmdline && stristr (cmdline, "--stop")) {
        hwnd = FindWindow ("WinPT", "WinPT");
        if (hwnd != NULL)
            PostMessage (hwnd, WM_DESTROY, 0, 0);
        return 0;
    }    

    get_file_version ("winpt.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
    ec = get_file_version ("PTD.dll", &ptdver[0], &ptdver[1], &ptdver[2], &ptdver[3]);
    if (!ec && (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;
    }

    s = gpgme_check_version (NEED_GPGME_VERSION);
    if (!s || !*s) {
        msg_box (GetDesktopWindow (),
                 _("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;
    
    gettext_set_user_domain ();

    regist_inst_gnupg (1);
    regist_inst_winpt (1, &created);

    if (!created) {
        memset (&reg_prefs, 0, sizeof (reg_prefs));
        get_reg_winpt_prefs (&reg_prefs);
        reg_prefs.fm.progress = 0; /* TODO: fix the bug and enable it again */
        if (gnupg_load_config () == -2)
            msg_box (GetDesktopWindow (), 
                     _("The gpg.conf file contains the 'textmode' option\n"
                       "which leads to broken binary output during decryption.\n"
                       "If this is on purpose, just continue otherwise the option should be disabled."),
                     _("WinPT Error"), MB_ERR);
    }

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

    rc = gnupg_check_homedir ();
    if (rc) {
        char *p;

        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 && (p=strrchr (s, '\\'))) {
            char *path = substr (s, 0, (p-s));

            set_reg_entry_gpg ("HomeDir", path);
            free_if_alloc (path);
        }
        else {
            msg_box (GetDesktopWindow (), 
                     _("GPG home directory could not be determined."),
                     _("WinPT Error"), MB_ERR);
            goto start;
        }
    }

    rc = check_gnupg_prog ();
    if (rc) {
        if (msg_box (GetDesktopWindow (), 
                     _("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 (GetDesktopWindow (), 
                     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 (GetDesktopWindow (),
                _("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 WinPT to offer you more choices.\n"),
                  "WinPT", MB_INFO|MB_YESNO);
            if (ec == IDYES)
                first_start = 1;
        }
        if (!first_start) {
            msg_box (GetDesktopWindow (), 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) /* 2 means read-only mode. */
            gpg_read_only = 1;
        else if (rc)
            return 0;
    }
    
    init_gnupg_table ();

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

    rc = kserver_load_conf ();
    if (rc)
        msg_box (GetDesktopWindow (), winpt_strerror (rc), 
                 _("Keyserver"), MB_ERR);

    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 && (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 (GetDesktopWindow (), _("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 (GetDesktopWindow (),
                 _("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 SETUP_EXISTING:
            rc = gnupg_import_keypair ();
            if (rc) {
                msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
                goto start;
            }
            break;

        case SETUP_CARDGEN:
            rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN,
                                 h, card_keygen_dlg_proc, 0);
            if (!rc)
                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 ();
            keycache_release (1);
            return 0;
        }
    }
    else {
        gpg_keycache_t c;
        if (update_keycache (hwnd)) {
            DestroyWindow (hwnd);
            free_gnupg_table ();
            keycache_release (1);
            return 0;
        }
        /* XXX: rewrite this part. */
        c = keycache_get_ctx (1);
        if (!gpg_keycache_get_size (c)) {
            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 (GetDesktopWindow (), 
                          _("It seems that GPG is not configured 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 ();
                keycache_release (1);
                return 0;
            }
        }       
        if (check_default_key ()) {
            char *p = get_gnupg_default_key ();
            log_box (_("WinPT Error"), MB_ERR,
                     _("Default key (from the GPG config file) could not be found or is unuseable.\n"
                       "The default key will be resetted and can be set later in the Key Manager again.\n\n"
                       "%s: secret key not found."), p? p : "?");
            set_gnupg_default_key (NULL);
            free_if_alloc (p);
        }
        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;
}