driverinterface.c

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

    fileHandle = INVALID_HANDLE_VALUE;
    if (driver_GetVolumeInfo_Mountpoint(mountpoint, &volumeDetails))
        {
        DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Trying %ls...\n"), volumeDetails.DeviceName));
        fileHandle = driver_GetDeviceHandle(volumeDetails.DeviceName);
        SecZeroMemory(&volumeDetails, sizeof(volumeDetails));
        }

    if (fileHandle == INVALID_HANDLE_VALUE) 
        {
        DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("Call to driver_GetDeviceHandle failed to get valid handle.\n")));
        }
    else
        { 
        DIOCBuffer.UserSpaceDeviceHandle = 0;
        if (!(DeviceIoControl(
                                  fileHandle, 
                                  IOCTL_FREEOTFE_USER_DEV_HANDLE_GET, 
                                  NULL, 
                                  0, 
                                  &DIOCBuffer, 
                                  sizeof(DIOCBuffer), 
                                  &bytesReturned,
                                  NULL
                                )))
            {
            DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("DIOC returned FALSE\n")));
            }
        else if (bytesReturned != sizeof(DIOCBuffer))
            {
            DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("DIOC returned too-small buffer\n")));
            }
        else
            {
            DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Userspace handle obtained from driver: %0.8x\n"), DIOCBuffer.UserSpaceDeviceHandle));
            retval = DIOCBuffer.UserSpaceDeviceHandle;
            }

        SecZeroMemory(&DIOCBuffer, sizeof(DIOCBuffer));

        CloseHandle(fileHandle);
        }

    DEBUGOUTGUI(DEBUGLEV_EXIT, (TEXT("driver_GetUserAppHandle\n")));
    return retval;
}


// =========================================================================
// Set handle returned by ActivateDeviceEx on device's internal store
BOOL driver_SetUserAppHandle(WCHAR* mountpoint, HANDLE hActiveDevice)
{
    BOOL retval = FALSE;
    DIOC_USER_DEVICE_HANDLE DIOCBuffer;
    DWORD bytesReturned;
    HANDLE fileHandle;
    DIOC_DISK_DEVICE_STATUS volumeDetails;

    DEBUGOUTGUI(DEBUGLEV_ENTER, (TEXT("driver_SetUserAppHandle\n")));
    DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Userspace handle to set: %0.8x\n"), hActiveDevice));

    DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Trying %ls...\n"), volumeDetails.DeviceName));
    fileHandle = INVALID_HANDLE_VALUE;
    if (driver_GetVolumeInfo_Mountpoint(mountpoint, &volumeDetails))
        {
        fileHandle = driver_GetDeviceHandle(volumeDetails.DeviceName);
        SecZeroMemory(&volumeDetails, sizeof(volumeDetails));
        }

    if (fileHandle == INVALID_HANDLE_VALUE) 
        {
        DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("Call to driver_GetDeviceHandle failed to get valid handle.\n")));
        }
    else
        {
        DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Handle to opened device: 0x%0.8x\n"), fileHandle));
        DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Active device handle   : 0x%0.8x\n"), hActiveDevice));
        DIOCBuffer.UserSpaceDeviceHandle = hActiveDevice;
        retval = DeviceIoControl(
                                  fileHandle, 
                                  IOCTL_FREEOTFE_USER_DEV_HANDLE_SET, 
                                  &DIOCBuffer, 
                                  sizeof(DIOCBuffer), 
                                  NULL, 
                                  0, 
                                  &bytesReturned,
                                  NULL
                                );

        SecZeroMemory(&DIOCBuffer, sizeof(DIOCBuffer));

        if (retval)
            {
            DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Userspace handle passed successfully to device\n")));
            }
        else
            {
            DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("Unable to pass userspace handle on device\n")));
            }

        CloseHandle(fileHandle);
        }

    DEBUGOUTGUI(DEBUGLEV_EXIT, (TEXT("driver_SetUserAppHandle\n")));
    return retval;
}


