driverinterfacehash.c

来自「文件驱动加密,功能强大,可产生加密分区,支持AES,MD2,MD4,MD5MD2」· C语言 代码 · 共 339 行

// Description: 
// By Sarah Dean
// Email: [e-mail]
// WWW:   http://www.FreeOTFE.org/
//
// -----------------------------------------------------------------------------
//

#include "FreeOTFEDebug.h"
#include "FreeOTFElib.h"
#include "DriverInterfaceHash.h"
#include "DriverInterfaceCommon.h"

    
// =========================================================================
BOOL driver_HashLoadDLL(WCHAR* Filename, MODULE_DETAILS_HASH* DLLDetails)
{
    BOOL retval = TRUE;

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

    // Get library path and filename...
    if (retval)
        {
        // +1 for terminating NULL
        DLLDetails->Filename = calloc((wcslen(Filename) + 1), sizeof(DLLDetails->Filename[0]));
        if (DLLDetails->Filename == NULL)
            {
            DEBUGOUTMAINDRV(DEBUGLEV_INFO, (TEXT("Unable to malloc memory to copy driver filename\n")));
            retval = FALSE;
            }
        else
            {
            wcscpy(DLLDetails->Filename, Filename);
            }
        }

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

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

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

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

        DEBUGOUTMAINDRV(DEBUGLEV_INFO, (TEXT("Getting proc address for: %ls\n"), DLLEXPORT_HASH_HASH));
        DLLDetails->FnHash = (PHashDLLFnHash)GetProcAddress(
                                         DLLDetails->Lib,
                                         DLLEXPORT_HASH_HASH
                                        );
        if (DLLDetails->FnHash == NULL)
            {
            DEBUGOUTMAINDRV(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_HashUnloadDLL(DLLDetails);
        }

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


// =========================================================================
void driver_HashUnloadDLL(MODULE_DETAILS_HASH* DLLDetails)
{
    DEBUGOUTMAINDRV(DEBUGLEV_ENTER, (TEXT("driver_HashUnloadDLL\n")));

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

        SecZeroAndFreeWCHARMemory(DLLDetails->Filename);

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

    DEBUGOUTMAINDRV(DEBUGLEV_EXIT, (TEXT("driver_HashUnloadDLL\n")));
}


// =========================================================================
// malloc a HASH_DRIVER_INFO structure, and populate as appropriate; returning
// a pointer to the structure in driverInfo
BOOL driver_HashGetDriverDetails(WCHAR* HashFilename, HASH_DRIVER_INFO* driverInfo)
{
    BOOL retval = FALSE;
    MODULE_DETAILS_HASH DLLDetails;
    DIOC_HASH_IDENTIFYDRIVER identifyBuf;
    DWORD supportedBufSize;
    DIOC_HASH_IDENTIFYSUPPORTED* supportedBuf;
    HASH* hashArray;

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

    if (driver_HashLoadDLL(HashFilename, &DLLDetails))
        {
        if (DLLDetails.FnIdentifyDriver(&identifyBuf) != ERROR_SUCCESS)
            {
            DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("Call to FnIdentifyDriver FAILED!")));
            }
        else
            {
            supportedBufSize = (
                                sizeof(*supportedBuf) -
                                sizeof(HASH) +                                 
                                (sizeof(HASH) * identifyBuf.CountHashes)
                               );
            supportedBuf = malloc(supportedBufSize);
            if (supportedBuf == NULL)
                {
                DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("Unable to malloc DIOCBuffer FnIdentifySupported call\n")));
                }
            else
                {
                if (DLLDetails.FnIdentifySupported(
                                                   supportedBufSize, 
                                                   supportedBuf
                                                  ) != ERROR_SUCCESS)
                    {
                    DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("Call to FnIdentifySupported FAILED!")));
                    }
                else
                    {
                    hashArray = calloc(supportedBuf->BufCount, sizeof(HASH));
                    if (hashArray == NULL)
                        {
                        DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("Unable to malloc buffer for list of supported to be returned\n")));
                        }
                    else
                        {
                        driverInfo->DriverGUID = identifyBuf.DriverGUID;
                        memcpy(
                               driverInfo->DriverTitle,
                               identifyBuf.Title,
                               sizeof(identifyBuf.Title)
                              );
                        driverInfo->DriverVersionID = identifyBuf.VersionID;
                        driverInfo->HashCount = identifyBuf.CountHashes;

                        memcpy(
                               hashArray, 
                               supportedBuf->Hashes,
                               (supportedBuf->BufCount * sizeof(*hashArray))
                              );

                        driverInfo->HashDetails = hashArray;

                        retval = TRUE;
                        }
                    }

                SecZeroAndFreeMemory(supportedBuf, supportedBufSize);
                }

            SecZeroMemory(&identifyBuf, sizeof(identifyBuf));
            }

        driver_HashUnloadDLL(&DLLDetails);
        }

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


