freeotfe4pda.c

文件驱动加密,功能强大,可产生加密分区,支持AES,MD2,MD4,MD5MD2, MD4, MD5, RIPEMD-128, RIPEMD-160, SHA-1, SHA-224, SHA-256,

    // Simulated disk geometry
    devContext->PartitionSize.QuadPart = 0; 
    SecZeroMemory(&devContext->DiskGeometry, sizeof(devContext->DiskGeometry));
    devContext->DiskSize.QuadPart = 0;  

    // The "sector size" in which blocks should actually be read/written to the volume
    // file/partition
    devContext->FileSectorSize = 0;
    devContext->DataOffsetModVirtualSectorSize = 0; 

    // Encryption block size
    devContext->EncryptionBlockSize = 0;

    // Readonly flag
    devContext->ReadOnly = TRUE;

    // Storage device info (i.e. the type of device emulated)
    SecZeroMemory(&devContext->StorageDeviceInfo, sizeof(devContext->StorageDeviceInfo));

    // Prevent media removal; for removable disks only
    devContext->PreventMediaRemoval = TRUE; 

    // -----
	// IV Hash device ID
    FreeDeviceDetailsHash(&(devContext->IVHash));

    // -----
	// IV cypher device ID
    FreeDeviceDetailsCypher(&(devContext->IVCypher));

    // -----
	// Main cypher device ID
    FreeDeviceDetailsCypher(&(devContext->MainCypher));

    // -----
    // Key to be used for encryption/decryption
    SecZeroAndFreeMemory(
                         devContext->MasterKey, 
                         (devContext->MasterKeyLength / 8)
                        );
    SecZeroAndFreeMemory(
                         devContext->MasterKeyASCII, 
                         ((devContext->MasterKeyLength / 8) * 2)
                        );
    devContext->MasterKeyLength = 0;

    // Key to be used for ESSIV generation (*if* *required*)
    SecZeroAndFreeMemory(
                         devContext->ESSIVKey, 
                         (devContext->ESSIVKeyLength / 8)
                        );
    SecZeroAndFreeMemory(
                         devContext->ESSIVKeyASCII, 
                         ((devContext->ESSIVKeyLength / 8) * 2)
                        );
    devContext->ESSIVKeyLength = 0;

    // Volume IV to be used to encrypt/decrypt each sector
    SecZeroAndFreeMemory(
                         devContext->VolumeIV, 
                         (devContext->VolumeIVLength / 8)
                        );
    devContext->VolumeIVLength = 0;

    // Various flags
    devContext->VolumeFlags = 0;

    // Sector IV generation method
    devContext->SectorIVGenMethod = SCTRIVGEN_UNKNOWN;

    // Metadata
    SecZeroAndFreeMemory(devContext->MetaData, devContext->MetaDataLength);
    devContext->MetaDataLength = 0;
}


// =========================================================================
// Determine the max size of a partition
// DeviceName - The device name of the partition
BOOL
GetMaxSizePartition(
    IN  WCHAR* DeviceName,
    OUT PLARGE_INTEGER MaxSize
)
{
    BOOL retval = FALSE;

    DEBUGOUTMAINDRV(DEBUGLEV_ENTER, (TEXT("GetMaxSizePartition\n")));

    DEBUGOUTMAINDRV(DEBUGLEV_ENTER, (TEXT("!!!!! GetMaxSizePartition NOT YET IMPLEMENTED !!!!!\n")));
    DEBUGOUTMAINDRV(DEBUGLEV_ENTER, (TEXT("!!!!! GetMaxSizePartition NOT YET IMPLEMENTED !!!!!\n")));
    DEBUGOUTMAINDRV(DEBUGLEV_ENTER, (TEXT("!!!!! GetMaxSizePartition NOT YET IMPLEMENTED !!!!!\n")));
    DEBUGOUTMAINDRV(DEBUGLEV_ENTER, (TEXT("!!!!! GetMaxSizePartition NOT YET IMPLEMENTED !!!!!\n")));
    DEBUGOUTMAINDRV(DEBUGLEV_ENTER, (TEXT("!!!!! GetMaxSizePartition NOT YET IMPLEMENTED !!!!!\n")));
/*
xxx - not yet implemented

Use:

    HANDLE WINAPI OpenPartition(
  HANDLE hStore,
  LPCTSTR szPartitionName
);

    BOOL WINAPI GetPartitionInfo(
  HANDLE hPartition,
  PPARTINFO pPartInfo
);

    BOOL CloseHandle( 
  HANDLE hObject
); 
*/

    DEBUGOUTMAINDRV(DEBUGLEV_EXIT, (TEXT("GetMaxSizePartition\n")));
    return retval;
}