// =========================================================================
// Set handle returned by ActivateDeviceEx on device's internal store
BOOL driver_SetForceDismounts(WCHAR* mountpoint, BOOL force)
{
    BOOL retval = FALSE;
    DIOC_FORCE_DISMOUNTS DIOCBuffer;
    DWORD bytesReturned;
    HANDLE fileHandle;
    DIOC_DISK_DEVICE_STATUS volumeDetails;

    DEBUGOUTGUI(DEBUGLEV_ENTER, (TEXT("driver_SetForceDismounts\n")));

    DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Trying %ls...\n"), volumeDetails.DeviceName));
    fileHandle = INVALID_HANDLE_VALUE;
    if (driver_GetVolumeInfo_Mountpoint(mountpoint, &volumeDetails))
        {
        fileHandle = driver_GetDeviceHandle(volumeDetails.DeviceName);
        SecZeroMemory(&volumeDetails, sizeof(volumeDetails));
        }

    if (fileHandle == INVALID_HANDLE_VALUE) 
        {
        DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("Call to driver_GetDeviceHandle failed to get valid handle.\n")));
        }
    else
        {
        DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Handle to opened device: 0x%0.8x\n"), fileHandle));
        DIOCBuffer.ForceDismounts = force;
        retval = DeviceIoControl(
                                  fileHandle, 
                                  IOCTL_FREEOTFE_SET_FORCE_DISMOUNT, 
                                  &DIOCBuffer, 
                                  sizeof(DIOCBuffer), 
                                  NULL, 
                                  0, 
                                  &bytesReturned,
                                  NULL
                                );

        SecZeroMemory(&DIOCBuffer, sizeof(DIOCBuffer));

        if (retval)
            {
            DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Set force/non-force dismount DIOC called successfully\n")));
            }
        else
            {
            DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("Unable to set force/non-force dismount on driver\n")));
            }

        CloseHandle(fileHandle);
        }

    DEBUGOUTGUI(DEBUGLEV_EXIT, (TEXT("driver_SetForceDismounts\n")));
    return retval;
}


// =========================================================================
BOOL driver_Dismount(WCHAR* mountpoint, BOOL force)
{
    BOOL retval = FALSE;
    DIOC_DISK_DEVICE_STATUS volumeDetails;
  
    DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Dismount: %ls\n"), mountpoint));
    if (force)
        {
        DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("FORCED DISMOUNT\n")));
        }
    
    if (driver_GetVolumeInfo_Mountpoint(mountpoint, &volumeDetails)) 
        {
        if (volumeDetails.ActivateDeviceHandle != NULL)
            {
            driver_SetForceDismounts(mountpoint, force);
            retval = DeactivateDevice(volumeDetails.ActivateDeviceHandle);

            if (retval)
                {
                DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Dismount OK\n")));
                }
            else
                {
                DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Dismount FAILED\n")));
                }
            }
        }

    // If we could deactivate the device (if applicable), proceed to remove
    // the registry entries...
    if (retval || force) 
        {
        DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Deleting registry entries...\n")));
        retval = RegDetailsDeleteAllByKey(volumeDetails.BuiltinKey, TRUE);
        }

    SecZeroMemory(&volumeDetails, sizeof(volumeDetails));

    DEBUGOUTGUI(DEBUGLEV_EXIT, (TEXT("driver_Dismount\n")));
    return retval;
}


// =========================================================================
BOOL driver_DismountAll(BOOL force)
{
    BOOL retval = FALSE;
    BOOL allOK;
    int i;
    int cnt = 0;
    REGDETAILS_ACTIVE* mountedDetails = NULL;
    int detailsByteSize;

    DEBUGOUTGUI(DEBUGLEV_ENTER, (TEXT("driver_DismountAll\n")));

    detailsByteSize = 0;

    allOK = driver_GetMountedCount(&cnt);
    if (allOK)
        {
        detailsByteSize = (cnt * sizeof(*mountedDetails)); 
        mountedDetails = malloc(detailsByteSize);
        if (mountedDetails == NULL)
            {
            DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("Unable to malloc memory for all volumes mounted\n")));
            allOK = FALSE;
            }
        else
            {
            allOK = driver_MountedVolumes(detailsByteSize, mountedDetails);
            if (!(allOK))
                {
                SecZeroAndFreeMemory(mountedDetails, detailsByteSize);
                mountedDetails = NULL;
                }
            }
        }

    if (allOK) 
        {
        retval = TRUE;
        for(i = 0; i < cnt; i++)
            {
            allOK = driver_Dismount(mountedDetails[i].Mountpoint, force);
            if (!(allOK))
                {
                DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("Unable dismount: %ls\n"), mountedDetails[i].Mountpoint));
                }

            retval = (retval && allOK);
            }
        }

    RegDetailsFreeAllActive(cnt, mountedDetails);
    SecZeroAndFreeMemory(mountedDetails, detailsByteSize);

    DEBUGOUTGUI(DEBUGLEV_EXIT, (TEXT("driver_DismountAll\n")));
    return retval;
}


