VC CUtilityLZW 效率还行的LZW压缩算法，随机数加密

效率还行的LZW压缩算法，随机数加密，关键加密方法已经去掉

#pragma once

#include <afxtempl.h>
#include "QHashTNBuffer.h"
#include "QHashNTBuffer.h"

class CUtilityLZW
{
public:
    CUtilityLZW(void);
    virtual ~CUtilityLZW(void);
    
public:    
    static UINT32 CompressData(PBYTE pUncompressedData, UINT32 nUncompressedLength, CQHashTNBuffer * pListDictionary, CList<UINT32, UINT32> * pListCompressed);
    static UINT32 UncompressData(CList<UINT32, UINT32> * pListCompressed, CQHashNTBuffer * pListDictionary, PBYTE & pUncompressedData, UINT32 nUncompressedSize);
    
public:    
    static UINT32 EncryptData(CList<UINT32, UINT32> * pListCompressed, UINT32 & nOneDataSize, PBYTE & pEncryptData, UINT32 nEncryptSize);
    static UINT32 DecryptData(PBYTE pEncryptData, UINT32 nEncryptLength, UINT32 nOneDataSize, CList<UINT32, UINT32> * pListCompressed);
    static UINT32 PackData(PBYTE pEncryptData, UINT32 nEncryptLength, UINT32 nOneDataSize, UINT32 nUncompressedLength, UINT32 nVersionCode, PBYTE & pPackData, UINT32 nPackSize);
    static UINT32 UnpackData(PBYTE pPackData, UINT32 nPackLength, UINT32 & nOneDataSize, UINT32 & nUncompressedLength, UINT32 & nVersionCode, PBYTE & pEncryptData, UINT32 nEncryptSize);

public:
    static UINT32 Compress(PBYTE pUncompressedData, UINT32 nUncompressedLength, PBYTE & pPackData, UINT32 nPackLength);
    static UINT32 Uncompress(PBYTE pPackData, UINT32 nPackLength, PBYTE & pUncompressedData, UINT32 nUncompressedLength);

};

#include "stdafx.h"
#include "UtilityLZW.h"

#define __PSWX    "12324312342345345674567456745674567"


CUtilityLZW::CUtilityLZW(void)
{
}

CUtilityLZW::~CUtilityLZW(void)
{
}

UINT32 CUtilityLZW::CompressData(PBYTE pUncompressedData, UINT32 nUncompressedLength, CQHashTNBuffer * pListDictionary, CList<UINT32, UINT32> * pListCompressed)
{    
    UINT32 nResult = 0;
    if (pListDictionary == NULL)
    {
        pListDictionary = new CQHashTNBuffer(1024);
    }
    if (pListDictionary->GetCount() < 256)
    {
        for (UINT32 i = 0; i < 256; i++)
        {
            BYTE nData = (BYTE)(i);
            pListDictionary->SetAt((PUINT8)(&nData), 1, i);
        }
    }    
    if (pListCompressed == NULL)
    {
        pListCompressed = new CList<UINT32, UINT32>();
    }
    CQHashTNNode * pWordKey = new CQHashTNNode(0, 1024); 
    CQHashTNNode * pWordCur = new CQHashTNNode(0, 1024); 
    for (int n = 0; n < nUncompressedLength; n++ )
    {
        BYTE dataCur = pUncompressedData[n];
        if (pWordKey->m_nKeyLength > 0)
        {
            pWordCur->SetValue(pWordKey->m_pKeyData, pWordKey->m_nKeyLength);
        }
        pWordCur->AddTailKey(dataCur);
        if (pListDictionary->Contains(pWordCur->m_pKeyData, pWordCur->m_nKeyLength))
        {
            pWordKey->SetValue(pWordCur->m_pKeyData, pWordCur->m_nKeyLength);
        }
        else 
        {        
            UINT32 nWordValue = 0;
            if (pListDictionary->Lookup(pWordKey->m_pKeyData, pWordKey->m_nKeyLength, nWordValue))
            {
                pListCompressed->AddTail(nWordValue);
            }
            pListDictionary->SetAt(pWordCur->m_pKeyData, pWordCur->m_nKeyLength, pListDictionary->GetCount());
            pWordKey->m_nKeyLength = 0;
            pWordKey->AddTailKey(dataCur);
            nResult += 1;
        }
    }    
    if (pWordKey->m_nKeyLength > 0)
    {
        UINT32 nWordValue = 0;
        if (pListDictionary->Lookup(pWordKey->m_pKeyData, pWordKey->m_nKeyLength, nWordValue))
        {
            pListCompressed->AddTail(nWordValue);
        }
        nResult += 1;
    }
    if (nResult <= 0)
    {
        if (pListDictionary != NULL)
        {
            delete pListDictionary;
            pListDictionary = NULL;
        }
        if (pListCompressed != NULL)
        {
            delete pListCompressed;
            pListCompressed = NULL;
        }
    }
    delete pWordKey;
    delete pWordCur;
    return nResult;
}

