driverinterfacecypher.c

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

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

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

    
// =========================================================================
BOOL driver_CypherLoadDLL(WCHAR* Filename, MODULE_DETAILS_CYPHER* DLLDetails)
{
    BOOL retval = TRUE;

    DEBUGOUTMAINDRV(DEBUGLEV_ENTER, (TEXT("driver_CypherLoadDLL\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_CYPHER_IDENTIFYDRIVER));
        DLLDetails->FnIdentifyDriver = (PCypherDLLFnIdentifyDriver)GetProcAddress(
                                         DLLDetails->Lib,
                                         DLLEXPORT_CYPHER_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_CYPHER_IDENTIFYSUPPORTED));
        DLLDetails->FnIdentifySupported = (PCypherDLLFnIdentifySupported)GetProcAddress(
                                         DLLDetails->Lib,
                                         DLLEXPORT_CYPHER_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_CYPHER_GETCYPHERDETAILS));
        DLLDetails->FnGetCypherDetails = (PCypherDLLFnGetCypherDetails)GetProcAddress(
                                         DLLDetails->Lib,
                                         DLLEXPORT_CYPHER_GETCYPHERDETAILS
                                        );
        if (DLLDetails->FnGetCypherDetails == NULL)
            {
            DEBUGOUTMAINDRV(DEBUGLEV_ERROR, (TEXT("FAILED to get proc address\n")));
            retval = FALSE;
            }

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

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

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

        DEBUGOUTMAINDRV(DEBUGLEV_INFO, (TEXT("Getting proc address for: %ls\n"), DLLEXPORT_CYPHER_DECRYPTWITHASCII));
        DLLDetails->FnDecryptWithASCII = (PCypherDLLFnDecryptWithASCII)GetProcAddress(
                                         DLLDetails->Lib,
                                         DLLEXPORT_CYPHER_DECRYPTWITHASCII
                                        );
        if (DLLDetails->FnDecryptWithASCII == 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_CypherUnloadDLL(DLLDetails);
        }

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


// =========================================================================
void driver_CypherUnloadDLL(MODULE_DETAILS_CYPHER* DLLDetails)
{
    DEBUGOUTMAINDRV(DEBUGLEV_ENTER, (TEXT("driver_CypherUnloadDLL\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_CypherUnloadDLL\n")));
}


// =========================================================================
// malloc a CYPHER_DRIVER_INFO structure, and populate as appropriate; returning
// a pointer to the structure in driverInfo
BOOL driver_CypherGetDriverDetails(WCHAR* CypherFilename, CYPHER_DRIVER_INFO* driverInfo)
{
    BOOL retval = FALSE;
    MODULE_DETAILS_CYPHER DLLDetails;
    DIOC_CYPHER_IDENTIFYDRIVER identifyBuf;
    DWORD supportedBufSize;
    DIOC_CYPHER_IDENTIFYSUPPORTED* supportedBuf;
    CYPHER* cypherArray;

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

    if (driver_CypherLoadDLL(CypherFilename, &DLLDetails))
        {
        if (DLLDetails.FnIdentifyDriver(&identifyBuf) != ERROR_SUCCESS)
            {
            DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("Call to FnIdentifyDriver FAILED!")));
            }
        else
            {
            supportedBufSize = (
                                sizeof(*supportedBuf) -
                                sizeof(CYPHER) +                                 
                                (sizeof(CYPHER) * identifyBuf.CountCyphers)
                               );
            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
                    {
                    cypherArray = calloc(supportedBuf->BufCount, sizeof(CYPHER));
                    if (cypherArray == 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->CypherCount = identifyBuf.CountCyphers;

                        memcpy(
                               cypherArray, 
                               supportedBuf->Cyphers,
                               (supportedBuf->BufCount * sizeof(*cypherArray))
                              );

                        driverInfo->CypherDetails = cypherArray;

                        retval = TRUE;
                        }
                    }

                SecZeroAndFreeMemory(supportedBuf, supportedBufSize);
                }

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

        driver_CypherUnloadDLL(&DLLDetails);
        }

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


// =========================================================================
void driver_CypherFreeDriverDetails(CYPHER_DRIVER_INFO* driverInfo)
{
    if (driverInfo != NULL)
        {
        SecZeroMemory(driverInfo, sizeof(*driverInfo));
        SecZeroAndFreeMemory(
                             driverInfo->CypherDetails, 
                             (driverInfo->CypherCount * sizeof(CYPHER))
                            );
        }
}