// =========================================================================
BOOL DSK_Deinit(
    DWORD hDevice
)
{
    BOOL retval = FALSE;
	DEVICE_CONTEXT* devContext;

    DEBUGOUTMAINDRV(DEBUGLEV_ENTER, (TEXT("DSK_Deinit\n")));
    DEBUGOUTMAINDRV(DEBUGLEV_INFO, (TEXT("Device handle: 0x%0.8x\n"), hDevice));

    devContext = contextMgrDevice_DeleteDevice(hDevice);
    if (devContext == NULL)
        {
        DEBUGOUTMAINDRV(DEBUGLEV_ERROR, (TEXT("Unable to delete from device list\n")));
        // Note: Can get to here if there are handles open on the device
        // Unable to do anything...
        // Note: Device manager appears to ignore the return value from this
        //       function?!
        }
    else
        {
        DEBUGOUTMAINDRV(DEBUGLEV_INFO, (TEXT("Removing registry active details...\n")));
        RegDetailsFree(NULL, NULL, &devContext->RegdetailsActive);

        // Note: This will also close the file handle
        DEBUGOUTMAINDRV(DEBUGLEV_INFO, (TEXT("Overwriting device context...\n")));
        OverwriteDeviceSensitive(devContext);

        DEBUGOUTMAINDRV(DEBUGLEV_INFO, (TEXT("Freeing device context...\n")));
        SecZeroAndFreeMemory(devContext, sizeof(*devContext));

        retval = TRUE;
        }

    // Revert force dismounts (this may also be getting used by open file
    // handles, etc)
    G_contextMgrForceDismounts = FALSE;

    DEBUGOUTMAINDRV(DEBUGLEV_EXIT, (TEXT("DSK_Deinit\n")));
    return retval;
}


// =========================================================================
DWORD DSK_Open(
    DWORD hDevice,
    DWORD AccessCode,
    DWORD ShareMode 
)
{
    DWORD retval = 0;  // Zero indicates device can't be opened
	DEVICE_CONTEXT* devContext;
    DEVICE_LIST_ITEM* listItemDevice;

    DEBUGOUTMAINDRV(DEBUGLEV_ENTER, (TEXT("DSK_Open\n")));

    listItemDevice = contextMgrDevice_GetDevice(hDevice, &devContext);
    if (devContext == NULL)
        {
        DEBUGOUTMAINDRV(DEBUGLEV_INFO, (TEXT("Unable to get device: %0.8x\n"), hDevice));
        }
    else
        {
        retval = contextMgrOpen_AddOpenContext(hDevice);
        }
    contextMgrDevice_ReleaseDevice(listItemDevice);

    DEBUGOUTMAINDRV(DEBUGLEV_INFO, (TEXT("Open handle returned: 0x%0.8x\n"), retval));
    DEBUGOUTMAINDRV(DEBUGLEV_EXIT, (TEXT("DSK_Open\n")));
    return retval;
}


// =========================================================================
BOOL DSK_Close(
    DWORD hOpen 
)
{
    BOOL retval = FALSE;

    DEBUGOUTMAINDRV(DEBUGLEV_ENTER, (TEXT("DSK_Close\n")));
    DEBUGOUTMAINDRV(DEBUGLEV_INFO, (TEXT("Open handle: 0x%0.8x\n"), hOpen));

    contextMgrOpen_DeleteOpenContext(hOpen);

    DEBUGOUTMAINDRV(DEBUGLEV_EXIT, (TEXT("DSK_Close\n")));
    return retval;
}


