driverinterfacetwo.c

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

                                 ) == ERROR_SUCCESS)
            {
            if ((int)DIOCOut->MACLength >= *tBits)
                {                
                *MACOut = malloc((DIOCOut->MACLength / 8));
                if (*MACOut == NULL)
                    {
                    DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("Unable to malloc MAC return buffer\n")));
                    }
                else
                    {
                    *tBits = DIOCOut->MACLength;                
                    memcpy(*MACOut, DIOCOut->MAC, (DIOCOut->MACLength / 8));
                    retval = TRUE;
                    }
                }
            }
        }

    
    SecZeroAndFreeMemory(DIOCIn, DIOCInSize);
    SecZeroAndFreeMemory(DIOCOut, DIOCOutSize);

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


// =========================================================================
// ReadNotWrite - Set to TRUE to read, FALSE to write
BOOL _driver_ReadWriteRawCDB(
    WCHAR* Filename,
    LARGE_INTEGER Offset,
    BOOL ReadNotWrite,
    FREEOTFEBYTE (*CDB)[CRITICAL_DATA_LENGTH / 8]
)
{
    BOOL retval = FALSE;
    DWORD bytesTransferred;
    HANDLE fileHandle;
    BOOL filePosOK;
    DWORD newFilePos;
    DWORD dwDesiredAccess;

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


    if (ReadNotWrite) 
        {
        dwDesiredAccess = GENERIC_READ;
        DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Read data from file:\n")));
        }
    else
        {
        dwDesiredAccess = GENERIC_WRITE;
        DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Write data to file:\n")));
        }
    DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("  Filename: %ls\n"), Filename));
    DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("  Offset  : 0x%0.8x\n"), Offset.QuadPart));

    fileHandle = CreateFile(
                            Filename,
                            dwDesiredAccess,  
                            (FILE_SHARE_READ | FILE_SHARE_WRITE),  
                            NULL,
                            OPEN_EXISTING, 
                            FILE_ATTRIBUTE_NORMAL, 
                            NULL
                           ); 
    if (fileHandle == INVALID_HANDLE_VALUE) 
        { 
        DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("Unable to open volume file\n")));
        } 
    else
        {
        newFilePos = SetFilePointer( 
                                    fileHandle, 
                                    Offset.LowPart, 
                                    &(Offset.HighPart), 
                                    FILE_BEGIN
                                   );
        filePosOK = TRUE;
        if (newFilePos == FAILED_SETFILEPOINTER) 
            {
            filePosOK = (GetLastError() == NO_ERROR);
            }
        if (filePosOK) 
            {
            if (ReadNotWrite)
                {
                retval = ReadFile( 
                                   fileHandle,
                                   CDB, 
                                   sizeof(*CDB), 
                                   &bytesTransferred, 
                                   NULL
                                  );
                }
            else
                {
                retval = WriteFile( 
                                   fileHandle,
                                   CDB, 
                                   sizeof(*CDB), 
                                   &bytesTransferred, 
                                   NULL
                                  );
                }

            }

        CloseHandle(fileHandle);
        }

    if (retval)
        {
        DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("CDB write OK\n")));
        }
    else
        {
        DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("CDB write FAILED.\n")));
        }
    DEBUGOUTGUI(DEBUGLEV_EXIT, (TEXT("_driver_ReadWriteRawCDB\n")));
    return retval;
}


// =========================================================================
BOOL driver_LoadMainDLL(MODULE_DETAILS_MAIN* DLLDetails)
{
    BOOL retval = TRUE;

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

    // Get library path and filename...
    if (retval)
        {
        DLLDetails->Filename = driver_AllocMainDLLFullFilename(TRUE);
        if (DLLDetails->Filename == NULL)
            {
            retval = FALSE;
            }
        }

    // Load library...
    if (retval)
        {
        DLLDetails->Lib = LoadLibrary(DLLDetails->Filename);
        if (DLLDetails->Lib == NULL)
            {
            DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("FAILED to load library\n")));
            retval = FALSE;
            }
        }

    // Get library function address...
    if (retval)
        {
        DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Getting proc address for: %ls\n"), DLLEXPORT_MAIN_DERIVEKEY));
        DLLDetails->FnDeriveKey = (PMainDLLFnDeriveKey)GetProcAddress(
                                         DLLDetails->Lib,
                                         DLLEXPORT_MAIN_DERIVEKEY
                                        );
        if (DLLDetails->FnDeriveKey == NULL)
            {
            DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("FAILED to get proc address\n")));
            retval = FALSE;
            }

        DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Getting proc address for: %ls\n"), DLLEXPORT_MAIN_MACDATA));
        DLLDetails->FnMACData = (PMainDLLFnMACData)GetProcAddress(
                                         DLLDetails->Lib,
                                         DLLEXPORT_MAIN_MACDATA
                                        );
        if (DLLDetails->FnMACData == NULL)
            {
            DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("FAILED to get proc address\n")));
            retval = FALSE;
            }

        }


    // In case of failure, shutdown any loaded lib, overwrite, and free off...
    if (!(retval))
        {
        driver_UnloadMainDLL(DLLDetails);
        }

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