// =========================================================================
void driver_PrettyprintSectorIVGenMethod(
    SECTOR_IV_GEN_METHOD sectorIVGenMethod, 
    WCHAR* buffer,
    int bufferSize  // In bytes
)
{
    switch (sectorIVGenMethod)
        {
        case SCTRIVGEN_NONE:
            {
            wcsncpy(
                    buffer,
                    TEXT("Null IV"),
                    (bufferSize / sizeof(buffer[0]))
                   );
            break;
            }

        case SCTRIVGEN_32BIT_SECTOR_ID:
            {
            wcsncpy(
                    buffer,
                    TEXT("32 bit sector ID"),
                    (bufferSize / sizeof(buffer[0]))
                   );
            break;
            }

        case SCTRIVGEN_64BIT_SECTOR_ID:
            {
            wcsncpy(
                    buffer,
                    TEXT("64 bit sector ID"),
                    (bufferSize / sizeof(buffer[0]))
                   );
            break;
            }

        case SCTRIVGEN_HASH_32BIT_SECTOR_ID:
            {
            wcsncpy(
                    buffer,
                    TEXT("Hashed 32 bit sector ID"),
                    (bufferSize / sizeof(buffer[0]))
                   );
            break;
            }

        case SCTRIVGEN_HASH_64BIT_SECTOR_ID:
            {
            wcsncpy(
                    buffer,
                    TEXT("Hashed 64 bit sector ID"),
                    (bufferSize / sizeof(buffer[0]))
                   );
            break;
            }

        case SCTRIVGEN_ESSIV:
            {
            wcsncpy(
                    buffer,
                    TEXT("ESSIV"),
                    (bufferSize / sizeof(buffer[0]))
                   );
            break;
            }

        default:
            {
            wcsncpy(
                    buffer,
                    STR_UNKNOWN,
                    (bufferSize / sizeof(buffer[0]))
                   );
            break;
            }
        }
}


// =========================================================================
void driver_PrettyprintKDFAlgorithm(
    KDF_ALGORITHM algorithm, 
    WCHAR* buffer,
    int bufferSize  // In bytes
)
{
    switch (algorithm)
        {
        case KDF_HASH:
            {
            wcsncpy(
                    buffer,
                    TEXT("Hash"),
                    (bufferSize / sizeof(buffer[0]))
                   );
            break;
            }

        case KDF_PBKDF2:
            {
            wcsncpy(
                    buffer,
                    TEXT("PKCS #5 PBKDF2 (HMAC)"),
                    (bufferSize / sizeof(buffer[0]))
                   );
            break;
            }

        default:
            {
            wcsncpy(
                    buffer,
                    STR_UNKNOWN,
                    (bufferSize / sizeof(buffer[0]))
                   );
            break;
            }
        }
}


// =========================================================================
void driver_PrettyprintMACAlgorithm(
    MAC_ALGORITHM algorithm, 
    WCHAR* buffer,
    int bufferSize  // In bytes
)
{
    switch (algorithm)
        {
        case MAC_HASH:
            {
            wcsncpy(
                    buffer,
                    TEXT("Hash"),
                    (bufferSize / sizeof(buffer[0]))
                   );
            break;
            }

        case MAC_HMAC:
            {
            wcsncpy(
                    buffer,
                    TEXT("HMAC"),
                    (bufferSize / sizeof(buffer[0]))
                   );
            break;
            }

        default:
            {
            wcsncpy(
                    buffer,
                    STR_UNKNOWN,
                    (bufferSize / sizeof(buffer[0]))
                   );
            break;
            }
        }
}


// =========================================================================
// =========================================================================