driverinterfacecypher.c

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

// =========================================================================
// EncryptNotDecrypt - Set to TRUE to encrypt, FALSE to decrypt
BOOL _driver_CypherEncryptDecryptData(
    BOOL EncryptNotDecrypt,
    WCHAR* CypherDriverFilename,
    GUID CypherGUID,
    unsigned int KeySize, // In *bits*
    FREEOTFEBYTE* Key,
    unsigned int IVSize, // In *bits*
    FREEOTFEBYTE* IV,
    unsigned int BufferSize, // In bytes
    FREEOTFEBYTE* BufferIn,
    FREEOTFEBYTE* BufferOut
)
{
    BOOL retval = FALSE;
    MODULE_DETAILS_CYPHER DLLDetails;
    DIOC_CYPHER_DATA_IN* DIOCIn;
    unsigned int DIOCInSize;    
    FREEOTFEBYTE* ptrKey;
    FREEOTFEBYTE* ptrIV;
    FREEOTFEBYTE* ptrData;

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

    if (driver_CypherLoadDLL(CypherDriverFilename, &DLLDetails))
        {
        DIOCInSize = sizeof(*DIOCIn) - 
                     sizeof(DIOCIn->Key) - 
                     sizeof(DIOCIn->IV) - 
                     sizeof(DIOCIn->Data) +
                     (KeySize / 8) +
                     (IVSize / 8) + 
                     BufferSize;

        DIOCIn = malloc(DIOCInSize);
        if (DIOCIn == NULL) 
            {
            DEBUGOUTGUI(DEBUGLEV_ERROR, (TEXT("Unable to malloc DIOC in buffer\n")));
            }
        else
            {
            DIOCIn->CypherGUID = CypherGUID;
            DIOCIn->KeyLength = KeySize;
            DIOCIn->IVLength = IVSize;
            DIOCIn->DataLength = BufferSize;

            ptrKey  = DIOCIn->Key;
            ptrIV   = ptrKey + (KeySize / 8);
            ptrData = ptrIV + (IVSize / 8);

            memcpy(ptrKey, Key, (KeySize / 8));
            memcpy(ptrIV, IV, (IVSize / 8));
            memcpy(ptrData, BufferIn, BufferSize);
                
            if (EncryptNotDecrypt)
                {
                retval = (DLLDetails.FnEncrypt(
                                               DIOCInSize,
                                               DIOCIn,
                                               BufferSize,
                                               (DIOC_CYPHER_DATA_OUT*)BufferOut
                                              ) == ERROR_SUCCESS);
                }
            else
                {
                retval = (DLLDetails.FnDecrypt(
                                               DIOCInSize,
                                               DIOCIn,
                                               BufferSize,
                                               (DIOC_CYPHER_DATA_OUT*)BufferOut
                                              ) == ERROR_SUCCESS);
                }

            SecZeroAndFreeMemory(DIOCIn, DIOCInSize);
            }

        driver_CypherUnloadDLL(&DLLDetails);
        }

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


// =========================================================================
BOOL driver_CypherEncryptData(
    WCHAR* CypherDriverFilename,
    GUID CypherGUID,
    unsigned int keySize, // In *bits*
    FREEOTFEBYTE* Key,
    unsigned int IVSize, // In *bits*
    FREEOTFEBYTE* IV,
    unsigned int blockSize, // In bytes
    FREEOTFEBYTE* plaintextBuffer,
    FREEOTFEBYTE* encryptedBuffer
)
{
    return _driver_CypherEncryptDecryptData(
                               TRUE,
                               CypherDriverFilename,
                               CypherGUID,
                               keySize, // In *bits*
                               Key,
                               IVSize, // In *bits*
                               IV,
                               blockSize, // In bytes
                               plaintextBuffer,
                               encryptedBuffer
                              );
}


// =========================================================================
BOOL driver_CypherDecryptData(
    WCHAR* CypherDriverFilename,
    GUID CypherGUID,
    unsigned int keySize, // In *bits*
    FREEOTFEBYTE* Key,
    unsigned int IVSize, // In *bits*
    FREEOTFEBYTE* IV,
    unsigned int blockSize, // In bytes
    FREEOTFEBYTE* encryptedBuffer,
    FREEOTFEBYTE* plaintextBuffer
)
{
    return _driver_CypherEncryptDecryptData(
                               FALSE,
                               CypherDriverFilename,
                               CypherGUID,
                               keySize, // In *bits*
                               Key,
                               IVSize, // In *bits*
                               IV,
                               blockSize, // In bytes
                               encryptedBuffer,
                               plaintextBuffer
                              );
}


// =========================================================================
void driver_CypherPrettyprintAlgTitle(
    CYPHER* cypherInfo, 
    WCHAR* buffer,
    int bufferSize  // In bytes
)
{
    WCHAR strMode[10];  // Enough to hold any cypher mode as a string
    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, 
             cypherInfo->Title, 
             strlen(cypherInfo->Title)
            ); 

    // Conver cypher mode to UNICODE string representation
    memset(strMode, 0, sizeof(strMode));
    driver_CypherPrettyprintAlgMode(
                                    cypherInfo->Mode,
                                    strMode
                                   );

    // Prettyprint to buffer
    _snwprintf(
              buffer,
              (bufferSize / sizeof(buffer[0])),
              STR_FORMAT_FULL_CYPHER_TITLE,
              tmpStrBuf,
              strMode,
              cypherInfo->KeySize,
              cypherInfo->BlockSize
             );

    SecZeroMemory(tmpStrBuf, sizeof(tmpStrBuf));
}


// =========================================================================
// !! IMPORTANT !!
// Buffer **MUST** be large enough to store mode as UNICODE string!
// (Obvious, but...)
void driver_CypherPrettyprintAlgMode(
    CYPHER_MODE mode,
    WCHAR* buffer
)
{
    switch (mode)
        {
        case CYPHER_MODE_NONE:
            {
            wcscpy(buffer, TEXT("None"));
            break;
            }

        case CYPHER_MODE_ECB:
            {
            wcscpy(buffer, TEXT("ECB"));
            break;
            }

        case CYPHER_MODE_CBC:
            {
            wcscpy(buffer, TEXT("CBC"));
            break;
            }

        default:
            {
            wcscpy(buffer, STR_UNKNOWN);
            break;
            }
        }

}


// =========================================================================
BOOL
driver_CypherGetImplDetails(
    WCHAR* CypherFilename, 
    GUID* CypherImpl, 
    CYPHER* ImplDetails
)
{
    BOOL retval = FALSE;
    CYPHER_DRIVER_INFO cypherInfo;
    unsigned int i;

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

    if (driver_CypherGetDriverDetails(
                                    CypherFilename,
                                    &cypherInfo
                                   ))
        {
        for (i = 0; i < cypherInfo.CypherCount; i++)
            {
            if (IsEqualGUID(
                            CypherImpl,
                            &(cypherInfo.CypherDetails[i].CypherGUID)
                           ))
                {
                *ImplDetails = cypherInfo.CypherDetails[i];
                retval = TRUE;
                break;
                }
            }

        driver_CypherFreeDriverDetails(&cypherInfo);
        }

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


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