// =========================================================================
void driver_UnloadMainDLL(MODULE_DETAILS_MAIN* DLLDetails)
{
    if (DLLDetails != NULL)
        {
     	// DLL handle
        if ((DLLDetails->Lib) != NULL)
            {
	        FreeLibrary(DLLDetails->Lib);
            DLLDetails->Lib = NULL;
            }

        driver_FreeMainDLLFullFilename(DLLDetails->Filename);
        }

    SecZeroMemory(DLLDetails, sizeof(*DLLDetails));
}


// =========================================================================
// Note: It is the *callers* responsibility to free of the values returned
BOOL driver_GetAllAlgorithmDriverDetails(
    int* countDriversHash,
    WCHAR*** driverFilenamesHash,
    HASH_DRIVER_INFO*** driverInfoHash,

    int* countDriversCypher,
    WCHAR*** driverFilenamesCypher,
    CYPHER_DRIVER_INFO*** driverInfoCypher
)
{
    BOOL allOK = TRUE;
    int i;
                           
    // Identify all hash drivers...
    // !! WARNING !!
    // IF OPTIMISATION IS TURNED ON, THIS CALL OVERWRITES allOK?!!
    *countDriversHash = driver_GetDriverFilenames(
                                          FREEOTFE_DLL_PATTERN_HASH,
                                          driverFilenamesHash
                                         );
    if (*countDriversHash < 0) 
        {
        DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("Unable to obtain list of hash drivers\n")));
        allOK = FALSE;
        }
    else
        {
        DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("List of hash drivers found (total: %d): \n"), *countDriversHash));
        for(i = 0; i < *countDriversHash; i++)
            {
            DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Hash driver %d: %ls\n"), (i+1), (*driverFilenamesHash)[i]));
            }
        DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("End listing hash drivers.\n")));
        }

    // Identify all cypher drivers...
    *countDriversCypher = driver_GetDriverFilenames(
                                          FREEOTFE_DLL_PATTERN_CYPHER,
                                          driverFilenamesCypher
                                         );
    if (*countDriversCypher < 0) 
        {
        DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("Unable to obtain list of cypher drivers\n")));
        allOK = FALSE;
        }
    else
        {
        DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("List of cypher drivers found (total: %d): \n"), *countDriversCypher));
        for(i = 0; i < *countDriversCypher; i++)
            {
            DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Cypher driver %d: %ls\n"), (i+1), (*driverFilenamesCypher)[i]));
            }
        DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("End listing cypher drivers.\n")));
        }


    // Identify all hash algorithms supported by each of the hash drivers
    *driverInfoHash = calloc(*countDriversHash, sizeof(**driverInfoHash));
    if (*driverInfoHash == NULL)
        {
        DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("Unable to malloc driverInfoHash ARRAY\n")));
        allOK = FALSE;
        }
    else
        {
        for(i = 0; i < *countDriversHash; i++)
            {
            (*driverInfoHash)[i] = malloc(sizeof(*((*driverInfoHash)[0])));
            if ((*driverInfoHash)[i] == NULL)
                {
                DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("Unable to malloc driverInfoHash individual\n")));
                allOK = FALSE;
                }
            else
                {
                if (!(driver_HashGetDriverDetails(
                                            (*driverFilenamesHash)[i],
                                            (*driverInfoHash)[i]
                                           )))
                    {
                    DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("No driver details obtained for hash DLL\n")));
                    DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Hash DLL was: %ls\n"), (*driverFilenamesHash)[i]));
                    SecZeroAndFreeMemory(
                                         (*driverInfoHash)[i], 
                                         sizeof(*((*driverInfoHash)[0]))
                                        );
                    (*driverInfoHash)[i] = NULL;
                    }
                }
            }
        }


    // Identify all cypher algorithms supported by each of the cypher drivers
    *driverInfoCypher = calloc(*countDriversCypher, sizeof(**driverInfoCypher));
    if (*driverInfoCypher == NULL)
        {
        DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("Unable to malloc driverInfoCypher ARRAY\n")));
        allOK = FALSE;
        }
    else
        {
        for(i = 0; i < *countDriversCypher; i++)
            {
            (*driverInfoCypher)[i] = malloc(sizeof(*((*driverInfoCypher)[0])));
            if ((*driverInfoCypher)[i] == NULL)
                {
                DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("Unable to malloc driverInfoCypher individual\n")));
                allOK = FALSE;
                }
            else
                {
                if (!(driver_CypherGetDriverDetails(
                                            (*driverFilenamesCypher)[i],
                                            (*driverInfoCypher)[i]
                                           )))
                    {
                    DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("No driver details obtained for cypher DLL\n")));
                    DEBUGOUTGUI(DEBUGLEV_INFO, (TEXT("Cypher DLL was: %ls\n"), (*driverFilenamesCypher)[i]));
                    SecZeroAndFreeMemory(
                                         (*driverInfoCypher)[i], 
                                         sizeof(*((*driverInfoCypher)[0]))
                                        );
                    (*driverInfoCypher)[i] = NULL;
                    }
                }
            }
        }


    return allOK;
}


// =========================================================================
// Count number of hash/cypher implementations
// Returns CountImplHash and CountImplCypher
void _driver_GetAllAlgorithmDriverOptions_Count(
    WCHAR** driverFilenamesHash,
    HASH_DRIVER_INFO** driverInfoHash,

    WCHAR** driverFilenamesCypher,
    CYPHER_DRIVER_INFO** driverInfoCypher,