trunk/Src/wptSafeEditCtrl.cpp

/* wptSafeEditCtrl.cpp - Safe edit control for passwords
 *      Copyright (C) 2006 Timo Schulz, g10 Code GmbH
 *
 * 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 <stdio.h>
#include <richedit.h>
#include "resource.h"

#include "wptTypes.h"
#include "wptW32API.h"

/* New message to retrieve text. */
#define WM_SAFE_GETTEXT (WM_USER+11)

/* Hook context. */
struct hook_ctx_s {
    HHOOK keyb;     /* handle for the keyboard. */
    HHOOK cbt;      /* handle for computer based training (CBT) */
};
typedef struct hook_ctx_s *hook_ctx_t;

/* Subclassing context. */
struct subclass_ctx_s {
    WNDPROC new_wnd_fnc;    /* old window procedure. */
    WNDPROC old_wnd_fnc;    /* new window procedure. */
    HWND wnd;               /* window handle that is subclassed. */
    void *opaque;
};
typedef struct subclass_ctx_s *subclass_ctx_t;


/* Dummy hook procedure to avoid channing. */
static LRESULT CALLBACK 
dummy_hook_proc (int code, WPARAM wparam, LPARAM lparam)
{
    return FALSE;
}


/* Set dummy hooks to prevent that the control is monitored
   by some external hook functions. */
static hook_ctx_t
install_dummy_hooks (void)
{
    hook_ctx_t hc;

    hc = (hook_ctx_t)calloc (1, sizeof *hc);
    if (!hc)
        return NULL;
    hc->cbt = SetWindowsHookEx (WH_CBT, dummy_hook_proc,
                                 GetModuleHandle (NULL), 0);
    if (hc->cbt == NULL) {
        free (hc);
        return NULL;
    }
    hc->keyb = SetWindowsHookEx (WH_KEYBOARD, dummy_hook_proc,
                                 GetModuleHandle (NULL), 0);
    if (hc->keyb == NULL) {
        free (hc);
        return NULL;
    }
    return hc;
}


/* Remove dummy hooks and free memory. */
static void
deinstall_dummy_hooks (hook_ctx_t hc)
{
    UnhookWindowsHookEx (hc->cbt);
    UnhookWindowsHookEx (hc->keyb);
    free (hc);
}


/* Filtered window procedure for the passphrase edit control. */
static LRESULT CALLBACK 
safe_edit_dlg_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static subclass_ctx_t ctx = NULL;

    /* XXX: filter all messages which were not send from 
            the current process. */

    if (ctx == NULL)
        ctx = (subclass_ctx_t)GetWindowLong (hwnd, GWL_USERDATA);

    switch (msg) {
    case WM_CUT:
    case WM_COPY:
    case WM_PASTE:
        /* do not allow to copy or paste the inserted text. */
        return TRUE;

    case WM_KEYUP:
    case WM_KEYDOWN:
        /* XXX: maybe in a future release, we might want to provide
                our own buffer implementation. */

        /* ignore 'end' and 'home' to make text selection more difficult. */
        if ((int)wparam == VK_END || (int)wparam == VK_HOME)
            return TRUE;
        break;

    case WM_GETTEXT:
        /* disallow normal gettext message. */
        return TRUE;

    case WM_SAFE_GETTEXT:
        { /* transform WM_GETTEXT request into EM_GETLINE request. */
            char *buffer = (char*)wparam;
            int n;
            buffer[0] = (char)lparam;
            n = SendMessage (hwnd, EM_GETLINE, 0, wparam);
            buffer[n] = 0;
        }
        break;

    case EM_GETLINE:
        break;

    case WM_LBUTTONDBLCLK:
    case WM_RBUTTONUP:
    case WM_RBUTTONDOWN:
        /* prevent that the popup menu is displayed. */
        return TRUE;

    case EM_SETSEL:
    case EM_SCROLLCARET:
    case EM_FINDTEXT:
    case EM_FINDTEXTEX:
    case EM_GETSELTEXT:
    case EM_PASTESPECIAL:
    case EM_GETTEXTRANGE:
    case EM_STREAMIN:
    case EM_STREAMOUT:
        /* disallow message which could be used to copy the text. */
        return TRUE;
    }

    return CallWindowProc (ctx->old_wnd_fnc, hwnd, msg, wparam, lparam);
}


/* Sublclass the window in the dialog @dlg with the id @ctrlid.
   @new_wnd_fnc is the new window procedure. */   
static int
subclass_window (HWND dlg, int ctrlid, WNDPROC new_wnd_fnc,
                 subclass_ctx_t *r_ctx)
{
    subclass_ctx_t ctx;

    *r_ctx = NULL;
    ctx = (subclass_ctx_t)calloc (1, sizeof *ctx);
    if (!ctx)
        return -1;
    ctx->wnd = GetDlgItem (dlg, ctrlid);
    ctx->new_wnd_fnc = new_wnd_fnc;
    ctx->old_wnd_fnc = (WNDPROC)GetWindowLong (ctx->wnd, GWL_WNDPROC);
    if (!ctx->old_wnd_fnc) {
        free (ctx);
        return -1;
    }
    SetLastError (0);
    SetWindowLong (ctx->wnd, GWL_WNDPROC, (LONG)new_wnd_fnc);
    if (GetLastError () != 0) {
        free (ctx);
        return -1;
    }
    SetLastError (0);
    SetWindowLong (ctx->wnd, GWL_USERDATA, (LONG)ctx);
    if (GetLastError () != 0) {
        free (ctx);
        return -1;
    }
    if (r_ctx)
        *r_ctx = ctx;
    return 0;
}


/* Restore the old window procedure for the subclassed control
   and free the memory. */
static void
subclass_free_memory (HWND dlg, int ctrlid)
{
    subclass_ctx_t ctx;
    HWND wnd;

    wnd = GetDlgItem (dlg, ctrlid);
    ctx = (subclass_ctx_t)GetWindowLong (wnd, GWL_USERDATA);
    SetWindowLong (ctx->wnd, GWL_WNDPROC, (LONG)ctx->old_wnd_fnc);
    if (ctx != NULL)
        free (ctx);
}


/* Init subclassing to provide a safer edit control
   for the dialog @dlg control @ctlid. */
void
safe_edit_control_init (HWND dlg, int ctlid)
{
    subclass_ctx_t ctx;

    subclass_window (dlg, ctlid,  safe_edit_dlg_proc, &ctx);
    if (ctx != NULL)
        ctx->opaque = install_dummy_hooks ();
}


/* Reset subclassing for the edit control @ctlid. */
void
safe_edit_control_free (HWND dlg, int ctlid)
{
    subclass_ctx_t ctx;
    HWND wnd;

    wnd = GetDlgItem (dlg, ctlid);
    ctx = (subclass_ctx_t)GetWindowLong (wnd, GWL_USERDATA);
    if (ctx != NULL && ctx->opaque != NULL)
        deinstall_dummy_hooks ((hook_ctx_t)ctx->opaque);
    subclass_free_memory (dlg, ctlid);
}


UINT
SafeGetDlgItemText (HWND dlg, int id, char *buf, int buflen)
{
    /* XXX: use memset (buf, 0, buflen)? */
    SendDlgItemMessage (dlg, id, WM_SAFE_GETTEXT, (WPARAM)buf, (LPARAM)buflen);
    return strlen (buf);
}
1	twoaday	181	/* wptSafeEditCtrl.cpp - Safe edit control for passwords
2			* Copyright (C) 2006 Timo Schulz, g10 Code GmbH
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			#include <stdio.h>
23			#include <richedit.h>
24			#include "resource.h"
25
26			#include "wptTypes.h"
27			#include "wptW32API.h"
28
29			/* New message to retrieve text. */
30			#define WM_SAFE_GETTEXT (WM_USER+11)
31
32			/* Hook context. */
33			struct hook_ctx_s {
34			HHOOK keyb; /* handle for the keyboard. */
35			HHOOK cbt; /* handle for computer based training (CBT) */
36			};
37			typedef struct hook_ctx_s *hook_ctx_t;
38
39			/* Subclassing context. */
40			struct subclass_ctx_s {
41			WNDPROC new_wnd_fnc; /* old window procedure. */
42			WNDPROC old_wnd_fnc; /* new window procedure. */
43			HWND wnd; /* window handle that is subclassed. */
44			void *opaque;
45			};
46			typedef struct subclass_ctx_s *subclass_ctx_t;
47
48
49			/* Dummy hook procedure to avoid channing. */
50			static LRESULT CALLBACK
51			dummy_hook_proc (int code, WPARAM wparam, LPARAM lparam)
52			{
53			return FALSE;
54			}
55
56
57			/* Set dummy hooks to prevent that the control is monitored
58			by some external hook functions. */
59			static hook_ctx_t
60			install_dummy_hooks (void)
61			{
62			hook_ctx_t hc;
63
64			hc = (hook_ctx_t)calloc (1, sizeof *hc);
65			if (!hc)
66			return NULL;
67			hc->cbt = SetWindowsHookEx (WH_CBT, dummy_hook_proc,
68			GetModuleHandle (NULL), 0);
69			if (hc->cbt == NULL) {
70			free (hc);
71			return NULL;
72			}
73			hc->keyb = SetWindowsHookEx (WH_KEYBOARD, dummy_hook_proc,
74			GetModuleHandle (NULL), 0);
75			if (hc->keyb == NULL) {
76			free (hc);
77			return NULL;
78			}
79			return hc;
80			}
81
82
83			/* Remove dummy hooks and free memory. */
84			static void
85			deinstall_dummy_hooks (hook_ctx_t hc)
86			{
87			UnhookWindowsHookEx (hc->cbt);
88			UnhookWindowsHookEx (hc->keyb);
89			free (hc);
90			}
91
92
93			/* Filtered window procedure for the passphrase edit control. */
94			static LRESULT CALLBACK
95			safe_edit_dlg_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
96			{
97			static subclass_ctx_t ctx = NULL;
98
99			/* XXX: filter all messages which were not send from
100			the current process. */
101
102			if (ctx == NULL)
103			ctx = (subclass_ctx_t)GetWindowLong (hwnd, GWL_USERDATA);
104
105			switch (msg) {
106			case WM_CUT:
107			case WM_COPY:
108			case WM_PASTE:
109			/* do not allow to copy or paste the inserted text. */
110			return TRUE;
111
112			case WM_KEYUP:
113			case WM_KEYDOWN:
114			/* XXX: maybe in a future release, we might want to provide
115			our own buffer implementation. */
116
117			/* ignore 'end' and 'home' to make text selection more difficult. */
118			if ((int)wparam == VK_END \|\| (int)wparam == VK_HOME)
119			return TRUE;
120			break;
121
122			case WM_GETTEXT:
123			/* disallow normal gettext message. */
124			return TRUE;
125
126			case WM_SAFE_GETTEXT:
127			{ /* transform WM_GETTEXT request into EM_GETLINE request. */
128			char buffer = (char)wparam;
129			int n;
130			buffer[0] = (char)lparam;
131			n = SendMessage (hwnd, EM_GETLINE, 0, wparam);
132			buffer[n] = 0;
133			}
134			break;
135
136			case EM_GETLINE:
137			break;
138
139			case WM_LBUTTONDBLCLK:
140			case WM_RBUTTONUP:
141			case WM_RBUTTONDOWN:
142			/* prevent that the popup menu is displayed. */
143			return TRUE;
144
145			case EM_SETSEL:
146			case EM_SCROLLCARET:
147			case EM_FINDTEXT:
148			case EM_FINDTEXTEX:
149			case EM_GETSELTEXT:
150			case EM_PASTESPECIAL:
151			case EM_GETTEXTRANGE:
152			case EM_STREAMIN:
153			case EM_STREAMOUT:
154			/* disallow message which could be used to copy the text. */
155			return TRUE;
156			}
157
158			return CallWindowProc (ctx->old_wnd_fnc, hwnd, msg, wparam, lparam);
159			}
160
161
162			/* Sublclass the window in the dialog @dlg with the id @ctrlid.
163			@new_wnd_fnc is the new window procedure. */
164			static int
165			subclass_window (HWND dlg, int ctrlid, WNDPROC new_wnd_fnc,
166			subclass_ctx_t *r_ctx)
167			{
168			subclass_ctx_t ctx;
169
170			*r_ctx = NULL;
171			ctx = (subclass_ctx_t)calloc (1, sizeof *ctx);
172			if (!ctx)
173			return -1;
174			ctx->wnd = GetDlgItem (dlg, ctrlid);
175			ctx->new_wnd_fnc = new_wnd_fnc;
176			ctx->old_wnd_fnc = (WNDPROC)GetWindowLong (ctx->wnd, GWL_WNDPROC);
177			if (!ctx->old_wnd_fnc) {
178			free (ctx);
179			return -1;
180			}
181			SetLastError (0);
182			SetWindowLong (ctx->wnd, GWL_WNDPROC, (LONG)new_wnd_fnc);
183			if (GetLastError () != 0) {
184			free (ctx);
185			return -1;
186			}
187			SetLastError (0);
188			SetWindowLong (ctx->wnd, GWL_USERDATA, (LONG)ctx);
189			if (GetLastError () != 0) {
190			free (ctx);
191			return -1;
192			}
193			if (r_ctx)
194			*r_ctx = ctx;
195			return 0;
196			}
197
198
199			/* Restore the old window procedure for the subclassed control
200			and free the memory. */
201			static void
202			subclass_free_memory (HWND dlg, int ctrlid)
203			{
204			subclass_ctx_t ctx;
205			HWND wnd;
206
207			wnd = GetDlgItem (dlg, ctrlid);
208			ctx = (subclass_ctx_t)GetWindowLong (wnd, GWL_USERDATA);
209			SetWindowLong (ctx->wnd, GWL_WNDPROC, (LONG)ctx->old_wnd_fnc);
210			if (ctx != NULL)
211			free (ctx);
212			}
213
214
215			/* Init subclassing to provide a safer edit control
216			for the dialog @dlg control @ctlid. */
217			void
218			safe_edit_control_init (HWND dlg, int ctlid)
219			{
220			subclass_ctx_t ctx;
221
222			subclass_window (dlg, ctlid, safe_edit_dlg_proc, &ctx);
223			if (ctx != NULL)
224			ctx->opaque = install_dummy_hooks ();
225			}
226
227
228			/* Reset subclassing for the edit control @ctlid. */
229			void
230			safe_edit_control_free (HWND dlg, int ctlid)
231			{
232			subclass_ctx_t ctx;
233			HWND wnd;
234
235			wnd = GetDlgItem (dlg, ctlid);
236			ctx = (subclass_ctx_t)GetWindowLong (wnd, GWL_USERDATA);
237			if (ctx != NULL && ctx->opaque != NULL)
238			deinstall_dummy_hooks ((hook_ctx_t)ctx->opaque);
239			subclass_free_memory (dlg, ctlid);
240			}
241
242
243			UINT
244			SafeGetDlgItemText (HWND dlg, int id, char *buf, int buflen)
245			{
246			/* XXX: use memset (buf, 0, buflen)? */
247			SendDlgItemMessage (dlg, id, WM_SAFE_GETTEXT, (WPARAM)buf, (LPARAM)buflen);
248			return strlen (buf);
249			}