trunk/PTD/wptFileDisk.cpp

#if 0
        filedisk_init_info                      @600
        filedisk_free_info                      @601
        filedisk_mount                          @602
        filedisk_unmount                        @603
        filedisk_status                         @604

/* wptFileDisk.c - Control program for a virtual disk driver for WinNT/2000/XP.

    Copyright (C) 1999, 2000, 2001, 2002 Bo Brantén.

    Heavily modified for the use with Cryptdisk by Timo Schulz
    (C) 2004 Timo Schulz

    This program 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.
    This program 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 this program; 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 <windows.h>
#include <winioctl.h>
#include <stdio.h>
#include <sys/types.h>

#include "openpgp.h"
#include "../Include/wptCryptdisk.h"

/* remember to change the values in wptErrors.h also */
#define CDISK_ERR_LOCK   201
#define CDISK_ERR_MOUNT  202
#define CDISK_ERR_UMOUNT 203
#define CDISK_ERR_OPEN   204
#define CDISK_ERR_BUSY   205
#define CDISK_ERR_QUERY  206

static void 
print_lasterr (char * prefix)
{
    LPVOID msg;

    FormatMessage(
        FORMAT_MESSAGE_ALLOCATE_BUFFER |
        FORMAT_MESSAGE_FROM_SYSTEM |
        FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL,
        GetLastError(),
        0,
        (LPTSTR) &msg,
        0,
        NULL
        );
    MessageBox (NULL, (LPTSTR)msg, prefix, MB_ICONERROR|MB_OK);
    LocalFree (msg);
}

#if 0
static int
add_key (OPEN_FILE_INFORMATION *ka, const char * key, size_t len)
{
    gpg_md_t md=NULL;

    if (ka->KeyNum >= MAX_KEYS) 
        return -1;

    switch (ka->KeyType) {
    case 1: /* 2fish */
        md = gpg_md_open (MD_RMD160);
        ka->KeyLength=20;
        break;
    case 2: /* AES256 */
        md = gpg_md_open (MD_SHA512);
        ka->KeyLength=32;       
        break;
    case 3: /* AES128 */
        md = gpg_md_open (MD_SHA256);
        ka->KeyLength=16;
        break;
    case 4: /* AES192 */
        ka->KeyLength=24;
        md = gpg_md_open (MD_SHA384);
        break;
    }
    if (!md)
        return -1;
    gpg_md_write (md, (char *)key, len);
    gpg_md_final (md);
    memcpy (ka->Key[ka->KeyNum++], gpg_md_read (md), ka->KeyLength);
    gpg_md_close (md);
    return 0;
}
#endif


int
filedisk_mount (int                     DeviceNumber,
                OPEN_FILE_INFORMATION   *ofi,
                char                    drivelet,
                BOOLEAN                 CdImage)
{
    char    VolumeName[] = "\\\\.\\ :";
    char    DeviceName[255];
    HANDLE  Device;
    DWORD   BytesReturned;

    VolumeName[4] = drivelet;

    Device = CreateFile (VolumeName,
                         GENERIC_READ | GENERIC_WRITE,
                         FILE_SHARE_READ | FILE_SHARE_WRITE,
                         NULL,
                         OPEN_EXISTING,
                         FILE_FLAG_NO_BUFFERING,
                         NULL);
    if (Device != INVALID_HANDLE_VALUE) {
        SetLastError (ERROR_BUSY);
        print_lasterr (&VolumeName[4]);
        return CDISK_ERR_BUSY;
    }

    if (CdImage)
        sprintf (DeviceName, DEVICE_NAME_PREFIX "Cd" "%u", DeviceNumber);
    else
        sprintf (DeviceName, DEVICE_NAME_PREFIX "%u", DeviceNumber);

    if (!DefineDosDevice (DDD_RAW_TARGET_PATH,
                          &VolumeName[4],
                          DeviceName)) {
        print_lasterr (&VolumeName[4]);
        return CDISK_ERR_OPEN;
    }

    Device = CreateFile (VolumeName,
                         GENERIC_READ | GENERIC_WRITE,
                         FILE_SHARE_READ | FILE_SHARE_WRITE,
                         NULL,
                         OPEN_EXISTING,
                         FILE_FLAG_NO_BUFFERING,
                         NULL);

    if (Device == INVALID_HANDLE_VALUE) {
        print_lasterr (&VolumeName[4]);
        DefineDosDevice (DDD_REMOVE_DEFINITION, &VolumeName[4], NULL);
        return CDISK_ERR_OPEN;
    }

    if (!DeviceIoControl (Device,
                          IOCTL_FILE_DISK_OPEN_FILE,
                          ofi,
                          sizeof(OPEN_FILE_INFORMATION) + ofi->FileNameLength - 1,
                          NULL, 0, &BytesReturned, NULL)) {
        print_lasterr ("Cryptdisk Error");
        DefineDosDevice (DDD_REMOVE_DEFINITION, &VolumeName[4], NULL);
        return CDISK_ERR_MOUNT;
    }

    return 0;
}