// =========================================================================
BOOL DSK_IOControl(
    DWORD hOpen,
    DWORD dwCode,
    PBYTE pBufIn,
    DWORD dwLenIn,
    PBYTE pBufOut,
    DWORD dwLenOut,
    PDWORD pdwActualOut
)
{
    BOOL retval = FALSE;
	DEVICE_CONTEXT* devContext;
    OPEN_LIST_ITEM* openDetails;
    DWORD hDevice = 0;
    DWORD outputBufferUsed = 0;
    DEVICE_LIST_ITEM* listItemDevice = NULL;

    devContext = NULL;
    openDetails = contextMgrOpen_GetOpenContext(hOpen);
    if (openDetails == NULL)
        {
        DEBUGOUTMAINDRV(DEBUGLEV_INFO, (TEXT("Unable to get open handle details: %0.8x\n"), hOpen));
        }
    else
        {
        hDevice = openDetails->hDevice;
        listItemDevice = contextMgrDevice_GetDevice(hDevice, &devContext);
        if (devContext == NULL)
            {
            DEBUGOUTMAINDRV(DEBUGLEV_INFO, (TEXT("Unable to get device: %0.8x\n"), hDevice));
            }
        }

    if (devContext != NULL)
        {
        DEBUGOUTMAINDRV(DEBUGLEV_ENTER, (TEXT("DSK_IOControl\n")));
        DEBUGOUTMAINDRV(DEBUGLEV_INFO, (TEXT("Device handle : 0x%0.8x\n"), openDetails->hDevice));
        DEBUGOUTMAINDRV(DEBUGLEV_INFO, (TEXT("Open handle   : 0x%0.8x\n"), hOpen));
        DEBUGOUTMAINDRV(DEBUGLEV_INFO, (TEXT("IOControl code: 0x%0.8x\n"), dwCode));
        DEBUGOUTMAINDRV(DEBUGLEV_INFO, (TEXT("IN buffer     : 0x%0.8x\n"), pBufIn));
        DEBUGOUTMAINDRV(DEBUGLEV_INFO, (TEXT("IN size       : %d\n"), dwLenIn));
        DEBUGOUTMAINDRV(DEBUGLEV_INFO, (TEXT("OUT buffer    : 0x%0.8x\n"), pBufOut));
        DEBUGOUTMAINDRV(DEBUGLEV_INFO, (TEXT("OUT size      : %d\n"), dwLenOut));

        if (devContext->Mounted)
            {
            switch (dwCode)
                {
                case IOCTL_DISK_DEVICE_INFO:
                    {
                    retval = IOCTL_Std_DiskDeviceInfo(
                                                      devContext,
                                                      pBufIn,
                                                      dwLenIn,
                                                      &outputBufferUsed 
                                                     );
                    break;
                    }

                case IOCTL_DISK_FORMAT_MEDIA:
                    {
                    retval = IOCTL_Std_DiskFormatMedia(
                                                       devContext,
                                                       &outputBufferUsed 
                                                      );
                    retval = TRUE;
                    break;
                    }

                case DISK_IOCTL_FORMAT_MEDIA:
                    {
                    retval = IOCTL_Std_DiskFormatMedia(
                                                       devContext,
                                                       &outputBufferUsed 
                                                      );
                    break;
                    }

                // WM5.0 and later
                //case IOCTL_DISK_GET_SECTOR_ADDR:
                //    {
                //    // xxx - implement
                //    break;
                //    }

                case IOCTL_DISK_GET_STORAGEID:
                    {
                    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
                    break;
                    // This IOCTL *has* been implemented, but it always returns the
                    // same serial number for *all* volumes.
                    // Not sure what impact that will have; hence disabled for now.
                    retval = IOCTL_Std_DiskGetStorageID(
                                                        devContext,
                                                        pBufOut,
                                                        dwLenOut,
                                                        &outputBufferUsed 
                                                       );
                    break;
                    }

                case DISK_IOCTL_GETINFO:
                    {
                    // Note that IOCTL_DISK_GETINFO and DISK_IOCTL_GETINFO invert
                    // the in/out buffers
                    retval = IOCTL_Std_DiskGetInfo(
                                                   devContext,
                                                   pBufIn,
                                                   dwLenIn,
                                                   &outputBufferUsed 
                                                  );
                    break;
                    }

                case IOCTL_DISK_GETINFO:
                    {
                    // Note that IOCTL_DISK_GETINFO and DISK_IOCTL_GETINFO invert
                    // the in/out buffers
                    retval = IOCTL_Std_DiskGetInfo(
                                                   devContext,
                                                   pBufOut,
                                                   dwLenOut,
                                                   &outputBufferUsed 
                                                  );
                    break;
                    }

                case DISK_IOCTL_INITIALIZED:
                    {
                    retval = IOCTL_Std_DiskInitialized(devContext, &outputBufferUsed);
                    break;
                    }

                case IOCTL_DISK_GETNAME:
                case DISK_IOCTL_GETNAME: