C/C++中常用加密與解密算法的實現(xiàn)
計算機安全和數(shù)據(jù)隱私是現(xiàn)代應(yīng)用程序設(shè)計中至關(guān)重要的方面。為了確保數(shù)據(jù)的機密性和完整性，常常需要使用加密和解密算法。C++是一種廣泛使用的編程語言，提供了許多加密和解密算法的實現(xiàn)。本文將介紹一些在C++中常用的加密與解密算法，這其中包括Xor異或、BASE64、AES、MD5、SHA256、RSA等。
異或加解密
異或（XOR）加密算法是一種基于異或運算的簡單且常見的加密技術(shù)。在異或加密中，每個位上的值通過與一個密鑰位進行異或運算來改變。這種加密算法的簡單性和高效性使得它在某些場景下很有用，尤其是對于簡單的數(shù)據(jù)加密需求。
異或運算是一種邏輯運算，其規(guī)則如下：
- 0 XOR 0 = 0
- 0 XOR 1 = 1
- 1 XOR 0 = 1
- 1 XOR 1 = 0
在異或加密中，將明文與密鑰進行逐位異或運算。如果明文位和密鑰位相同，則結(jié)果為0；如果不同，則結(jié)果為1。這個過程是可逆的，即可以通過再次異或同樣的密鑰來還原原始明文。
#include <Windows.h>
#include <iostream>
using namespace std;
// 獲取異或整數(shù)
long GetXorKey(const char* StrPasswd)
{
char cCode[32] = { 0 };
strcpy(cCode, StrPasswd);
DWORD Xor_Key = 0;
for (unsigned int x = 0; x < strlen(cCode); x++)
{
Xor_Key = Xor_Key * 4 + cCode[x];
}
return Xor_Key;
}
// 異或為字符串
std::string XorEncrypt(std::string content, std::string secretKey)
{
for (UINT i = 0; i < content.length(); i++)
{
content[i] ^= secretKey[i % secretKey.length()];
}
return content;
}
int main(int argc, char* argv[])
{
// 計算加密密鑰
long ref = GetXorKey("lyshark");
std::cout << "計算異或密鑰: " << ref << std::endl;
// 執(zhí)行異或加密
char szBuffer[1024] = "hello lyshark";
for (int x = 0; x < strlen(szBuffer); x++)
{
szBuffer[x] = szBuffer[x] ^ ref;
std::cout << "加密后: " << szBuffer[x] << std::endl;
}
// 直接異或字符串
std::string xor_string = "hello lyshark";
std::cout << "加密后: " << XorEncrypt(xor_string, "lyshark").c_str() << std::endl;
system("pause");
return 0;
}
運行后對特定字符串異或處理，如下圖；
BASE64加解密
Base64 是一種常見的編碼和解碼算法，用于將二進制數(shù)據(jù)轉(zhuǎn)換成可打印的 ASCII 字符串，以及將這樣的字符串還原回二進制數(shù)據(jù)。Base64 編碼是一種將二進制數(shù)據(jù)表示為 ASCII 字符的方式，廣泛應(yīng)用于數(shù)據(jù)傳輸和存儲領(lǐng)域。
Base64 編碼基于一組 64 個字符的編碼表，通常包括大寫字母 A-Z、小寫字母 a-z、數(shù)字 0-9，以及兩個額外的字符 '+' 和 '/'。這樣的字符集是為了確保編碼后的數(shù)據(jù)是可打印的，并且在不同系統(tǒng)之間可以被準確傳輸。
編碼的過程如下：
- 將待編碼的數(shù)據(jù)劃分為每 3 個字節(jié)一組（24 位）。
- 將每組 3 個字節(jié)拆分成 4 個 6 位的塊。
- 每個 6 位的塊對應(yīng)編碼表中的一個字符。
- 如果數(shù)據(jù)長度不是 3 的倍數(shù)，使用 '=' 字符進行填充。
解碼的過程是編碼的逆過程。
#include <iostream>
#include <Windows.h>
// base64 轉(zhuǎn)換表, 共64個
static const char base64_alphabet[] ={
'A', 'B', 'C', 'D', 'E', 'F', 'G',
'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T',
'U', 'V', 'W', 'X', 'Y', 'Z',
'a', 'b', 'c', 'd', 'e', 'f', 'g',
'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't',
'u', 'v', 'w', 'x', 'y', 'z',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'+', '/'
};
// 解碼時使用
static const unsigned char base64_suffix_map[256] = {
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 253, 255,
255, 253, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 253, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 62, 255, 255, 255, 63,
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 255, 255,
255, 254, 255, 255, 255, 0, 1, 2, 3, 4, 5, 6,
7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19, 20, 21, 22, 23, 24, 25, 255, 255, 255, 255, 255,
255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
49, 50, 51, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255
};
static char cmove_bits(unsigned char src, unsigned lnum, unsigned rnum)
{
src <<= lnum; // src = src << lnum;
src >>= rnum; // src = src >> rnum;
return src;
}
int base64_encode(const char* indata, int inlen, char* outdata, int* outlen)
{
int ret = 0;
if (indata == NULL || inlen == 0)
{
return ret = -1;
}
// 源字符串長度, 如果in_len不是3的倍數(shù), 那么需要補成3的倍數(shù)
int in_len = 0;
// 需要補齊的字符個數(shù), 這樣只有2, 1, 0(0的話不需要拼接, )
int pad_num = 0;
if (inlen % 3 != 0)
{
pad_num = 3 - inlen % 3;
}
// 拼接后的長度, 實際編碼需要的長度(3的倍數(shù))
in_len = inlen + pad_num;
// 編碼后的長度
int out_len = in_len * 8 / 6;
// 定義指針指向傳出data的首地址
char* p = outdata;
//編碼, 長度為調(diào)整后的長度, 3字節(jié)一組
for (int i = 0; i < in_len; i += 3)
{
// 將indata第一個字符向右移動2bit(丟棄2bit)
int value = *indata >> 2;
// 對應(yīng)base64轉(zhuǎn)換表的字符
char c = base64_alphabet[value];
// 將對應(yīng)字符(編碼后字符)賦值給outdata第一字節(jié)
*p = c;
//處理最后一組(最后3字節(jié))的數(shù)據(jù)
if (i == inlen + pad_num - 3 && pad_num != 0)
{
if (pad_num == 1)
{
*(p + 1) = base64_alphabet[(int)(cmove_bits(*indata, 6, 2) + cmove_bits(*(indata + 1), 0, 4))];
*(p + 2) = base64_alphabet[(int)cmove_bits(*(indata + 1), 4, 2)];
*(p + 3) = '=';
}
else if (pad_num == 2)
{
// 編碼后的數(shù)據(jù)要補兩個 '='
*(p + 1) = base64_alphabet[(int)cmove_bits(*indata, 6, 2)];
*(p + 2) = '=';
*(p + 3) = '=';
}
}
else
{
// 處理正常的3字節(jié)的數(shù)據(jù)
*(p + 1) = base64_alphabet[cmove_bits(*indata, 6, 2) + cmove_bits(*(indata + 1), 0, 4)];
*(p + 2) = base64_alphabet[cmove_bits(*(indata + 1), 4, 2) + cmove_bits(*(indata + 2), 0, 6)];
*(p + 3) = base64_alphabet[*(indata + 2) & 0x3f];
}
p += 4;
indata += 3;
}
if (outlen != NULL)
{
*outlen = out_len;
}
return ret;
}
int base64_decode(const char* indata, int inlen, char* outdata, int* outlen)
{
int ret = 0;
if (indata == NULL || inlen <= 0 || outdata == NULL || outlen == NULL)
{
return ret = -1;
}
if (inlen % 4 != 0)
{
// 需要解碼的數(shù)據(jù)不是4字節(jié)倍數(shù)
return ret = -2;
}
int t = 0, x = 0, y = 0, i = 0;
unsigned char c = 0;
int g = 3;
while (indata[x] != 0)
{
// 需要解碼的數(shù)據(jù)對應(yīng)的ASCII值對應(yīng)base64_suffix_map的值
c = base64_suffix_map[indata[x++]];
// 對應(yīng)的值不在轉(zhuǎn)碼表中
if (c == 255)
return -1;
// 對應(yīng)的值是換行或者回車
if (c == 253)
continue;
if (c == 254)
{
// 對應(yīng)的值是'='
c = 0; g--;
}
// 將其依次放入一個int型中占3字節(jié)
t = (t << 6) | c;
if (++y == 4)
{
outdata[i++] = (unsigned char)((t >> 16) & 0xff);
if (g > 1) outdata[i++] = (unsigned char)((t >> 8) & 0xff);
if (g > 2) outdata[i++] = (unsigned char)(t & 0xff);
y = t = 0;
}
}
if (outlen != NULL)
{
*outlen = i;
}
return ret;
}
int main(int argc, char* argv[])
{
char str1[] = "hello lyshark";
char str3[30] = { 0 };
char str2[30] = { 0 };
int len = 0;
base64_encode(str1, (int)strlen(str1), str2, &len);
printf("加密后: %s 長度: %d\n", str2, len);
base64_decode(str2, (int)strlen(str2), str3, &len);
printf("解密后: %s 長度: %d\n", str3, len);
system("pause");
return 0;
}
運行后對特定字符串base64處理，如下圖；
AES對稱加解密
高級加密標準（Advanced Encryption Standard，AES）是一種對稱密鑰加密算法，廣泛用于保護敏感數(shù)據(jù)的機密性。AES 是一種塊密碼算法，支持不同的密鑰長度（128、192、256 比特），并且在安全性和性能之間取得了很好的平衡。
AES 操作在固定大小的數(shù)據(jù)塊上進行，每個數(shù)據(jù)塊大小為 128 比特（16 字節(jié)）。AES 使用稱為輪（rounds）的迭代結(jié)構(gòu)來執(zhí)行加密和解密。輪數(shù)取決于密鑰長度，分別為 10 輪（128 比特密鑰）、12 輪（192 比特密鑰）和 14 輪（256 比特密鑰）。AES可使用16、24或32字節(jié)密鑰(對應(yīng)128、192和256位)，AES分為ECB和CBC模式，處理的數(shù)據(jù)必須是塊大小16的倍數(shù)。
AES 的基本加密流程包括以下步驟：
- 密鑰擴展（Key Expansion）： 根據(jù)輸入密鑰生成輪密鑰，用于后續(xù)的輪函數(shù)。
- 初始輪（Initial Round）： 將明文與第一輪密鑰進行逐字節(jié)的異或操作。
- 輪運算（Rounds）： 重復(fù)執(zhí)行一系列輪函數(shù)，每輪包括四個操作：字節(jié)替代、行移位、列混淆和輪密鑰加。
- 最終輪（Final Round）： 在最后一輪中，省略列混淆步驟。
AES 的解密過程與加密過程相似，但使用的是逆操作，如逆字節(jié)替代、逆行移位、逆列混淆和逆輪密鑰加。
CryptAcquireContext函數(shù)，用于獲取或創(chuàng)建與加密服務(wù)提供程序（CSP）相關(guān)聯(lián)的密碼學上下文。這個函數(shù)的目的是為了建立與加密服務(wù)提供程序相關(guān)的密碼學上下文，使得后續(xù)的加密操作可以在這個上下文中進行。
以下是CryptAcquireContext函數(shù)的一般格式：
BOOL CryptAcquireContext( HCRYPTPROV *phProv, LPCTSTR pszContainer, LPCTSTR pszProvider, DWORD dwProvType, DWORD dwFlags );
phProv: 一個指向HCRYPTPROV類型的指針，用于接收密碼學上下文的句柄。pszContainer: 字符串，指定與密鑰集關(guān)聯(lián)的容器名稱。可以為NULL，表示不使用容器。pszProvider: 字符串，指定要使用的CSP的名稱。如果為NULL，將使用默認的提供程序。dwProvType: 指定CSP的類型。例如，PROV_RSA_FULL表示使用RSA算法的提供程序。dwFlags: 指定標志，控制函數(shù)的行為。例如，CRYPT_VERIFYCONTEXT表示驗證上下文，而不是嘗試使用特定的密鑰。
CryptCreateHash 函數(shù)，用于創(chuàng)建一個與密碼學上下文相關(guān)聯(lián)的哈希對象。哈希對象可用于計算數(shù)據(jù)的哈希值，常用于數(shù)字簽名、數(shù)據(jù)完整性驗證等安全操作。
以下是CryptCreateHash函數(shù)的一般格式：
BOOL CryptCreateHash( HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey, DWORD dwFlags, HCRYPTHASH *phHash );
hProv: 與哈希對象關(guān)聯(lián)的密碼學上下文的句柄。Algid: 哈希算法的標識，例如CALG_MD5表示MD5算法。hKey: 與哈希對象關(guān)聯(lián)的密鑰。在哈希計算中，通常不需要密鑰，因此可以將其設(shè)為NULL。dwFlags: 控制函數(shù)的行為的標志。一般設(shè)為0。phHash: 一個指向HCRYPTHASH類型的指針，用于接收哈希對象的句柄。
成功調(diào)用該函數(shù)后，phHash將包含一個指向新創(chuàng)建的哈希對象的句柄，該對象與指定的密碼學上下文和哈希算法相關(guān)聯(lián)。
CryptHashData函數(shù)，用于將數(shù)據(jù)添加到哈希對象中，從而更新哈希值。它常用于在計算數(shù)字簽名或驗證數(shù)據(jù)完整性時，逐步處理數(shù)據(jù)塊并更新哈希值。
以下是CryptHashData函數(shù)的一般格式：
BOOL CryptHashData( HCRYPTHASH hHash, const BYTE *pbData, DWORD dwDataLen, DWORD dwFlags );
hHash: 指向哈希對象的句柄。pbData: 指向包含要添加到哈希對象的數(shù)據(jù)的緩沖區(qū)的指針。dwDataLen: 數(shù)據(jù)緩沖區(qū)的字節(jié)數(shù)。dwFlags: 控制函數(shù)的行為的標志。一般設(shè)為0。
成功調(diào)用后，哈希對象的狀態(tài)將被更新以反映已添加的數(shù)據(jù)，從而計算新的哈希值。這使得可以逐步處理大型數(shù)據(jù)，而不需要將整個數(shù)據(jù)加載到內(nèi)存中。
CryptDeriveKey 函數(shù)，用于從一個密碼導(dǎo)出密鑰。這個函數(shù)通常用于從用戶提供的密碼生成對稱密鑰，這樣就可以用于加密或解密數(shù)據(jù)。
以下是 CryptDeriveKey 函數(shù)的一般格式：
BOOL CryptDeriveKey( HCRYPTPROV hProv, ALG_ID Algid, HCRYPTHASH hBaseData, DWORD dwFlags, HCRYPTKEY *phKey );
hProv: 一個有效的 CSP（Cryptographic Service Provider）句柄。Algid: 密鑰算法標識符，指定要創(chuàng)建的密鑰類型。hBaseData: 與密鑰生成相關(guān)的基本數(shù)據(jù)的哈希對象的句柄。可以為NULL。dwFlags: 控制函數(shù)的行為的標志。一般設(shè)為 0。phKey: 指向 HCRYPTKEY 類型的指針，用于接收生成的密鑰的句柄。
成功調(diào)用后，phKey 將包含一個新的密鑰句柄，可以用于后續(xù)的加密和解密操作。密鑰的具體屬性（比如大?。┯?nbsp;Algid 參數(shù)決定。
CryptEncrypt 函數(shù)，用于對數(shù)據(jù)進行加密。這個函數(shù)通常用于加密一個數(shù)據(jù)塊，例如一個文件或一個消息。
以下是 CryptEncrypt 函數(shù)的一般格式：
BOOL CryptEncrypt( HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final, DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen, DWORD dwBufLen );
hKey: 用于加密數(shù)據(jù)的密鑰的句柄。hHash: 句柄，指定一個哈希對象。對稱算法不需要哈希，因此可以為NULL。Final: 指定是否是最后一個數(shù)據(jù)塊。如果是最后一個數(shù)據(jù)塊，將設(shè)置為TRUE。dwFlags: 控制函數(shù)的行為的標志。一般設(shè)為 0。pbData: 指向要加密的數(shù)據(jù)的指針。pdwDataLen: 指向一個變量，用于輸入數(shù)據(jù)的大小，輸出加密后數(shù)據(jù)的大小。dwBufLen: 緩沖區(qū)的大小。
成功調(diào)用后，pbData 將包含加密后的數(shù)據(jù)。pdwDataLen 將包含加密后數(shù)據(jù)的實際大小。
CryptDecrypt 函數(shù)，用于對數(shù)據(jù)進行解密。這個函數(shù)通常用于解密一個數(shù)據(jù)塊，例如一個文件或一個消息。
以下是 CryptDecrypt 函數(shù)的一般格式：
BOOL CryptDecrypt( HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final, DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen );
hKey: 用于解密數(shù)據(jù)的密鑰的句柄。hHash: 句柄，指定一個哈希對象。對稱算法不需要哈希，因此可以為NULL。Final: 指定是否是最后一個數(shù)據(jù)塊。如果是最后一個數(shù)據(jù)塊，將設(shè)置為TRUE。dwFlags: 控制函數(shù)的行為的標志。一般設(shè)為 0。pbData: 指向要解密的數(shù)據(jù)的指針。pdwDataLen: 指向一個變量，用于輸入解密前數(shù)據(jù)的大小，輸出解密后數(shù)據(jù)的大小。
成功調(diào)用后，pbData 將包含解密后的數(shù)據(jù)。pdwDataLen 將包含解密后數(shù)據(jù)的實際大小。
#include <stdio.h>
#include <Windows.h>
// AES加密
BOOL AesEncrypt(BYTE* pPassword, BYTE* pData, DWORD& dwDataLength, DWORD dwBufferLength)
{
BOOL bRet = TRUE;
HCRYPTPROV hCryptProv = NULL;
HCRYPTHASH hCryptHash = NULL;
HCRYPTKEY hCryptKey = NULL;
DWORD dwPasswordLength = strlen((char*)pPassword);
do
{
bRet = CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT);
bRet = CryptCreateHash(hCryptProv, CALG_MD5, NULL, 0, &hCryptHash);
bRet = CryptHashData(hCryptHash, pPassword, dwPasswordLength, 0);
bRet = CryptDeriveKey(hCryptProv, CALG_AES_128, hCryptHash, CRYPT_EXPORTABLE, &hCryptKey);
bRet = CryptEncrypt(hCryptKey, NULL, TRUE, 0, pData, &dwDataLength, dwBufferLength);
} while (FALSE);
if (hCryptKey || hCryptHash || hCryptProv)
{
CryptDestroyKey(hCryptKey);
CryptDestroyHash(hCryptHash);
CryptReleaseContext(hCryptProv, 0);
}
return bRet;
}
// AES解密
BOOL AesDecrypt(BYTE* pPassword, BYTE* pData, DWORD& dwDataLength, DWORD dwBufferLength)
{
BOOL bRet = TRUE;
HCRYPTPROV hCryptProv = NULL;
HCRYPTHASH hCryptHash = NULL;
HCRYPTKEY hCryptKey = NULL;
DWORD dwPasswordLength = strlen((char*)pPassword);
do
{
bRet = CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT);
bRet = CryptCreateHash(hCryptProv, CALG_MD5, NULL, 0, &hCryptHash);
bRet = CryptHashData(hCryptHash, pPassword, dwPasswordLength, 0);
bRet = CryptDeriveKey(hCryptProv, CALG_AES_128, hCryptHash, CRYPT_EXPORTABLE, &hCryptKey);
bRet = CryptDecrypt(hCryptKey, NULL, TRUE, 0, pData, &dwDataLength);
} while (FALSE);
if (hCryptKey || hCryptHash || hCryptProv)
{
CryptDestroyKey(hCryptKey);
CryptDestroyHash(hCryptHash);
CryptReleaseContext(hCryptProv, 0);
}
return bRet;
}
int main(int argc, char* argv[])
{
BYTE pData[MAX_PATH] = { 0 };
DWORD dwDataLength = 0;
char* Msg = (char *)"hello lyshark";
strcpy((char*)pData, Msg);
dwDataLength = 1 + ::strlen((char*)pData);
// AES 加密
AesEncrypt((BYTE*)"123321", pData, dwDataLength, MAX_PATH);
printf("AES 加密長度: %d 加密后: %s \n", dwDataLength, pData);
// AES 解密
AesDecrypt((BYTE*)"123321", pData, dwDataLength, MAX_PATH);
printf("AES 解密長度: %d 解密后: %s \n", dwDataLength, pData);
system("pause");
return 0;
}
上述代碼運行，實現(xiàn)對特定字符串hello lyshark加密，并使用密碼123321，如下圖所示；
MD5/SHA256單向加解密
MD5（Message Digest Algorithm 5）是一種廣泛使用的哈希函數(shù)，常用于生成數(shù)據(jù)的數(shù)字簽名。MD5 產(chǎn)生的哈希值（摘要）通常是一個 128 位的十六進制數(shù)字，通常表示為 32 個字符。盡管 MD5 在過去廣泛用于校驗文件完整性和生成密碼散列，但由于其容易受到碰撞攻擊的影響，現(xiàn)在已被更安全的哈希算法如 SHA-256 取代。
MD5 是一種不可逆的哈希函數(shù)，其核心原理包括以下幾步：
- 填充： 對輸入數(shù)據(jù)進行填充，使其長度滿足 512 位的倍數(shù)，并在數(shù)據(jù)尾部附加原始數(shù)據(jù)長度的二進制表示。
- 初始化： 初始化 128 位的緩沖區(qū)，用于存儲中間計算結(jié)果。
- 處理塊： 將填充后的數(shù)據(jù)按照 512 位的塊進行劃分，每個塊進行一系列的運算，更新緩沖區(qū)。
- 輸出： 將最終得到的緩沖區(qū)內(nèi)容作為 MD5 的輸出。
MD5 的核心操作主要包括四輪循環(huán)，每輪循環(huán)包含 16 次操作。這些操作涉及位運算、邏輯運算和模運算等，以及對緩沖區(qū)內(nèi)容的不斷更新。
SHA-256（Secure Hash Algorithm 256-bit）是 SHA-2 家族中的一員，是一種廣泛使用的密碼哈希函數(shù)。SHA-256 生成的哈希值長度為 256 位，通常以 64 個字符的十六進制字符串表示。SHA-256 在密碼學和數(shù)據(jù)完整性驗證中得到廣泛應(yīng)用，被認為是一種安全可靠的哈希算法。
SHA-256 的基本原理與 MD5 類似，但具有更復(fù)雜的設(shè)計和更長的輸出長度。其核心過程包括以下幾個步驟：
- 填充： 將輸入數(shù)據(jù)填充到滿足 512 位塊大小的倍數(shù)，并在數(shù)據(jù)尾部添加原始數(shù)據(jù)長度的二進制表示。
- 初始化： 初始化 256 位的緩沖區(qū)，用于存儲中間計算結(jié)果。
- 處理塊： 將填充后的數(shù)據(jù)按照 512 位的塊進行劃分，每個塊進行一系列的運算，更新緩沖區(qū)。
- 輸出： 將最終得到的緩沖區(qū)內(nèi)容作為 SHA-256 的輸出。
SHA-256 的核心操作包括四輪循環(huán)，每輪循環(huán)包含 64 次操作。這些操作包括位運算、邏輯運算、模運算等，以及對緩沖區(qū)內(nèi)容的不斷更新。
CryptAcquireContext 函數(shù)，用于獲取密碼學上下文句柄。這個函數(shù)通常是在進行加密和解密操作之前調(diào)用的第一步。
以下是 CryptAcquireContext 函數(shù)的一般格式：
BOOL CryptAcquireContext( HCRYPTPROV *phProv, LPCTSTR pszContainer, LPCTSTR pszProvider, DWORD dwProvType, DWORD dwFlags );
phProv: 用于接收密碼學上下文句柄的指針。pszContainer: 指定密鑰容器的名稱?？梢詾?nbsp;NULL。pszProvider: 指定加密服務(wù)提供者的名稱?？梢詾?nbsp;NULL。dwProvType: 指定提供者類型。常見的類型包括PROV_RSA_FULL、PROV_RSA_AES等。dwFlags: 控制函數(shù)的行為的標志。通常為 0。
成功調(diào)用后，phProv 將包含一個密碼學上下文句柄，該句柄用于后續(xù)的加密和解密操作。
CryptGetHashParam 函數(shù)，用于檢索哈希對象的參數(shù)。哈希對象是用于計算數(shù)據(jù)摘要的對象，通常在密碼學操作中使用。
以下是 CryptGetHashParam 函數(shù)的一般格式：
BOOL CryptGetHashParam( HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, DWORD *pdwDataLen, DWORD dwFlags );
hHash: 哈希對象的句柄。dwParam: 指定要檢索的參數(shù)類型。常見的參數(shù)類型包括HP_HASHVAL（獲取哈希值）和HP_HASHSIZE（獲取哈希值的大?。┑?。pbData: 用于接收參數(shù)數(shù)據(jù)的緩沖區(qū)。pdwDataLen: 用于指定輸入緩沖區(qū)的大小，并在成功調(diào)用后包含實際返回的數(shù)據(jù)長度。dwFlags: 控制函數(shù)的行為的標志。通常為 0。
成功調(diào)用后，pbData 緩沖區(qū)中將包含請求的參數(shù)數(shù)據(jù)。
CryptDestroyHash 函數(shù)，用于銷毀哈希對象。哈希對象是在進行哈希計算時創(chuàng)建的對象，使用完畢后需要通過 CryptDestroyHash 來釋放相關(guān)資源。
以下是 CryptDestroyHash 函數(shù)的一般格式：
BOOL CryptDestroyHash( HCRYPTHASH hHash );
hHash: 要銷毀的哈希對象的句柄。
函數(shù)返回一個布爾值，表示是否成功銷毀哈希對象。如果成功，返回 TRUE，否則返回 FALSE。
CryptReleaseContext 函數(shù)，用于釋放密碼學上下文。密碼學上下文是在進行加密或哈希操作時所創(chuàng)建的，使用完畢后需要通過 CryptReleaseContext 來釋放相關(guān)資源。
以下是 CryptReleaseContext 函數(shù)的一般格式：
BOOL CryptReleaseContext( HCRYPTPROV hProv, DWORD dwFlags );
hProv: 要釋放的密碼學上下文的句柄。
dwFlags: 一組標志，通?？梢栽O(shè)置為零。
函數(shù)返回一個布爾值，表示是否成功釋放密碼學上下文。如果成功，返回 TRUE，否則返回 FALSE。
這兩個算法都是單向加密算法，其可以將一段任意字符串壓縮為一個唯一常數(shù)。
#include <stdio.h>
#include <Windows.h>
BOOL CalculateHash(BYTE* pData, DWORD dwDataLength, ALG_ID algHashType, BYTE** ppHashData, DWORD* pdwHashDataLength)
{
HCRYPTPROV hCryptProv = NULL;
HCRYPTHASH hCryptHash = NULL;
BYTE* pHashData = NULL;
DWORD dwHashDataLength = 0;
DWORD dwTemp = 0;
BOOL bRet = FALSE;
do
{
bRet = CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT);
bRet = CryptCreateHash(hCryptProv, algHashType, NULL, NULL, &hCryptHash);
bRet = CryptHashData(hCryptHash, pData, dwDataLength, 0);
dwTemp = sizeof(dwHashDataLength);
bRet = CryptGetHashParam(hCryptHash, HP_HASHSIZE, (BYTE*)(&dwHashDataLength), &dwTemp, 0);
pHashData = new BYTE[dwHashDataLength];
RtlZeroMemory(pHashData, dwHashDataLength);
bRet = ::CryptGetHashParam(hCryptHash, HP_HASHVAL, pHashData, &dwHashDataLength, 0);
*ppHashData = pHashData;
*pdwHashDataLength = dwHashDataLength;
} while (FALSE);
if (FALSE == bRet)
{
if (pHashData)
{
delete[]pHashData;
pHashData = NULL;
}
}
if (hCryptHash || hCryptProv)
{
CryptDestroyHash(hCryptHash);
CryptReleaseContext(hCryptProv, 0);
}
return bRet;
}
int main(int argc, char* argv[])
{
char szBuf[1024] = "hello lyshark";
BYTE* pHashData = NULL;
DWORD dwHashDataLength = 0;
// MD5
CalculateHash((BYTE *)szBuf, strlen(szBuf), CALG_MD5, &pHashData, &dwHashDataLength);
for (DWORD x = 0; x < dwHashDataLength; x++)
{
printf("%x", pHashData[x]);
}
printf("\n");
// SHA256
CalculateHash((BYTE *)szBuf, strlen(szBuf), CALG_SHA_256, &pHashData, &dwHashDataLength);
for (DWORD x = 0; x < dwHashDataLength; x++)
{
printf("%x", pHashData[x]);
}
delete[]pHashData;
pHashData = NULL;
system("pause");
return 0;
}
上述代碼運行后，則可以計算出hello lyshark字符串的md5以及sha256摘要信息，如下所示；
RSA對稱加解密
RSA（Rivest–Shamir–Adleman）是一種非對稱加密算法，于1977年由羅納德·李維斯特（Ron Rivest）、阿迪·薩米爾（Adi Shamir）和倫納德·阿德曼（Leonard Adleman）三位密碼學家提出。RSA算法基于兩個大素數(shù)的乘積的難解性問題，它廣泛用于安全通信和數(shù)字簽名等領(lǐng)域。
RSA算法涉及到兩個密鑰：公鑰和私鑰。其中，公鑰用于加密，私鑰用于解密。其基本原理建立在兩個數(shù)論問題上：
- 大整數(shù)分解問題： 將一個大合數(shù)分解為兩個質(zhì)數(shù)的乘積的難度。
- 歐拉函數(shù)和模反演問題： 利用歐拉函數(shù)和模反演性質(zhì)，確保僅有私鑰的持有者能夠有效地解密。
RSA算法的密鑰生成過程包括以下步驟：
- 選擇兩個大素數(shù) p 和 q。
- 計算 n = pq，n 稱為模數(shù)。
- 計算歐拉函數(shù) φ(n) = (p-1)(q-1)。
- 選擇公鑰 e，滿足 1 < e < φ(n)，且 e 與 φ(n) 互質(zhì)。
- 計算私鑰 d，使得 de ≡ 1 (mod φ(n))。
公鑰是 (n, e)，私鑰是 (n, d)。
加密和解密過程如下：
RSA算法的安全性基于大整數(shù)分解問題的困難性，即在已知 n 的情況下，要找到 p 和 q 的乘積。當 n 非常大時，這一過程變得非常耗時，使得RSA算法在當前的計算資源下被廣泛應(yīng)用于加密通信和數(shù)字簽名。
CryptGenKey 是 Windows Cryptographic API (CryptoAPI) 中的一個函數(shù)，用于生成密鑰。該函數(shù)允許應(yīng)用程序生成對稱密鑰、非對稱密鑰對以及用于哈希的密鑰。
以下是 CryptGenKey 函數(shù)的一般格式：
BOOL CryptGenKey( HCRYPTPROV hProv, ALG_ID Algid, DWORD dwFlags, HCRYPTKEY *phKey );
hProv: 用于生成密鑰的密碼學服務(wù)提供者 (CSP) 的句柄。Algid: 標識要生成的密鑰類型，可以是對稱密鑰算法、非對稱密鑰算法或用于哈希的密鑰算法。dwFlags: 控制密鑰生成的標志。對于不同的密鑰類型，可能有不同的標志。phKey: 生成的密鑰的句柄。
函數(shù)返回一個布爾值，表示是否成功生成密鑰。如果成功，返回 TRUE，否則返回 FALSE。
CryptExportKey 函數(shù)是 Windows Cryptographic API (CryptoAPI) 中的一個函數(shù)，用于導(dǎo)出密鑰的原始或簡單 BLOB 格式。密鑰 BLOB 包含密鑰的完整信息，以便在不同的系統(tǒng)或進程之間傳輸密鑰。
以下是 CryptExportKey 函數(shù)的一般格式：
BOOL CryptExportKey( HCRYPTKEY hKey, HCRYPTKEY hExpKey, DWORD dwBlobType, DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen );
hKey: 要導(dǎo)出的密鑰的句柄。hExpKey: 導(dǎo)出密鑰的密碼學服務(wù)提供者 (CSP) 句柄。通常，使用與hKey相同的 CSP。dwBlobType: 導(dǎo)出的 BLOB 類型，可以是簡單 BLOB 或原始 BLOB。dwFlags: 導(dǎo)出操作的標志。pbData: 用于接收導(dǎo)出的密鑰 BLOB 的緩沖區(qū)。pdwDataLen: 指向存儲密鑰 BLOB 大小的變量的指針。在調(diào)用函數(shù)之前，應(yīng)將其設(shè)置為緩沖區(qū)的大??；在調(diào)用函數(shù)后，它將包含實際寫入緩沖區(qū)的字節(jié)數(shù)。
函數(shù)返回一個布爾值，表示是否成功導(dǎo)出密鑰。如果成功，返回 TRUE，否則返回 FALSE。
CryptImportKey 函數(shù)是 Windows Cryptographic API (CryptoAPI) 中的一個函數(shù)，用于導(dǎo)入密鑰的原始或簡單 BLOB 格式。該函數(shù)通常與 CryptExportKey 函數(shù)一起使用，用于在不同的系統(tǒng)或進程之間傳輸密鑰。
以下是 CryptImportKey 函數(shù)的一般格式：
BOOL CryptImportKey( HCRYPTPROV hProv, const BYTE *pbData, DWORD dwDataLen, HCRYPTKEY hPubKey, DWORD dwFlags, HCRYPTKEY *phKey );
hProv: 密鑰將與之關(guān)聯(lián)的密碼學服務(wù)提供者 (CSP) 的句柄。pbData: 包含要導(dǎo)入的密鑰 BLOB 的緩沖區(qū)的指針。dwDataLen: 密鑰 BLOB 的長度（以字節(jié)為單位）。hPubKey: 用于解密密鑰 BLOB 的公鑰的句柄。dwFlags: 導(dǎo)入密鑰的標志。phKey: 指向?qū)氲拿荑€的句柄的指針。
函數(shù)返回一個布爾值，表示是否成功導(dǎo)入密鑰。如果成功，返回 TRUE，否則返回 FALSE。
RSA算法包括公鑰與私鑰兩部，加密時會先使用RSA生成公鑰與私鑰，然后在進行加密。
#include <iostream>
#include <Windows.h>
using namespace std;
// 生成公鑰和私鑰
BOOL GenerateKey(BYTE **ppPublicKey, DWORD *pdwPublicKeyLength, BYTE **ppPrivateKey, DWORD *pdwPrivateKeyLength)
{
BOOL bRet = TRUE;
HCRYPTPROV hCryptProv = NULL;
HCRYPTKEY hCryptKey = NULL;
BYTE *pPublicKey = NULL;
DWORD dwPublicKeyLength = 0;
BYTE *pPrivateKey = NULL;
DWORD dwPrivateKeyLength = 0;
do
{
bRet = CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL, 0);
if (FALSE == bRet)
break;
bRet = CryptGenKey(hCryptProv, AT_KEYEXCHANGE, CRYPT_EXPORTABLE, &hCryptKey);
if (FALSE == bRet)
break;
bRet = CryptExportKey(hCryptKey, NULL, PUBLICKEYBLOB, 0, NULL, &dwPublicKeyLength);
if (FALSE == bRet)
break;
pPublicKey = new BYTE[dwPublicKeyLength];
RtlZeroMemory(pPublicKey, dwPublicKeyLength);
bRet = CryptExportKey(hCryptKey, NULL, PUBLICKEYBLOB, 0, pPublicKey, &dwPublicKeyLength);
if (FALSE == bRet)
break;
bRet = CryptExportKey(hCryptKey, NULL, PRIVATEKEYBLOB, 0, NULL, &dwPrivateKeyLength);
if (FALSE == bRet)
break;
pPrivateKey = new BYTE[dwPrivateKeyLength];
RtlZeroMemory(pPrivateKey, dwPrivateKeyLength);
bRet = CryptExportKey(hCryptKey, NULL, PRIVATEKEYBLOB, 0, pPrivateKey, &dwPrivateKeyLength);
if (FALSE == bRet)
break;
*ppPublicKey = pPublicKey;
*pdwPublicKeyLength = dwPublicKeyLength;
*ppPrivateKey = pPrivateKey;
*pdwPrivateKeyLength = dwPrivateKeyLength;
} while (FALSE);
if (hCryptKey)
CryptDestroyKey(hCryptKey);
if (hCryptProv)
CryptReleaseContext(hCryptProv, 0);
return bRet;
}
// 公鑰加密數(shù)據(jù)
BOOL RsaEncrypt(BYTE *pPublicKey, DWORD dwPublicKeyLength, BYTE *pData, DWORD &dwDataLength, DWORD dwBufferLength)
{
BOOL bRet = TRUE;
HCRYPTPROV hCryptProv = NULL;
HCRYPTKEY hCryptKey = NULL;
do
{
bRet = CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL, 0);
if (FALSE == bRet)
break;
bRet = CryptImportKey(hCryptProv, pPublicKey, dwPublicKeyLength, NULL, 0, &hCryptKey);
if (FALSE == bRet)
break;
bRet = CryptEncrypt(hCryptKey, NULL, TRUE, 0, pData, &dwDataLength, dwBufferLength);
if (FALSE == bRet)
break;
} while (FALSE);
if (hCryptKey)
CryptDestroyKey(hCryptKey);
if (hCryptProv)
CryptReleaseContext(hCryptProv, 0);
return bRet;
}
// 私鑰解密數(shù)據(jù)
BOOL RsaDecrypt(BYTE *pPrivateKey, DWORD dwProvateKeyLength, BYTE *pData, DWORD &dwDataLength)
{
BOOL bRet = TRUE;
HCRYPTPROV hCryptProv = NULL;
HCRYPTKEY hCryptKey = NULL;
do
{
bRet = CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL, 0);
if (FALSE == bRet)
break;
bRet = CryptImportKey(hCryptProv, pPrivateKey, dwProvateKeyLength, NULL, 0, &hCryptKey);
if (FALSE == bRet)
break;
bRet = CryptDecrypt(hCryptKey, NULL, TRUE, 0, pData, &dwDataLength);
if (FALSE == bRet)
break;
} while (FALSE);
if (hCryptKey)
CryptDestroyKey(hCryptKey);
if (hCryptProv)
CryptReleaseContext(hCryptProv, 0);
return bRet;
}
int main(int argc, char * argv[])
{
BYTE *pPublicKey = NULL;
DWORD dwPublicKeyLength = 0;
BYTE *pPrivateKey = NULL;
DWORD dwPrivateKeyLength = 0;
BYTE *pData = NULL;
DWORD dwDataLength = 0;
DWORD dwBufferLength = 4096;
pData = new BYTE[dwBufferLength];
RtlZeroMemory(pData, dwBufferLength);
lstrcpy((char *)pData, "hello lyshark");
dwDataLength = 1 + lstrlen((char *)pData);
// 輸出加密前原始數(shù)據(jù)
printf("加密前原始數(shù)據(jù): ");
for (int i = 0; i < dwDataLength; i++)
printf("%x", pData[i]);
printf("\n\n");
// 生成公鑰和私鑰
GenerateKey(&pPublicKey, &dwPublicKeyLength, &pPrivateKey, &dwPrivateKeyLength);
printf("公鑰: ");
for (int i = 0; i < dwPublicKeyLength; i++)
printf("%.2x", pPublicKey[i]);
printf("\n\n");
printf("私鑰: ");
for (int i = 0; i < dwPrivateKeyLength; i++)
printf("%.2x", pPrivateKey[i]);
printf("\n\n");
// 使用公鑰加密
RsaEncrypt(pPublicKey, dwPublicKeyLength, pData, dwDataLength, dwBufferLength);
printf("公鑰加密: ");
for (int i = 0; i < dwDataLength; i++)
printf("%x", pData[i]);
printf("\n\n");
// 使用私鑰解密
RsaDecrypt(pPrivateKey, dwPrivateKeyLength, pData, dwDataLength);
printf("私鑰解密: ");
for (int i = 0; i < dwDataLength; i++)
printf("%x", pData[i]);
printf("\n\n");
delete[]pData;
delete[]pPrivateKey;
delete[]pPublicKey;
system("pause");
return 0;
}
運行后生成公鑰與私鑰，并對字符串加密與解密，如下圖所示；
以上就是C/C++中常用加密與解密算法的實現(xiàn)的詳細內(nèi)容，更多關(guān)于C++加密與解密算法的資料請關(guān)注腳本之家其它相關(guān)文章！
相關(guān)文章
Matlab實現(xiàn)繪制有氣泡感的網(wǎng)絡(luò)圖
這篇文章主要介紹了如何利用Matlab實現(xiàn)繪制有氣泡感的網(wǎng)絡(luò)圖，文中的示例代碼講解詳細，對我們學習Matlab有一定的幫助，需要的可以參考一下2023-02-02
這篇文章主要介紹了C++11顯示類型轉(zhuǎn)換的優(yōu)點，幫助大家更好的理解和學習c++，感興趣的朋友可以了解下2020-08-08
這篇文章主要為大家詳細介紹了C語言實現(xiàn)貪吃蛇小黑窗，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-01-01
詳解C++值多態(tài)中的傳統(tǒng)多態(tài)與類型擦除
值多態(tài)是一種介于傳統(tǒng)多態(tài)與類型擦除之間的多態(tài)實現(xiàn)方式，借鑒了值語義，保留了繼承，在單繼承的適用范圍內(nèi)，程序和程序員都能從中受益。這篇文章主要介紹了C++值多態(tài)中的傳統(tǒng)多態(tài)與類型擦除,需要的朋友可以參考下2020-04-04
這篇文章主要介紹了Boost.Asio 的多線程模型的相關(guān)知識，文中代碼非常詳細，供大家參考和學習，感興趣的朋友可以了解下2020-06-06
這篇文章主要介紹了C++異步調(diào)用方法,本文通過實例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2023-05-05
這篇文章主要介紹了C++ template用法案例詳解,本篇文章通過簡要的案例,講解了該項技術(shù)的了解與使用,以下就是詳細內(nèi)容,需要的朋友可以參考下2021-09-09
這篇文章主要介紹了總結(jié)了24個C++的大坑,你能躲過幾個，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2021-05-05
VS2017+Qt5+Opencv3.4調(diào)用攝像頭拍照并存儲
本文主要介紹了VS2017+Qt5+Opencv3.4調(diào)用攝像頭拍照并存儲，實現(xiàn)了視頻，拍照，保存這三個功能。具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-05-05
這篇文章主要介紹了C++中的模板類&模板函數(shù)用法,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2023-08-08