static int 
filedisk_unmount2 (char drivelet, int flags, int forced)
{
    char    VolumeName[60] = "\\\\.\\ :";
    HANDLE  Device;
    DWORD   BytesReturned;

    if (!flags)
        VolumeName[4] = drivelet;
    else if (flags & 1)
        sprintf(VolumeName,"\\\\.\\FileDisk%d", drivelet);
    else if (flags & 2)
        sprintf(VolumeName,"\\\\.\\FileDiskCd%d",drivelet);

    Device = CreateFile (VolumeName,
                         GENERIC_READ | GENERIC_WRITE,
                         FILE_SHARE_READ | FILE_SHARE_WRITE,
                         NULL,
                         OPEN_EXISTING,
                         FILE_FLAG_NO_BUFFERING,
                         NULL);
    if (Device == INVALID_HANDLE_VALUE) {
        if (forced)
            print_lasterr(&VolumeName[4]);
        return CDISK_ERR_OPEN;
    }

    if (!DeviceIoControl (Device, 
                          FSCTL_LOCK_VOLUME,
                          NULL, 0, NULL, 0,
                          &BytesReturned, NULL)) {
        if (forced) {
            print_lasterr(&VolumeName[4]);
            return CDISK_ERR_LOCK;
        }
    }

    if (!DeviceIoControl (Device,
                          IOCTL_FILE_DISK_CLOSE_FILE,
                          NULL, 0, NULL, 0, 
                          &BytesReturned, NULL )) {
        if (forced)
            print_lasterr ("Cryptdisk Error");
        return CDISK_ERR_UMOUNT;
    }

    if (!DeviceIoControl (
        Device, FSCTL_DISMOUNT_VOLUME,
        NULL, 0, NULL, 0,
        &BytesReturned, NULL)) {
        if (forced)
            print_lasterr (&VolumeName[4]);
        return CDISK_ERR_UMOUNT;
    }

    if (!DeviceIoControl (Device, 
                          FSCTL_UNLOCK_VOLUME,
                          NULL, 0, NULL, 0,
                          &BytesReturned, NULL)) {
        if (forced) {
            print_lasterr (&VolumeName[4]);
            return CDISK_ERR_LOCK;
        }
    }

    CloseHandle (Device);

    if (!DefineDosDevice (
        DDD_REMOVE_DEFINITION,
        &VolumeName[4], NULL)) {
        if (forced)
            print_lasterr (&VolumeName[4]);
        return CDISK_ERR_UMOUNT;
    }

    return 0;
}

int 
filedisk_unmount (char drivelet, int forced)
{           
    char i;

    if (drivelet) {
        int rc = filedisk_unmount2 (drivelet, 0, forced);
        if (rc) 
            print_lasterr ("Unmount´");
        return rc;
    }
    for (i=0; i<20;i++) {
        if (filedisk_unmount2 (i, 1, 0) == CDISK_ERR_OPEN)
            break;
    }
    for (i=0; i<20;i++) {
        if (filedisk_unmount2 (i, 2, 0) == CDISK_ERR_OPEN)
            break;
    }
    return 0;
}