// =========================================================================
void driver_HashFreeDriverDetails(HASH_DRIVER_INFO* driverInfo)
{
    if (driverInfo != NULL)
        {
        SecZeroMemory(driverInfo, sizeof(*driverInfo));
        SecZeroAndFreeMemory(
                             driverInfo->HashDetails, 
                             (driverInfo->HashCount * sizeof(HASH))
                            );
        }
}


// =========================================================================
void driver_HashPrettyprintAlgTitle(
    HASH* hashInfo, 
    WCHAR* buffer,
    int bufferSize  // In bytes
)
{
    WCHAR tmpStrBuf[1024];  // 1024 relativly arbitary; must be big enough to
                            // store a full prettyprinted hash/cypher title

    // Convert straight ASCII title to UNICODE
    memset(tmpStrBuf, 0, sizeof(tmpStrBuf));
    mbstowcs(
             tmpStrBuf, 
             hashInfo->Title, 
             strlen(hashInfo->Title)
            );

    // Prettyprint to buffer
    _snwprintf(
              buffer,
              (bufferSize / sizeof(buffer[0])),
              STR_FORMAT_FULL_HASH_TITLE,
              tmpStrBuf,
              hashInfo->Length,
              hashInfo->BlockSize
             );

    SecZeroMemory(tmpStrBuf, sizeof(tmpStrBuf));
}


// =========================================================================
BOOL
driver_HashGetImplDetails(
    WCHAR* HashFilename, 
    GUID* HashImpl, 
    HASH* ImplDetails
)
{
    BOOL retval = FALSE;
    HASH_DRIVER_INFO hashInfo;
    unsigned int i;

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

    if (driver_HashGetDriverDetails(
                                    HashFilename,
                                    &hashInfo
                                   ))
        {
        for (i = 0; i < hashInfo.HashCount; i++)
            {
            if (IsEqualGUID(
                            HashImpl,
                            &(hashInfo.HashDetails[i].HashGUID)
                           ))
                {
                *ImplDetails = hashInfo.HashDetails[i];
                retval = TRUE;
                break;
                }
            }

        driver_HashFreeDriverDetails(&hashInfo);
        }

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


// =========================================================================
BOOL driver_HashData(
    WCHAR* HashDriverFilename,
    GUID HashGUID,
    unsigned int BufferSizeIn,  // In *bits*
    unsigned char* BufferIn,
    unsigned int* ptrBufferSizeOut,  // In *bits*
    unsigned char* BufferOut
)
{
    BOOL retval = FALSE;
    MODULE_DETAILS_HASH DLLDetails;

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

    if (driver_HashLoadDLL(HashDriverFilename, &DLLDetails))
        {
        retval = (DLLDetails.FnHash(
                                    &HashGUID,
                                    BufferSizeIn,
                                    BufferIn,
                                    ptrBufferSizeOut,
                                    BufferOut
                                   ) == ERROR_SUCCESS);

        driver_HashUnloadDLL(&DLLDetails);
        }

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


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