UINT32 CUtilityLZW::UncompressData(CList<UINT32, UINT32> * pListCompressed, CQHashNTBuffer * pListDictionary, PBYTE & pUncompressedData, UINT32 nUncompressedSize)
{    
    UINT32 nResult = 0;    
    if (pListDictionary == NULL)
    {
        pListDictionary = new CQHashNTBuffer(40960);
    }
    if (pListDictionary->GetCount() < 256)
    {
        for (UINT32 i = 0; i < 256; i++)
        {
            BYTE nData = (BYTE)(i);
            pListDictionary->SetAt(i, (PUINT8)(&nData), 1);
        }
    }
    if ((pListCompressed != NULL) && (nUncompressedSize > 0))
    {    
        if (pListCompressed->GetCount() > 0)
        {            
            if (pUncompressedData == NULL)
            {
                pUncompressedData = new BYTE[nUncompressedSize];
            }            
            int wordPos = 0; 
            wordPos = pListCompressed->GetHead();
            pListCompressed->RemoveHead();
            CQHashNTNode * pWordKey = new CQHashNTNode(0, 0, 256); 
            pListDictionary->Lookup(wordPos, pWordKey);
            memcpy(pUncompressedData + nResult, pWordKey->m_pValueData, pWordKey->m_nValueLength);
            nResult += pWordKey->m_nValueLength;            
            CQHashNTNode * pWordEntry = new CQHashNTNode(0, 0, 256);             
            CQHashNTNode * pWordNew = new CQHashNTNode(0, 0, 256);     
            POSITION pos = pListCompressed->GetHeadPosition();
            while (pos != NULL)
            {
                wordPos = pListCompressed->GetNext(pos);
                pWordEntry->m_nValueLength = 0;
                if (pListDictionary->Lookup(wordPos, pWordEntry))
                {
                }
                else if (wordPos == pListDictionary->GetCount())
                {
                    if (pWordKey->m_nValueLength > 0)
                    {
                        pWordEntry->SetValue(wordPos);
                        pWordEntry->SetValue(pWordKey->m_pValueData, pWordKey->m_nValueLength);                    
                        pWordEntry->AddTailValue(pWordKey->m_pValueData[0]);
                    }
                }
                memcpy(pUncompressedData + nResult, pWordEntry->m_pValueData, pWordEntry->m_nValueLength);
                nResult += pWordEntry->m_nValueLength;
                if (pWordEntry->m_nValueLength > 0)
                {
                    UINT32 nNewKey = pListDictionary->GetCount();
                    pWordNew->m_nValueLength = 0;
                    pWordNew->SetValue(nNewKey);
                    pWordNew->SetValue(pWordKey->m_pValueData, pWordKey->m_nValueLength);
                    pWordNew->AddTailValue(pWordEntry->m_pValueData[0]);
                    pListDictionary->SetAt(nNewKey, pWordNew->m_pValueData, pWordNew->m_nValueLength);
                }
                pWordKey->SetValue(pWordEntry->m_nKeyData);
                pWordKey->SetValue(pWordEntry->m_pValueData, pWordEntry->m_nValueLength);
            }
            delete pWordNew;
            delete pWordEntry;
            delete pWordKey;
        }
    }
    return nResult;
}