int
filedisk_status (char drivelet, LARGE_INTEGER * size, int * rdonly)
{
    char                    VolumeName[] = "\\\\.\\ :";
    HANDLE                  Device;
    POPEN_FILE_INFORMATION  ofi;
    DWORD                   BytesReturned;

    VolumeName[4] = drivelet;

    Device = CreateFile (VolumeName,
                         GENERIC_READ,
                         FILE_SHARE_READ | FILE_SHARE_WRITE,
                         NULL,
                         OPEN_EXISTING,
                         FILE_FLAG_NO_BUFFERING,
                        NULL);

    if (Device == INVALID_HANDLE_VALUE) {
        print_lasterr(&VolumeName[4]);
        return CDISK_ERR_OPEN;
    }

    ofi = malloc (sizeof(OPEN_FILE_INFORMATION) + MAX_PATH);

    if (!DeviceIoControl (Device,
                          IOCTL_FILE_DISK_QUERY_FILE,
                          NULL,
                          0,
                          ofi,
                          sizeof(OPEN_FILE_INFORMATION) + MAX_PATH,
                          &BytesReturned, NULL)) {
        print_lasterr (&VolumeName[4]);
        return CDISK_ERR_QUERY;
    }

    if (BytesReturned < sizeof(OPEN_FILE_INFORMATION)) {
        SetLastError (ERROR_INSUFFICIENT_BUFFER);
        print_lasterr (&VolumeName[4]);
        return CDISK_ERR_QUERY;
    }

    if (size)
        *size = ofi->FileSize;
    if (rdonly)
        *rdonly = ofi->ReadOnly;

    return 0;
}


POPEN_FILE_INFORMATION
filedisk_init_info (int devnum, char drivelet, const char * file,
                    int ro, int cd_img, unsigned long size, const char * key,
                    int keyalgo)
{
    POPEN_FILE_INFORMATION pfi;

    pfi = calloc (1, sizeof(OPEN_FILE_INFORMATION) + strlen (file) + 7);
    if (!pfi)
        return NULL;

    /*pfi->version = CCVERSION;*/
    if (file[0] == '\\') {
        if (file[1] == '\\' && file[2] != '.') {
            /* \\server\share\path\filedisk.img */
            strcpy(pfi->FileName, "\\??\\UNC");
            strcat(pfi->FileName, file + 1);
        }
        else /* \Device\Harddisk0\Partition1\path\filedisk.img */
            strcpy(pfi->FileName, file);
    }   
    else { // c:\path\filedisk.img
        strcpy (pfi->FileName, "\\??\\");
        strcat (pfi->FileName, file);
    }

    pfi->FileNameLength = (USHORT) strlen (pfi->FileName);
    pfi->ReadOnly = ro? TRUE : FALSE;
    if (cd_img)
        pfi->ReadOnly = TRUE;
    if (size)
        pfi->FileSize.QuadPart = size * 1024;
    if (key) {
        /*
        if (keyalgo < 1 || keyalgo > 4)
            pfi->KeyType = 1;
        else
            pfi->KeyType = keyalgo;
        add_key (pfi, key, strlen (key));
        */
    }

    return pfi;
}


void
filedisk_free_info (POPEN_FILE_INFORMATION pfi)
{
    if (!pfi)
        return;
    /*memset (pfi->Key, 0, sizeof pfi->Key);*/
    free (pfi);
}
#endif

