int dc_format_done(wchar_t *dev_name)
{
dev_hook *hook = NULL;
int resl;
DbgMsg("dc_format_done\n");
do
{
if ( (hook = dc_find_hook(dev_name)) == NULL ) {
resl = ST_NF_DEVICE; break;
}
wait_object_infinity(&hook->busy_lock);
if ( !(hook->flags & F_FORMATTING) ) {
resl = ST_ERROR; break;
}
/* set hook fields */
hook->tmp_size = 0;
hook->flags &= ~F_FORMATTING;
/* free resources */
dc_wipe_free(&hook->wp_ctx);
mm_free(hook->tmp_buff);
mm_free(hook->tmp_key);
resl = ST_OK;
} while (0);
if (hook != NULL) {
KeReleaseMutex(&hook->busy_lock, FALSE);
dc_deref_hook(hook);
}
return resl;
}
int dc_backup_header(wchar_t *dev_name, dc_pass *password, void *out)
{
dc_header *header = NULL;
xts_key *hdr_key = NULL;
dev_hook *hook = NULL;
int resl;
s8 salt[PKCS5_SALT_SIZE];
do
{
if ( (hook = dc_find_hook(dev_name)) == NULL ) {
resl = ST_NF_DEVICE; break;
}
wait_object_infinity(&hook->busy_lock);
if (hook->flags & (F_SYNC | F_UNSUPRT | F_DISABLE | F_CDROM)) {
resl = ST_ERROR; break;
}
if ( (hdr_key = mm_alloc(sizeof(xts_key), MEM_SECURE)) == NULL ) {
resl = ST_NOMEM; break;
}
/* get device params */
if (hook->dsk_size == 0) {
if ( (resl = dc_fill_disk_info(hook)) != ST_OK ) break;
}
if ( (resl = io_read_header(hook, &header, NULL, password)) != ST_OK ) {
break;
}
/* generate new salt */
cp_rand_bytes(header->salt, PKCS5_SALT_SIZE);
/* save original salt */
memcpy(salt, header->salt, PKCS5_SALT_SIZE);
/* init new header key */
cp_set_header_key(hdr_key, header->salt, header->alg_1, password);
/* encrypt header with new key */
xts_encrypt(pv(header), pv(header), sizeof(dc_header), 0, hdr_key);
/* restore original salt */
memcpy(header->salt, salt, PKCS5_SALT_SIZE);
/* copy header to output */
memcpy(out, header, sizeof(dc_header));
resl = ST_OK;
} while (0);
if (hook != NULL) {
KeReleaseMutex(&hook->busy_lock, FALSE);
dc_deref_hook(hook);
}
/* prevent leaks */
burn(salt, sizeof(salt));
/* free memory */
if (header != NULL) mm_free(header);
if (hdr_key != NULL) mm_free(hdr_key);
return resl;
}
static u32 dc_get_hook_flags(wchar_t *dev_name)
{
dev_hook *hook;
u32 flags = 0;
if (hook = dc_find_hook(dev_name)) {
flags = hook->flags;
dc_deref_hook(hook);
}
return flags;
}
int dc_change_pass(wchar_t *dev_name, dc_pass *old_pass, dc_pass *new_pass)
{
dc_header *header = NULL;
dev_hook *hook = NULL;
int wp_init = 0;
int resl;
wipe_ctx wipe;
do
{
if ( (hook = dc_find_hook(dev_name)) == NULL ) {
resl = ST_NF_DEVICE; break;
}
wait_object_infinity(&hook->busy_lock);
if ( !(hook->flags & F_ENABLED) ) {
resl = ST_NO_MOUNT; break;
}
if (hook->flags & (F_SYNC | F_FORMATTING | F_CDROM)) {
resl = ST_ERROR; break;
}
/* read old volume header */
if ( (resl = io_read_header(hook, &header, NULL, old_pass)) != ST_OK ) {
break;
}
/* init data wipe */
if ( (resl = dc_wipe_init(
&wipe, hook, hook->head_len, WP_GUTMANN, hook->crypt.cipher_id)) == ST_OK )
{
wp_init = 1;
} else break;
/* wipe volume header */
dc_wipe_process(&wipe, 0, hook->head_len);
/* write new volume header */
resl = io_write_header(hook, header, NULL, new_pass);
} while (0);
if (wp_init != 0) {
dc_wipe_free(&wipe);
}
if (hook != NULL) {
KeReleaseMutex(&hook->busy_lock, FALSE);
dc_deref_hook(hook);
}
if (header != NULL) mm_free(header);
return resl;
}
int dc_restore_header(wchar_t *dev_name, dc_pass *password, void *in)
{
dc_header *header = NULL;
xts_key *hdr_key = NULL;
dev_hook *hook = NULL;
int resl;
do
{
if ( (hook = dc_find_hook(dev_name)) == NULL ) {
resl = ST_NF_DEVICE; break;
}
wait_object_infinity(&hook->busy_lock);
if (hook->flags & (F_ENABLED | F_CDROM)) {
resl = ST_ERROR; break;
}
/* get device params */
if (hook->dsk_size == 0) {
if ( (resl = dc_fill_disk_info(hook)) != ST_OK ) break;
}
if ( (header = mm_alloc(sizeof(dc_header), MEM_SECURE)) == NULL ) {
resl = ST_NOMEM; break;
}
/* copy header from input */
memcpy(header, in, sizeof(dc_header));
if ( (hdr_key = mm_alloc(sizeof(xts_key), MEM_SECURE)) == NULL ) {
resl = ST_NOMEM; break;
}
/* decrypt header */
if (cp_decrypt_header(hdr_key, header, password) == 0) {
resl = ST_PASS_ERR; break;
}
/* write new volume header */
resl = io_write_header(hook, header, NULL, password);
} while (0);
if (hook != NULL) {
KeReleaseMutex(&hook->busy_lock, FALSE);
dc_deref_hook(hook);
}
if (hdr_key != NULL) mm_free(hdr_key);
if (header != NULL) mm_free(header);
return resl;
}
int dc_unmount_device(wchar_t *dev_name, int force)
{
dev_hook *hook;
int resl;
DbgMsg("dc_unmount_device %ws\n", dev_name);
if (hook = dc_find_hook(dev_name))
{
if (IS_UNMOUNTABLE(hook)) {
resl = dc_process_unmount(hook, force);
} else {
resl = ST_UNMOUNTABLE;
}
dc_deref_hook(hook);
} else {
resl = ST_NF_DEVICE;
}
return resl;
}
int dc_mount_device(wchar_t *dev_name, dc_pass *password, u32 mnt_flags)
{
dc_header *hcopy = NULL;
dev_hook *hook = NULL;
xts_key *hdr_key = NULL;
int resl;
DbgMsg("dc_mount_device %ws\n", dev_name);
do
{
if ( (hook = dc_find_hook(dev_name)) == NULL ) {
resl = ST_NF_DEVICE; break;
}
wait_object_infinity(&hook->busy_lock);
if (hook->flags & F_ENABLED) {
resl = ST_ALR_MOUNT; break;
}
if (hook->flags & (F_UNSUPRT | F_DISABLE | F_FORMATTING)) {
resl = ST_ERROR; break;
}
if ( !NT_SUCCESS(dc_fill_device_info(hook)) ) {
resl = ST_IO_ERROR; break;
}
if ( ( (hook->flags & F_CDROM) && (hook->bps != CD_SECTOR_SIZE) ) ||
(!(hook->flags & F_CDROM) && IS_INVALID_SECTOR_SIZE(hook->bps) ) )
{
hook->flags |= F_UNSUPRT; resl = ST_ERROR; break;
}
if ( (resl = dc_probe_decrypt(hook, &hcopy, &hdr_key, password)) != ST_OK ) {
break;
}
/* check volume header */
if ( (IS_INVALID_VOL_FLAGS(hcopy->flags) != 0) ||
( (hcopy->flags & VF_STORAGE_FILE) && (hcopy->stor_off == 0) ) ||
(hcopy->alg_1 >= CF_CIPHERS_NUM) ||
(hcopy->alg_2 >= CF_CIPHERS_NUM) ||
(hcopy->tmp_wp_mode >= WP_NUM) ||
( (hook->flags & F_CDROM) && (hcopy->flags & (VF_TMP_MODE | VF_STORAGE_FILE)) ) )
{
resl = ST_INV_VOLUME; break;
}
if (hcopy->version > DC_HDR_VERSION) {
resl = ST_VOLUME_TOO_NEW; break;
}
#if 0
/* update volume header if needed */
if ( (hcopy->version < DC_HDR_VERSION) && !(hook->flags & F_CDROM) )
{
hcopy->version = DC_HDR_VERSION;
memset(hcopy->deprecated, 0, sizeof(hcopy->deprecated));
io_write_header(hook, hcopy, hdr_key, NULL);
}
#endif
DbgMsg("hdr_key=%p, dsk_key=%p\n", hdr_key, hook->dsk_key);
// initialize volume key
if ( (hook->dsk_key = (xts_key*)mm_secure_alloc(sizeof(xts_key))) == NULL ) {
resl = ST_NOMEM;
break;
}
xts_set_key(hcopy->key_1, hcopy->alg_1, hook->dsk_key);
DbgMsg("device mounted\n");
if (hcopy->flags & VF_STORAGE_FILE) {
hook->use_size = hook->dsk_size;
hook->stor_off = hcopy->stor_off;
} else {
hook->use_size = hook->dsk_size - hook->head_len;
hook->stor_off = hook->use_size;
}
hook->crypt.cipher_id = d8(hcopy->alg_1);
hook->disk_id = hcopy->disk_id;
hook->vf_version = hcopy->version;
hook->tmp_size = 0;
hook->mnt_flags = mnt_flags;
DbgMsg("hook->vf_version %d\n", hook->vf_version);
DbgMsg("hook->bps %d\n", hook->bps);
DbgMsg("hook->head_len %d\n", hook->head_len);
DbgMsg("flags %x\n", hcopy->flags);
if (hcopy->flags & VF_STORAGE_FILE) {
hook->flags |= F_PROTECT_DCSYS;
}
if (hcopy->flags & VF_NO_REDIR) {
hook->flags |= F_NO_REDIRECT;
hook->stor_off = 0;
}
if (hcopy->flags & VF_TMP_MODE)
{
hook->tmp_size = hcopy->tmp_size;
hook->hdr_key = hdr_key;
hook->crypt.wp_mode = hcopy->tmp_wp_mode;
if (hcopy->flags & VF_REENCRYPT) {
hook->sync_init_type = S_CONTINUE_RE_ENC;
} else {
hook->sync_init_type = S_CONTINUE_ENC;
}
/* copy decrypted header to device data */
memcpy(&hook->tmp_header, hcopy, sizeof(dc_header));
if ( (resl = dc_enable_sync_mode(hook)) != ST_OK )
{
burn(&hook->tmp_header, sizeof(dc_header));
hdr_key = hook->hdr_key;
} else {
hdr_key = NULL; /* prevent key wiping */
}
} else {
hook->flags |= F_ENABLED;
resl = ST_OK;
}
if (resl == ST_OK) {
/* increment mount changes counter */
lock_inc(&hook->chg_mount);
}
} while (0);
if (hdr_key != NULL) mm_secure_free(hdr_key);
if (hcopy != NULL) mm_secure_free(hcopy);
if (hook != NULL)
{
if ((hook->flags & F_ENABLED) == 0 && hook->dsk_key != NULL) {
mm_secure_free(hook->dsk_key);
hook->dsk_key = NULL;
}
KeReleaseMutex(&hook->busy_lock, FALSE);
dc_deref_hook(hook);
}
return resl;
}
NTSTATUS dc_drv_control_irp(PDEVICE_OBJECT dev_obj, PIRP irp)
{
PIO_STACK_LOCATION irp_sp = IoGetCurrentIrpStackLocation(irp);
NTSTATUS status = STATUS_INVALID_DEVICE_REQUEST; // returned status
ULONG length = 0; // returned length
//
void *data = irp->AssociatedIrp.SystemBuffer;
u32 in_len = irp_sp->Parameters.DeviceIoControl.InputBufferLength;
u32 out_len = irp_sp->Parameters.DeviceIoControl.OutputBufferLength;
switch (irp_sp->Parameters.DeviceIoControl.IoControlCode)
{
case DC_GET_VERSION:
if (irp_sp->Parameters.DeviceIoControl.OutputBufferLength != sizeof(ULONG))
{
status = STATUS_INVALID_PARAMETER;
break;
}
*((PULONG)irp->AssociatedIrp.SystemBuffer) = DC_DRIVER_VER;
status = STATUS_SUCCESS;
length = sizeof(ULONG);
break;
case DC_CTL_CLEAR_PASS:
dc_clean_pass_cache();
status = STATUS_SUCCESS;
break;
case DC_CTL_ADD_SEED:
if (irp_sp->Parameters.DeviceIoControl.InputBufferLength == 0)
{
status = STATUS_INVALID_PARAMETER;
break;
}
cp_rand_add_seed(irp->AssociatedIrp.SystemBuffer, irp_sp->Parameters.DeviceIoControl.InputBufferLength);
status = STATUS_SUCCESS;
// prevent leaks
RtlSecureZeroMemory(irp->AssociatedIrp.SystemBuffer, irp_sp->Parameters.DeviceIoControl.InputBufferLength);
break;
case DC_CTL_GET_RAND:
if (irp_sp->Parameters.DeviceIoControl.OutputBufferLength == 0)
{
status = STATUS_INVALID_PARAMETER;
break;
}
if ( (data = MmGetSystemAddressForMdlSafe(irp->MdlAddress, NormalPagePriority)) == NULL )
{
status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
if (cp_rand_bytes(data, irp_sp->Parameters.DeviceIoControl.OutputBufferLength) == 0)
{
status = STATUS_INTERNAL_ERROR;
break;
}
status = STATUS_SUCCESS;
length = irp_sp->Parameters.DeviceIoControl.OutputBufferLength;
break;
case DC_CTL_LOCK_MEM:
if (irp_sp->Parameters.DeviceIoControl.InputBufferLength != sizeof(DC_LOCK_MEMORY))
{
status = STATUS_INVALID_PARAMETER;
break;
}
status = mm_lock_user_memory( PsGetProcessId(IoGetRequestorProcess(irp)), ((PDC_LOCK_MEMORY)irp->AssociatedIrp.SystemBuffer)->ptr,
((PDC_LOCK_MEMORY)irp->AssociatedIrp.SystemBuffer)->length );
break;
case DC_CTL_UNLOCK_MEM:
if (irp_sp->Parameters.DeviceIoControl.InputBufferLength != sizeof(PVOID*))
{
status = STATUS_INVALID_PARAMETER;
break;
}
status = mm_unlock_user_memory( PsGetProcessId(IoGetRequestorProcess(irp)), *((PVOID*)irp->AssociatedIrp.SystemBuffer) );
break;
case DC_CTL_GET_FLAGS:
if (irp_sp->Parameters.DeviceIoControl.OutputBufferLength != sizeof(DC_FLAGS))
{
status = STATUS_INVALID_PARAMETER;
break;
}
((PDC_FLAGS)irp->AssociatedIrp.SystemBuffer)->conf_flags = dc_conf_flags;
((PDC_FLAGS)irp->AssociatedIrp.SystemBuffer)->load_flags = dc_load_flags;
status = STATUS_SUCCESS;
length = sizeof(DC_FLAGS);
break;
case DC_CTL_SET_FLAGS:
if (irp_sp->Parameters.DeviceIoControl.InputBufferLength != sizeof(DC_FLAGS))
{
status = STATUS_INVALID_PARAMETER;
break;
}
dc_conf_flags = ((PDC_FLAGS)irp->AssociatedIrp.SystemBuffer)->conf_flags;
if ( !(dc_conf_flags & CONF_CACHE_PASSWORD) ) dc_clean_pass_cache();
dc_init_encryption();
status = STATUS_SUCCESS;
break;
case DC_CTL_BSOD:
mm_clean_secure_memory();
dc_clean_keys();
KeBugCheck(IRQL_NOT_LESS_OR_EQUAL);
break;
case DC_GET_DUMP_HELPERS: // This IOCTL is allowed only from kernel mode
if (irp->RequestorMode != KernelMode)
{
status = STATUS_ACCESS_DENIED;
break;
}
if (irp_sp->Parameters.DeviceIoControl.OutputBufferLength != sizeof(DC_DUMP_HELPERS))
{
status = STATUS_INVALID_PARAMETER;
break;
}
memcpy(irp->UserBuffer, &dc_dump_helpers, sizeof(DC_DUMP_HELPERS));
status = STATUS_SUCCESS;
length = sizeof(DC_DUMP_HELPERS);
break;
//
case DC_CTL_STATUS:
{
dc_ioctl *dctl = data;
dc_status *stat = data;
dev_hook *hook;
if ( (in_len == sizeof(dc_ioctl)) && (out_len == sizeof(dc_status)) )
{
dctl->device[MAX_DEVICE] = 0;
if (hook = dc_find_hook(dctl->device))
{
if (hook->pdo_dev->Flags & DO_SYSTEM_BOOT_PARTITION) {
hook->flags |= F_SYSTEM;
}
dc_get_mount_point(hook, stat->mnt_point, sizeof(stat->mnt_point));
stat->crypt = hook->crypt;
stat->dsk_size = hook->dsk_size;
stat->tmp_size = hook->tmp_size;
stat->flags = hook->flags;
stat->mnt_flags = hook->mnt_flags;
stat->disk_id = hook->disk_id;
stat->paging_count = hook->paging_count;
stat->vf_version = hook->vf_version;
status = STATUS_SUCCESS;
length = sizeof(dc_status);
dc_deref_hook(hook);
}
}
}
break;
case DC_CTL_BENCHMARK:
{
if ( (in_len == sizeof(int)) && (out_len == sizeof(dc_bench_info)) )
{
if (dc_k_benchmark(p32(data)[0], pv(data)) == ST_OK) {
status = STATUS_SUCCESS;
length = sizeof(dc_bench_info);
}
}
}
break;
case DC_BACKUP_HEADER:
{
dc_backup_ctl *back = data;
if ( (in_len == sizeof(dc_backup_ctl)) && (out_len == in_len) )
{
back->device[MAX_DEVICE] = 0;
back->status = dc_backup_header(back->device, &back->pass, back->backup);
/* prevent leaks */
burn(&back->pass, sizeof(back->pass));
status = STATUS_SUCCESS;
length = sizeof(dc_backup_ctl);
}
}
break;
case DC_RESTORE_HEADER:
{
dc_backup_ctl *back = data;
if ( (in_len == sizeof(dc_backup_ctl)) && (out_len == in_len) )
{
back->device[MAX_DEVICE] = 0;
back->status = dc_restore_header(back->device, &back->pass, back->backup);
/* prevent leaks */
burn(&back->pass, sizeof(back->pass));
status = STATUS_SUCCESS;
length = sizeof(dc_backup_ctl);
}
}
break;
default:
{
dc_ioctl *dctl = data;
if ( (in_len == sizeof(dc_ioctl)) && (out_len == sizeof(dc_ioctl)) )
{
/* limit null-terminated string length */
dctl->device[MAX_DEVICE] = 0;
/* process IOCTL */
dctl->status = dc_ioctl_process(irp_sp->Parameters.DeviceIoControl.IoControlCode, dctl);
/* prevent leaks */
burn(&dctl->passw1, sizeof(dctl->passw1));
burn(&dctl->passw2, sizeof(dctl->passw2));
status = STATUS_SUCCESS;
length = sizeof(dc_ioctl);
}
}
break;
}
return dc_complete_irp(irp, status, length);
}
int dc_format_step(wchar_t *dev_name, int wp_mode)
{
dev_hook *hook = NULL;
u8 *buff;
int resl;
u64 offs;
u32 size;
do
{
if ( (hook = dc_find_hook(dev_name)) == NULL ) {
resl = ST_NF_DEVICE; break;
}
wait_object_infinity(&hook->busy_lock);
if ( !(hook->flags & F_FORMATTING) ) {
resl = ST_ERROR; break;
}
offs = hook->tmp_size;
buff = hook->tmp_buff;
size = d32(min(hook->dsk_size - offs, ENC_BLOCK_SIZE));
if (size == 0) {
dc_format_done(dev_name);
resl = ST_FINISHED; break;
}
if (hook->crypt.wp_mode != wp_mode)
{
dc_wipe_free(&hook->wp_ctx);
resl = dc_wipe_init(
&hook->wp_ctx, hook, ENC_BLOCK_SIZE, wp_mode, hook->crypt.cipher_id);
if (resl == ST_OK) {
hook->crypt.wp_mode = d8(wp_mode);
} else {
dc_wipe_init(&hook->wp_ctx, hook, ENC_BLOCK_SIZE, WP_NONE, 0);
hook->crypt.wp_mode = WP_NONE;
}
}
/* wipe sectors */
dc_wipe_process(&hook->wp_ctx, offs, size);
/* zero buffer */
memset(buff, 0, size);
/* encrypt buffer with temporary key */
cp_fast_encrypt(buff, buff, size, offs, hook->tmp_key);
/* write pseudo-random data to device */
resl = io_hook_rw(hook, buff, size, offs, 0);
if ( (resl == ST_OK) || (resl == ST_RW_ERR) ) {
hook->tmp_size += size;
}
if ( (resl == ST_MEDIA_CHANGED) || (resl == ST_NO_MEDIA) ) {
dc_process_unmount(hook, MF_NOFSCTL); resl = ST_FINISHED;
}
} while (0);
if (hook != NULL) {
KeReleaseMutex(&hook->busy_lock, FALSE);
dc_deref_hook(hook);
}
return resl;
}
int dc_format_start(wchar_t *dev_name, dc_pass *password, crypt_info *crypt)
{
IO_STATUS_BLOCK iosb;
NTSTATUS status;
dc_header *header = NULL;
dev_hook *hook = NULL;
xts_key *tmp_key = NULL;
HANDLE h_dev = NULL;
u8 *buff = NULL;
int w_init = 0;
u8 key_buf[32];
int resl;
DbgMsg("dc_format_start\n");
do
{
if ( (hook = dc_find_hook(dev_name)) == NULL ) {
resl = ST_NF_DEVICE; break;
}
wait_object_infinity(&hook->busy_lock);
if (hook->flags & (F_ENABLED | F_UNSUPRT | F_DISABLE | F_CDROM)) {
resl = ST_ERROR; break;
}
/* verify encryption info */
if ( (crypt->cipher_id >= CF_CIPHERS_NUM) || (crypt->wp_mode >= WP_NUM) ) {
resl = ST_ERROR; break;
}
/* get device params */
if ( (resl = dc_fill_disk_info(hook)) != ST_OK ) {
break;
}
if ( (header = mm_alloc(sizeof(dc_header), MEM_SECURE)) == NULL ) {
resl = ST_NOMEM; break;
}
if ( (buff = mm_alloc(ENC_BLOCK_SIZE, 0)) == NULL ) {
resl = ST_NOMEM; break;
}
if ( (tmp_key = mm_alloc(sizeof(xts_key), MEM_SECURE)) == NULL ) {
resl = ST_NOMEM; break;
}
/* temporary disable automounting */
hook->flags |= F_NO_AUTO_MOUNT;
/* open volume device */
if ( (h_dev = io_open_device(hook->dev_name)) == NULL ) {
resl = ST_LOCK_ERR; break;
}
/* lock volume */
status = ZwFsControlFile(
h_dev, NULL, NULL, NULL, &iosb, FSCTL_LOCK_VOLUME, NULL, 0, NULL, 0);
if (NT_SUCCESS(status) == FALSE) {
resl = ST_LOCK_ERR; break;
}
/* enable automounting */
hook->flags &= ~F_NO_AUTO_MOUNT;
/* set encryption info */
hook->crypt = *crypt;
/* init data wiping */
resl = dc_wipe_init(
&hook->wp_ctx, hook, ENC_BLOCK_SIZE, crypt->wp_mode, crypt->cipher_id);
if (resl == ST_OK) {
w_init = 1;
} else break;
/* wipe first sectors */
dc_wipe_process(&hook->wp_ctx, 0, hook->head_len);
/* create random temporary key */
cp_rand_bytes(key_buf, sizeof(key_buf));
xts_set_key(key_buf, crypt->cipher_id, tmp_key);
/* create volume header */
memset(header, 0, sizeof(dc_header));
cp_rand_bytes(pv(header->salt), PKCS5_SALT_SIZE);
cp_rand_bytes(pv(&header->disk_id), sizeof(u32));
cp_rand_bytes(pv(header->key_1), DISKKEY_SIZE);
header->sign = DC_VOLM_SIGN;
header->version = DC_HDR_VERSION;
header->alg_1 = crypt->cipher_id;
/* write volume header */
if ( (resl = io_write_header(hook, header, NULL, password)) != ST_OK ) {
break;
}
/* mount device */
if ( (resl = dc_mount_device(dev_name, password, 0)) != ST_OK ) {
break;
}
/* set hook fields */
hook->flags |= F_FORMATTING;
hook->tmp_size = hook->head_len;
hook->tmp_buff = buff;
hook->tmp_key = tmp_key;
} while (0);
if ( (resl != ST_OK) )
{
if (w_init != 0) {
dc_wipe_free(&hook->wp_ctx);
}
if (buff != NULL) { mm_free(buff); }
if (tmp_key != NULL) { mm_free(tmp_key); }
}
if (header != NULL) {
mm_free(header);
}
if (hook != NULL) {
KeReleaseMutex(&hook->busy_lock, FALSE);
dc_deref_hook(hook);
}
/* prevent leaks */
burn(key_buf, sizeof(key_buf));
if (h_dev != NULL)
{
if (resl != ST_LOCK_ERR)
{
/* dismount volume */
ZwFsControlFile(
h_dev, NULL, NULL, NULL, &iosb, FSCTL_DISMOUNT_VOLUME, NULL, 0, NULL, 0);
/* unlock volume */
ZwFsControlFile(
h_dev, NULL, NULL, NULL, &iosb, FSCTL_UNLOCK_VOLUME, NULL, 0, NULL, 0);
}
/* close device */
ZwClose(h_dev);
}
return resl;
}
NTSTATUS dc_drv_control_irp(PDEVICE_OBJECT dev_obj, PIRP irp)
{
PIO_STACK_LOCATION irp_sp = IoGetCurrentIrpStackLocation(irp);
NTSTATUS status = STATUS_INVALID_DEVICE_REQUEST;
void *data = irp->AssociatedIrp.SystemBuffer;
u32 in_len = irp_sp->Parameters.DeviceIoControl.InputBufferLength;
u32 out_len = irp_sp->Parameters.DeviceIoControl.OutputBufferLength;
u32 code = irp_sp->Parameters.DeviceIoControl.IoControlCode;
u32 bytes = 0;
switch (code)
{
case DC_GET_VERSION:
{
if (out_len == sizeof(u32))
{
p32(data)[0] = DC_DRIVER_VER;
bytes = sizeof(u32);
status = STATUS_SUCCESS;
}
}
break;
case DC_CTL_CLEAR_PASS:
{
dc_clean_pass_cache();
status = STATUS_SUCCESS;
}
break;
case DC_CTL_STATUS:
{
dc_ioctl *dctl = data;
dc_status *stat = data;
dev_hook *hook;
if ( (in_len == sizeof(dc_ioctl)) && (out_len == sizeof(dc_status)) )
{
dctl->device[MAX_DEVICE] = 0;
if (hook = dc_find_hook(dctl->device))
{
if (hook->pdo_dev->Flags & DO_SYSTEM_BOOT_PARTITION) {
hook->flags |= F_SYSTEM;
}
dc_get_mount_point(hook, stat->mnt_point, sizeof(stat->mnt_point));
stat->crypt = hook->crypt;
stat->dsk_size = hook->dsk_size;
stat->tmp_size = hook->tmp_size;
stat->flags = hook->flags;
stat->mnt_flags = hook->mnt_flags;
stat->disk_id = hook->disk_id;
stat->paging_count = hook->paging_count;
stat->vf_version = hook->vf_version;
status = STATUS_SUCCESS;
bytes = sizeof(dc_status);
dc_deref_hook(hook);
}
}
}
break;
case DC_CTL_ADD_SEED:
{
if (in_len != 0)
{
cp_rand_add_seed(data, in_len);
status = STATUS_SUCCESS;
/* prevent leaks */
burn(data, in_len);
}
}
break;
case DC_CTL_GET_RAND:
{
dc_rand_ctl *rctl = data;
if (in_len == sizeof(dc_rand_ctl))
{
__try
{
ProbeForWrite(rctl->buff, rctl->size, sizeof(u8));
if (cp_rand_bytes(rctl->buff, rctl->size) != 0) {
status = STATUS_SUCCESS;
}
}
__except(EXCEPTION_EXECUTE_HANDLER) {
status = GetExceptionCode();
}
}
}
break;
case DC_CTL_BENCHMARK:
{
if ( (in_len == sizeof(int)) && (out_len == sizeof(dc_bench_info)) )
{
if (dc_k_benchmark(p32(data)[0], pv(data)) == ST_OK) {
status = STATUS_SUCCESS;
bytes = sizeof(dc_bench_info);
}
}
}
break;
case DC_CTL_BSOD:
{
lock_inc(&dc_dump_disable);
dc_clean_pass_cache();
mm_unlock_user_memory(NULL, NULL);
dc_clean_keys();
KeBugCheck(IRQL_NOT_LESS_OR_EQUAL);
}
break;
case DC_CTL_GET_CONF:
{
dc_conf *conf = data;
if (out_len == sizeof(dc_conf)) {
conf->conf_flags = dc_conf_flags;
conf->load_flags = dc_load_flags;
status = STATUS_SUCCESS;
bytes = sizeof(dc_conf);
}
}
break;
case DC_CTL_SET_CONF:
{
dc_conf *conf = data;
if (in_len == sizeof(dc_conf))
{
dc_conf_flags = conf->conf_flags;
status = STATUS_SUCCESS;
if ( !(dc_conf_flags & CONF_CACHE_PASSWORD) ) {
dc_clean_pass_cache();
}
dc_init_encryption();
}
}
break;
case DC_CTL_LOCK_MEM:
{
PEPROCESS process = IoGetRequestorProcess(irp);
dc_lock_ctl *smem = data;
if ( (process != NULL) && (in_len == sizeof(dc_lock_ctl)) && (out_len == in_len) )
{
smem->resl = mm_lock_user_memory(smem->data, smem->size, process);
status = STATUS_SUCCESS; bytes = sizeof(dc_lock_ctl);
}
}
break;
case DC_CTL_UNLOCK_MEM:
{
PEPROCESS process = IoGetRequestorProcess(irp);
dc_lock_ctl *smem = data;
if ( (process != NULL) && (in_len == sizeof(dc_lock_ctl)) && (out_len == in_len) )
{
mm_unlock_user_memory(smem->data, process);
status = STATUS_SUCCESS; bytes = sizeof(dc_lock_ctl);
smem->resl = ST_OK;
}
}
break;
case DC_BACKUP_HEADER:
{
dc_backup_ctl *back = data;
if ( (in_len == sizeof(dc_backup_ctl)) && (out_len == in_len) )
{
back->device[MAX_DEVICE] = 0;
back->status = dc_backup_header(back->device, &back->pass, back->backup);
/* prevent leaks */
burn(&back->pass, sizeof(back->pass));
status = STATUS_SUCCESS;
bytes = sizeof(dc_backup_ctl);
}
}
break;
case DC_RESTORE_HEADER:
{
dc_backup_ctl *back = data;
if ( (in_len == sizeof(dc_backup_ctl)) && (out_len == in_len) )
{
back->device[MAX_DEVICE] = 0;
back->status = dc_restore_header(back->device, &back->pass, back->backup);
/* prevent leaks */
burn(&back->pass, sizeof(back->pass));
status = STATUS_SUCCESS;
bytes = sizeof(dc_backup_ctl);
}
}
break;
default:
{
dc_ioctl *dctl = data;
if ( (in_len == sizeof(dc_ioctl)) && (out_len == sizeof(dc_ioctl)) )
{
/* limit null-terminated string length */
dctl->device[MAX_DEVICE] = 0;
/* process IOCTL */
dctl->status = dc_ioctl_process(code, dctl);
/* prevent leaks */
burn(&dctl->passw1, sizeof(dctl->passw1));
burn(&dctl->passw2, sizeof(dctl->passw2));
status = STATUS_SUCCESS;
bytes = sizeof(dc_ioctl);
}
}
break;
}