UINT32 CUtilityLZW::EncryptData(CList<UINT32, UINT32> * pListCompressed, UINT32 & nOneDataSize, PBYTE & pEncryptData, UINT32 nEncryptSize)
{
    UINT32 nResult = 0;    
    UINT32 nMaxDatSize = 0;            
    POSITION pos = pListCompressed->GetHeadPosition();
    while (pos != NULL)
    {
        UINT32 wordPos = pListCompressed->GetNext(pos);
        if (wordPos <= 0xFF) nMaxDatSize = max(1, nMaxDatSize);
        else if (wordPos <= 0xFFFF) nMaxDatSize = max(2, nMaxDatSize);
        else if (wordPos <= 0xFFFFFF) nMaxDatSize = max(3, nMaxDatSize);
        else if (wordPos <= 0xFFFFFFFF) nMaxDatSize = max(4, nMaxDatSize);
        else nMaxDatSize = max(4, nMaxDatSize);
    }
    nOneDataSize = nMaxDatSize;
    UINT32 nCompressedLength = nOneDataSize * pListCompressed->GetCount();
    if (pEncryptData == NULL)
    {
        pEncryptData = new BYTE[nCompressedLength];
    }
    else if (nEncryptSize < nCompressedLength)
    {
        delete[] pEncryptData;
        pEncryptData = new BYTE[nCompressedLength];
    }            
    if (nOneDataSize == 1)
    {
        POSITION pos = pListCompressed->GetHeadPosition();
        while (pos != NULL)
        {
            UINT32 wordPos = pListCompressed->GetNext(pos);
            pEncryptData[nResult++] = (BYTE)(wordPos & 0xFF);
        }
    }                
    else if (nOneDataSize == 2)
    {
        POSITION pos = pListCompressed->GetHeadPosition();
        while (pos != NULL)
        {
            UINT32 wordPos = pListCompressed->GetNext(pos);
            pEncryptData[nResult++] = (BYTE)((wordPos >> 0) & 0xFF);
            pEncryptData[nResult++] = (BYTE)((wordPos >> 8) & 0xFF);
        }
    }                
    else if (nOneDataSize == 3)
    {
        POSITION pos = pListCompressed->GetHeadPosition();
        while (pos != NULL)
        {
            UINT32 wordPos = pListCompressed->GetNext(pos);
            pEncryptData[nResult++] = (BYTE)((wordPos >> 0) & 0xFF);
            pEncryptData[nResult++] = (BYTE)((wordPos >> 8) & 0xFF);
            pEncryptData[nResult++] = (BYTE)((wordPos >> 16) & 0xFF);
        }
    }        
    else
    {
        POSITION pos = pListCompressed->GetHeadPosition();
        while (pos != NULL)
        {
            UINT32 wordPos = pListCompressed->GetNext(pos);
            pEncryptData[nResult++] = (BYTE)((wordPos >> 0) & 0xFF);
            pEncryptData[nResult++] = (BYTE)((wordPos >> 8) & 0xFF);
            pEncryptData[nResult++] = (BYTE)((wordPos >> 16) & 0xFF);
            pEncryptData[nResult++] = (BYTE)((wordPos >> 24) & 0xFF);
        }
    }
    return nResult;
}