1	#if 0
2	filedisk_init_info @600
3	filedisk_free_info @601
4	filedisk_mount @602
5	filedisk_unmount @603
6	filedisk_status @604
7
8	/* wptFileDisk.c - Control program for a virtual disk driver for WinNT/2000/XP.
9
10	Copyright (C) 1999, 2000, 2001, 2002 Bo Brantén.
11
12	Heavily modified for the use with Cryptdisk by Timo Schulz
13	(C) 2004 Timo Schulz
14
15	This program is free software; you can redistribute it and/or modify
16	it under the terms of the GNU General Public License as published by
17	the Free Software Foundation; either version 2 of the License, or
18	(at your option) any later version.
19	This program is distributed in the hope that it will be useful,
20	but WITHOUT ANY WARRANTY; without even the implied warranty of
21	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22	GNU General Public License for more details.
23	You should have received a copy of the GNU General Public License
24	along with this program; if not, write to the Free Software
25	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26	*/
27
28	#ifdef HAVE_CONFIG_H
29	#include <config.h>
30	#endif
31
32	#include <windows.h>
33	#include <windows.h>
34	#include <winioctl.h>
35	#include <stdio.h>
36	#include <sys/types.h>
37
38	#include "openpgp.h"
39	#include "../Include/wptCryptdisk.h"
40
41	/* remember to change the values in wptErrors.h also */
42	#define CDISK_ERR_LOCK 201
43	#define CDISK_ERR_MOUNT 202
44	#define CDISK_ERR_UMOUNT 203
45	#define CDISK_ERR_OPEN 204
46	#define CDISK_ERR_BUSY 205
47	#define CDISK_ERR_QUERY 206
48
49	static void
50	print_lasterr (char * prefix)
51	{
52	LPVOID msg;
53
54	FormatMessage(
55	FORMAT_MESSAGE_ALLOCATE_BUFFER \|
56	FORMAT_MESSAGE_FROM_SYSTEM \|
57	FORMAT_MESSAGE_IGNORE_INSERTS,
58	NULL,
59	GetLastError(),
60	0,
61	(LPTSTR) &msg,
62	0,
63	NULL
64	);
65	MessageBox (NULL, (LPTSTR)msg, prefix, MB_ICONERROR\|MB_OK);
66	LocalFree (msg);
67	}
68
69	#if 0
70	static int
71	add_key (OPEN_FILE_INFORMATION ka, const char key, size_t len)
72	{
73	gpg_md_t md=NULL;
74
75	if (ka->KeyNum >= MAX_KEYS)
76	return -1;
77
78	switch (ka->KeyType) {
79	case 1: /* 2fish */
80	md = gpg_md_open (MD_RMD160);
81	ka->KeyLength=20;
82	break;
83	case 2: /* AES256 */
84	md = gpg_md_open (MD_SHA512);
85	ka->KeyLength=32;
86	break;
87	case 3: /* AES128 */
88	md = gpg_md_open (MD_SHA256);
89	ka->KeyLength=16;
90	break;
91	case 4: /* AES192 */
92	ka->KeyLength=24;
93	md = gpg_md_open (MD_SHA384);
94	break;
95	}
96	if (!md)
97	return -1;
98	gpg_md_write (md, (char *)key, len);
99	gpg_md_final (md);
100	memcpy (ka->Key[ka->KeyNum++], gpg_md_read (md), ka->KeyLength);
101	gpg_md_close (md);
102	return 0;
103	}
104	#endif
105
106
107	int
108	filedisk_mount (int DeviceNumber,
109	OPEN_FILE_INFORMATION *ofi,
110	char drivelet,
111	BOOLEAN CdImage)
112	{
113	char VolumeName[] = "\\\\.\\ :";
114	char DeviceName[255];
115	HANDLE Device;
116	DWORD BytesReturned;
117
118	VolumeName[4] = drivelet;
119
120	Device = CreateFile (VolumeName,
121	GENERIC_READ \| GENERIC_WRITE,
122	FILE_SHARE_READ \| FILE_SHARE_WRITE,
123	NULL,
124	OPEN_EXISTING,
125	FILE_FLAG_NO_BUFFERING,
126	NULL);
127	if (Device != INVALID_HANDLE_VALUE) {
128	SetLastError (ERROR_BUSY);
129	print_lasterr (&VolumeName[4]);
130	return CDISK_ERR_BUSY;
131	}
132
133	if (CdImage)
134	sprintf (DeviceName, DEVICE_NAME_PREFIX "Cd" "%u", DeviceNumber);
135	else
136	sprintf (DeviceName, DEVICE_NAME_PREFIX "%u", DeviceNumber);
137
138	if (!DefineDosDevice (DDD_RAW_TARGET_PATH,
139	&VolumeName[4],
140	DeviceName)) {
141	print_lasterr (&VolumeName[4]);
142	return CDISK_ERR_OPEN;
143	}
144
145	Device = CreateFile (VolumeName,
146	GENERIC_READ \| GENERIC_WRITE,
147	FILE_SHARE_READ \| FILE_SHARE_WRITE,
148	NULL,
149	OPEN_EXISTING,
150	FILE_FLAG_NO_BUFFERING,
151	NULL);
152
153	if (Device == INVALID_HANDLE_VALUE) {
154	print_lasterr (&VolumeName[4]);
155	DefineDosDevice (DDD_REMOVE_DEFINITION, &VolumeName[4], NULL);
156	return CDISK_ERR_OPEN;
157	}
158
159	if (!DeviceIoControl (Device,
160	IOCTL_FILE_DISK_OPEN_FILE,
161	ofi,
162	sizeof(OPEN_FILE_INFORMATION) + ofi->FileNameLength - 1,
163	NULL, 0, &BytesReturned, NULL)) {
164	print_lasterr ("Cryptdisk Error");
165	DefineDosDevice (DDD_REMOVE_DEFINITION, &VolumeName[4], NULL);
166	return CDISK_ERR_MOUNT;
167	}
168
169	return 0;
170	}
171
172
173	static int
174	filedisk_unmount2 (char drivelet, int flags, int forced)
175	{
176	char VolumeName[60] = "\\\\.\\ :";
177	HANDLE Device;
178	DWORD BytesReturned;
179
180	if (!flags)
181	VolumeName[4] = drivelet;
182	else if (flags & 1)
183	sprintf(VolumeName,"\\\\.\\FileDisk%d", drivelet);
184	else if (flags & 2)
185	sprintf(VolumeName,"\\\\.\\FileDiskCd%d",drivelet);
186
187	Device = CreateFile (VolumeName,
188	GENERIC_READ \| GENERIC_WRITE,
189	FILE_SHARE_READ \| FILE_SHARE_WRITE,
190	NULL,
191	OPEN_EXISTING,
192	FILE_FLAG_NO_BUFFERING,
193	NULL);
194	if (Device == INVALID_HANDLE_VALUE) {
195	if (forced)
196	print_lasterr(&VolumeName[4]);
197	return CDISK_ERR_OPEN;
198	}
199
200	if (!DeviceIoControl (Device,
201	FSCTL_LOCK_VOLUME,
202	NULL, 0, NULL, 0,
203	&BytesReturned, NULL)) {
204	if (forced) {
205	print_lasterr(&VolumeName[4]);
206	return CDISK_ERR_LOCK;
207	}
208	}
209
210	if (!DeviceIoControl (Device,
211	IOCTL_FILE_DISK_CLOSE_FILE,
212	NULL, 0, NULL, 0,
213	&BytesReturned, NULL )) {
214	if (forced)
215	print_lasterr ("Cryptdisk Error");
216	return CDISK_ERR_UMOUNT;
217	}
218
219	if (!DeviceIoControl (
220	Device, FSCTL_DISMOUNT_VOLUME,
221	NULL, 0, NULL, 0,
222	&BytesReturned, NULL)) {
223	if (forced)
224	print_lasterr (&VolumeName[4]);
225	return CDISK_ERR_UMOUNT;
226	}
227
228	if (!DeviceIoControl (Device,
229	FSCTL_UNLOCK_VOLUME,
230	NULL, 0, NULL, 0,
231	&BytesReturned, NULL)) {
232	if (forced) {
233	print_lasterr (&VolumeName[4]);
234	return CDISK_ERR_LOCK;
235	}
236	}
237
238	CloseHandle (Device);
239
240	if (!DefineDosDevice (
241	DDD_REMOVE_DEFINITION,
242	&VolumeName[4], NULL)) {
243	if (forced)
244	print_lasterr (&VolumeName[4]);
245	return CDISK_ERR_UMOUNT;
246	}
247
248	return 0;
249	}
250
251	int
252	filedisk_unmount (char drivelet, int forced)
253	{
254	char i;
255
256	if (drivelet) {
257	int rc = filedisk_unmount2 (drivelet, 0, forced);
258	if (rc)
259	print_lasterr ("Unmount´");
260	return rc;
261	}
262	for (i=0; i<20;i++) {
263	if (filedisk_unmount2 (i, 1, 0) == CDISK_ERR_OPEN)
264	break;
265	}
266	for (i=0; i<20;i++) {
267	if (filedisk_unmount2 (i, 2, 0) == CDISK_ERR_OPEN)
268	break;
269	}
270	return 0;
271	}
272
273
274	int
275	filedisk_status (char drivelet, LARGE_INTEGER * size, int * rdonly)
276	{
277	char VolumeName[] = "\\\\.\\ :";
278	HANDLE Device;
279	POPEN_FILE_INFORMATION ofi;
280	DWORD BytesReturned;
281
282	VolumeName[4] = drivelet;
283
284	Device = CreateFile (VolumeName,
285	GENERIC_READ,
286	FILE_SHARE_READ \| FILE_SHARE_WRITE,
287	NULL,
288	OPEN_EXISTING,
289	FILE_FLAG_NO_BUFFERING,
290	NULL);
291
292	if (Device == INVALID_HANDLE_VALUE) {
293	print_lasterr(&VolumeName[4]);
294	return CDISK_ERR_OPEN;
295	}
296
297	ofi = malloc (sizeof(OPEN_FILE_INFORMATION) + MAX_PATH);
298
299	if (!DeviceIoControl (Device,
300	IOCTL_FILE_DISK_QUERY_FILE,
301	NULL,
302	0,
303	ofi,
304	sizeof(OPEN_FILE_INFORMATION) + MAX_PATH,
305	&BytesReturned, NULL)) {
306	print_lasterr (&VolumeName[4]);
307	return CDISK_ERR_QUERY;
308	}
309
310	if (BytesReturned < sizeof(OPEN_FILE_INFORMATION)) {
311	SetLastError (ERROR_INSUFFICIENT_BUFFER);
312	print_lasterr (&VolumeName[4]);
313	return CDISK_ERR_QUERY;
314	}
315
316	if (size)
317	*size = ofi->FileSize;
318	if (rdonly)
319	*rdonly = ofi->ReadOnly;
320
321	return 0;
322	}
323
324
325	POPEN_FILE_INFORMATION
326	filedisk_init_info (int devnum, char drivelet, const char * file,
327	int ro, int cd_img, unsigned long size, const char * key,
328	int keyalgo)
329	{
330	POPEN_FILE_INFORMATION pfi;
331
332	pfi = calloc (1, sizeof(OPEN_FILE_INFORMATION) + strlen (file) + 7);
333	if (!pfi)
334	return NULL;
335
336	/pfi->version = CCVERSION;/
337	if (file[0] == '\\') {
338	if (file[1] == '\\' && file[2] != '.') {
339	/* \\server\share\path\filedisk.img */
340	strcpy(pfi->FileName, "\\??\\UNC");
341	strcat(pfi->FileName, file + 1);
342	}
343	else /* \Device\Harddisk0\Partition1\path\filedisk.img */
344	strcpy(pfi->FileName, file);
345	}
346	else { // c:\path\filedisk.img
347	strcpy (pfi->FileName, "\\??\\");
348	strcat (pfi->FileName, file);
349	}
350
351	pfi->FileNameLength = (USHORT) strlen (pfi->FileName);
352	pfi->ReadOnly = ro? TRUE : FALSE;
353	if (cd_img)
354	pfi->ReadOnly = TRUE;
355	if (size)
356	pfi->FileSize.QuadPart = size * 1024;
357	if (key) {
358	/*
359	if (keyalgo < 1 \|\| keyalgo > 4)
360	pfi->KeyType = 1;
361	else
362	pfi->KeyType = keyalgo;
363	add_key (pfi, key, strlen (key));
364	*/
365	}
366
367	return pfi;
368	}
369
370
371	void
372	filedisk_free_info (POPEN_FILE_INFORMATION pfi)
373	{
374	if (!pfi)
375	return;
376	/memset (pfi->Key, 0, sizeof pfi->Key);/
377	free (pfi);
378	}
379	#endif
380