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

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