UINT32 CUtilityLZW::DecryptData(PBYTE pEncryptData, UINT32 nEncryptLength, UINT32 nOneDataSize, CList<UINT32, UINT32> * pListCompressed)
{    
    UINT32 nResult = 0;    
    if (pListCompressed == NULL)
    {
        pListCompressed = new CList<UINT32, UINT32>();
    }
    UINT32 nIndex = 0;
    UINT32 nData = 0;
    if (nOneDataSize == 1)
    {
        while (nIndex < nEncryptLength)
        {
            nData = pEncryptData[nIndex++];
            pListCompressed->AddTail(nData);
            nResult += 1;
        }
    }            
    else if (nOneDataSize == 2)
    {
        while (nIndex < nEncryptLength)
        {
            nData = 0;
            nData |= (((UINT32)pEncryptData[nIndex++]) << 0);
            nData |= (((UINT32)pEncryptData[nIndex++]) << 8);
            pListCompressed->AddTail(nData);
            nResult += 1;
        }
    }                
    else if (nOneDataSize == 3)
    {
        while (nIndex < nEncryptLength)
        {
            nData = 0;
            nData |= (((UINT32)pEncryptData[nIndex++]) << 0);
            nData |= (((UINT32)pEncryptData[nIndex++]) << 8);
            nData |= (((UINT32)pEncryptData[nIndex++]) << 16);
            pListCompressed->AddTail(nData);
            nResult += 1;
        }
    }        
    else
    {
        while (nIndex < nEncryptLength)
        {
            nData = 0;
            nData |= (((UINT32)pEncryptData[nIndex++]) << 0);
            nData |= (((UINT32)pEncryptData[nIndex++]) << 8);
            nData |= (((UINT32)pEncryptData[nIndex++]) << 16);
            nData |= (((UINT32)pEncryptData[nIndex++]) << 24);
            pListCompressed->AddTail(nData);
            nResult += 1;
        }
    }
    return nResult;
}

UINT32 CUtilityLZW::PackData(PBYTE pEncryptData, UINT32 nEncryptLength, UINT32 nOneDataSize, UINT32 nUncompressedLength, UINT32 nVersionCode, PBYTE & pPackData, UINT32 nPackSize)
{
    UINT32 nResult = 0;    
    BYTE bKeys[] = {
        (BYTE)(rand() % 256), (BYTE)(rand() % 256), (BYTE)(rand() % 256), (BYTE)(rand() % 256),
        (BYTE)(rand() % 256), (BYTE)(rand() % 256), (BYTE)(rand() % 256), (BYTE)(rand() % 256),
        (BYTE)(rand() % 256), (BYTE)(rand() % 256), (BYTE)(rand() % 256), (BYTE)(rand() % 256),
        (BYTE)(rand() % 256), (BYTE)(rand() % 256), (BYTE)(rand() % 256), (BYTE)(rand() % 256),
    };
    UINT32 nHeadLen = 32;
    if ((nEncryptLength > 0) && (pEncryptData != NULL))
    {
        UINT32 nPackLen = nHeadLen + nEncryptLength;
        if (pPackData != NULL)
        {
            if (nPackSize < nPackLen)
            {
                delete[] pPackData;
                pPackData = NULL;
            }
        }
        if (pPackData == NULL)
        {
            pPackData = new BYTE[nPackLen];
            nPackSize = nPackLen;
        }
        UINT32 nData = 0;
        for (int n = 0; n < 16; n++)            
        {
            // 这里数据可加密，与随机数运算
            pPackData[nResult++] = bKeys[n];
        }            
        UINT32 nKeyIndex = 0;
        UINT32 gnData[] = {nVersionCode, nEncryptLength, nOneDataSize, nUncompressedLength };
        for (int n = 0; n < 4; n++)            
        {            
            // 这里数据可加密，与随机数运算
            nData = (BYTE)((gnData[n] >>  0) & 0xFF);
            pPackData[nResult++] = (BYTE)nData;
            nData = (BYTE)((gnData[n] >>  8) & 0xFF);
            pPackData[nResult++] = (BYTE)nData;
            nData = (BYTE)((gnData[n] >>  16) & 0xFF);
            pPackData[nResult++] = (BYTE)nData;
            nData = (BYTE)((gnData[n] >>  24) & 0xFF);
            pPackData[nResult++] = (BYTE)nData;
        }            
        for (int n = 0; n < nEncryptLength; n++)
        {            
            // 这里数据可加密，与随机数运算
            pPackData[nResult++] = (BYTE)nData;
        }
    }
    return nResult;
}

UINT32 CUtilityLZW::UnpackData(PBYTE pPackData, UINT32 nPackLength, UINT32 & nOneDataSize, UINT32 & nUncompressedLength, UINT32 & nVersionCode, PBYTE & pEncryptData, UINT32 nEncryptSize)
{
    UINT32 nResult = 0;    
    BYTE bKeys[16] = { 0 };    
    UINT32 nData = 0;
    UINT32 pos = 0;
    if (nPackLength > 32)
    {
        for (int n = 0; n < 16; n++)
        {
            // 这里数据可加密，与随机数运算
            bKeys[n] = pPackData[pos++];            
        }
        UINT32 nKeyIndex = 0;
        UINT32 gnData[4] = { 0 };
        UINT32 nKey = 0;
        for (int n = 0; n < 4; n++)            
        {
            // 这里数据可加密，与随机数运算
            gnData[n] = 0;
            nData = pPackData[pos++];
            gnData[n] |= ((nData & 0xFF) << 0);
            nData = pPackData[pos++];
            gnData[n] |= ((nData & 0xFF) << 8);
            nData = pPackData[pos++];
            gnData[n] |= ((nData & 0xFF) << 16);
            nData = pPackData[pos++];
            gnData[n] |= ((nData & 0xFF) << 24);
        }
        UINT32 nEncryptLength = 0;
        nVersionCode = gnData[0];
        nEncryptLength = gnData[1];
        nOneDataSize = gnData[2];
        nUncompressedLength = gnData[3];
        if (pEncryptData == NULL)
        {
            nResult += nUncompressedLength;
            nResult += 32;
            return nResult;
        }
        if (nEncryptSize < nEncryptLength)
        {
            delete[] pEncryptData;
            pEncryptData = NULL;
        }
        if (pEncryptData == NULL)
        {
            pEncryptData = new BYTE[nEncryptLength];
            nEncryptSize = nEncryptLength;
        }        
        nResult = 0;
        for (int n = 32; n < nPackLength; n++)
        {
            // 这里数据可加密，与随机数运算
            pEncryptData[nResult++] = ((PBYTE)pPackData)[pos++];    
        }
    }
    return nResult;
}

UINT32 CUtilityLZW::Compress(PBYTE pUncompressedData, UINT32 nUncompressedLength, PBYTE & pPackData, UINT32 nPackSize)
{
    UINT32 nResult = 0;    
    CQHashTNBuffer * pListDictionary = new CQHashTNBuffer(1024);
    CList<UINT32, UINT32> * pListCompressed = new CList<UINT32, UINT32>();
    UINT32 nCompressedCount = CompressData(pUncompressedData, nUncompressedLength, pListDictionary, pListCompressed);
    if (nCompressedCount > 0)
    {
        delete pListDictionary;
        pListDictionary = NULL;    
        UINT32 nOneDataSize = 0;
        UINT32 nEncryptLength = 0;
        PBYTE pEncryptData = NULL;
        nEncryptLength = EncryptData(pListCompressed, nOneDataSize, pEncryptData, 0);
        delete pListCompressed;
        pListCompressed = NULL;    
        if ((nEncryptLength > 0) && (pEncryptData != NULL))
        {
            UINT32 nPackLength = 0;
            BOOL bDelete = (pPackData == NULL);
            nPackLength = PackData(pEncryptData, nEncryptLength, nOneDataSize, nUncompressedLength, 0x00F, pPackData, nPackSize);
            if ((nPackLength > 0) && (pPackData != NULL))
            {
                nResult = nPackLength;
            }
            else  
            {
                if (bDelete && (pPackData != NULL))
                {
                    delete[] pPackData;
                    pPackData = NULL;
                }
            }
        }
        if (pEncryptData != NULL)
        {
            delete[] pEncryptData;
            pEncryptData = NULL;
        }
    }
    if (pListCompressed != NULL)
    {
        delete pListCompressed;
        pListCompressed = NULL;
    }
    if (pListDictionary != NULL)
    {
        delete pListDictionary;
        pListDictionary = NULL;
    }
    return nResult;
}

UINT32 CUtilityLZW::Uncompress(PBYTE pPackData, UINT32 nPackLength, PBYTE & pUncompressedData, UINT32 nUncompressedSize)
{
    UINT32 nResult = 0;
    UINT32 nOneDataSize = 0;
    UINT32 nUncompressedLength = 0;
    UINT32 nVersionCode = 0;
    PBYTE pEncryptData = NULL;
    if (pUncompressedData == NULL)
    {
        nResult = UnpackData(pPackData, nPackLength, nOneDataSize, nUncompressedLength, nVersionCode, pEncryptData, 0);
        return nResult;
    }    
    UINT32 nEncryptSize = nPackLength * 10;
    UINT32 nEncryptLength = 0;
    pEncryptData = new BYTE[nEncryptSize];
    nEncryptLength = UnpackData(pPackData, nPackLength, nOneDataSize, nUncompressedLength, nVersionCode, pEncryptData, nEncryptSize);
    if ((nEncryptLength > 0) && (pEncryptData != NULL))
    {
        CList<UINT32, UINT32> * pListCompressed = new CList<UINT32, UINT32>();
        UINT32 nCompressedCount = DecryptData(pEncryptData, nEncryptLength, nOneDataSize, pListCompressed);
        if (nCompressedCount)
        {
            delete[] pEncryptData;
            pEncryptData = NULL;
            CQHashNTBuffer * pListDictionary = new CQHashNTBuffer(40960);        
            BOOL bDelete = (pPackData == NULL);    
            if (pUncompressedData != NULL)
            {
                if (nUncompressedSize < nUncompressedLength)
                {
                    delete[] pUncompressedData;
                    pUncompressedData = NULL;
                }
            }
            if (pUncompressedData == NULL)
            {
                pUncompressedData = new BYTE[nUncompressedLength];
                nUncompressedSize = nUncompressedLength;
            }    
            nResult = UncompressData(pListCompressed, pListDictionary, pUncompressedData, nUncompressedSize);            
            if (bDelete && (nResult < nUncompressedLength))
            {
                delete[] pUncompressedData;
                pUncompressedData = NULL;
                nResult = 0;
            }
            delete pListDictionary;
            pListDictionary = NULL;
        }
        delete pListCompressed;
        pListCompressed = NULL;
    }
    if (pEncryptData != NULL)
    {
        delete[] pEncryptData;
        pEncryptData = NULL;
    }
    return nResult;
}

Demo

void CKRTV3BCDemoVCDlg::OnBnClickedButton1()
{
    int n = 0;
    CStringA strText = "
Support for Intel®/Sharp® flash chips 
 Support for AMD/Fujitsu® flash chips
 Support for ST(Advanced Architecture) flash chips";
 
    PBYTE pUncompressedData = new BYTE[1024];
    for (int n = 0; n < 1024; n++)
    {
        pUncompressedData[n] = (BYTE)(n + rand() % 255);
    }
    UINT32 nUncompressedLength = 1024;

    for (int n = 0; n < strText.GetLength(); n++)
    {
        pUncompressedData[n] = strText[n];
    }
    nUncompressedLength = strText.GetLength();

    PBYTE pCompressData  = new BYTE[2048];
    UINT32 nCompressSize = 2048;
    UINT32 nCompressLen = CUtilityLZW::Compress(pUncompressedData, nUncompressedLength, pCompressData, nCompressSize);
    if (nCompressLen > 0)
    {
        PBYTE pUncompressData2  = new BYTE[2048];
        UINT32 nUncompressSize2 = 2048;
        UINT32 nUncompressLen2 = CUtilityLZW::Uncompress(pCompressData, nCompressLen, pUncompressData2, nUncompressSize2);
        if(nUncompressLen2)
        {
            n++;
        }
    }
    CString str;
    str.Format(_T("%d"), n);
    AfxMessageBox(str);
}