14.11 Socket 基於時間加密通訊
2023-10-19 06:01:19
在之前的程式碼中我們並沒有對通訊端進行加密，在未加密狀態下我們所有的通訊內容都是明文傳輸的，這種方式在學習時可以使用但在真正的開發環境中必須要對封包進行加密，此處筆者將演示一種基於時間的加密方法，該加密方法的優勢是封包每次傳送均不一致，但封包內的內容是一致的，當抓包後會發現每次傳輸的封包密文是隨機變化的，但內容始終保持一致，也就是說兩個擁有相同內容的資料被加密後，封包密文不同，其主要運用了基於當前時間戳的通訊機制。
14.11.1 實現加鹽函數
加鹽函數此處筆者採用基於時間的加鹽方式，取出使用者分鐘數與秒數並生成亂數作為鹽，通過三者的混合計算出一串解密金鑰對，此方法的必須保證伺服器端與使用者端時間同步，如果不同步則無法計算出正確的金鑰對，解密也就無法繼續了。
程式碼中函數GenRandomString用於實現生成一個亂數，該函數接受一個亂數長度並返回一個字串。接著GetPasswordSalt_OnSec與GetPasswordSalt_OnMin函數分別用於根據當前秒與分鐘生成一個隨機的鹽，函數GetXorKey則用於對特定一段字串進行互斥或處理並生成一個Key，函數CRC32則用於對字串計算得到一個雜湊值。
#include <WinSock2.h>
#include <Windows.h>
#include <iostream>
#include <random>
#include <time.h>
#pragma comment(lib,"ws2_32.lib")
using namespace std;
typedef struct
{
char random[1024];
char Buffer[4096];
}SocketPackage;
// 產生長度為length的隨機字串
char* GenRandomString(int length)
{
int flag, i;
char* string;
srand((unsigned)time(NULL));
if ((string = (char*)malloc(length)) == NULL)
{
return NULL;
}
for (i = 0; i < length - 1; i++)
{
flag = rand() % 3;
switch (flag)
{
case 0:
string[i] = 'A' + rand() % 26;
break;
case 1:
string[i] = 'a' + rand() % 26;
break;
case 2:
string[i] = '0' + rand() % 10;
break;
default:
string[i] = 'x';
break;
}
}
string[length - 1] = '\0';
return string;
}
// 通過秒數生成鹽
int GetPasswordSalt_OnSec()
{
time_t nowtime;
struct tm* p;;
time(&nowtime);
p = localtime(&nowtime);
if (p->tm_sec <= 10)
return 2;
else if (p->tm_sec > 10 && p->tm_sec <= 20)
return 5;
else if (p->tm_sec > 20 && p->tm_sec <= 30)
return 8;
else if (p->tm_sec > 30 && p->tm_sec <= 40)
return 4;
else if (p->tm_sec > 40 && p->tm_sec <= 50)
return 9;
else
return 3;
}
// 通過分鐘生成鹽
int GetPasswordSalt_OnMin()
{
time_t nowtime;
struct tm* p;;
time(&nowtime);
p = localtime(&nowtime);
return p->tm_min;
}
// 獲取互斥或整數
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 + (GetPasswordSalt_OnSec() * GetPasswordSalt_OnMin()) + cCode[x];
}
return Xor_Key;
}
// 計算CRC32校驗和
DWORD CRC32(char* ptr, DWORD Size)
{
DWORD crcTable[256], crcTmp1;
// 動態生成CRC-32表
for (int i = 0; i < 256; i++)
{
crcTmp1 = i;
for (int j = 8; j > 0; j--)
{
if (crcTmp1 & 1) crcTmp1 = (crcTmp1 >> 1) ^ 0xEDB88320L;
else crcTmp1 >>= 1;
}
crcTable[i] = crcTmp1;
}
// 計算CRC32值
DWORD crcTmp2 = 0xFFFFFFFF;
while (Size--)
{
crcTmp2 = ((crcTmp2 >> 8) & 0x00FFFFFF) ^ crcTable[(crcTmp2 ^ (*ptr)) & 0xFF];
ptr++;
}
return (crcTmp2 ^ 0xFFFFFFFF);
}
int main(int argc, char *argv[])
{
// 生成一個亂數作為鹽
char* uuid = GenRandomString(7);
std::cout << "亂數: " << uuid << std::endl;
int sec_key = GetPasswordSalt_OnSec();
std::cout << "根據秒數生成鹽: " << sec_key << std::endl;
int min_key = GetPasswordSalt_OnMin();
std::cout << "根據分鐘生成鹽: " << min_key << std::endl;
// 傳入亂數作為金鑰對,生成最終金鑰
long key = GetXorKey(uuid);
std::cout << "最終金鑰: " << key << std::endl;
int crc32 = CRC32(uuid, 10);
std::cout << "crc32: " << hex << crc32 << std::endl;
system("pause");
return 0;
}
14.11.2 實現加密函數
對於加密函數SendEncryptionPage的實現流程，首先在傳送封包之前呼叫GenRandomString()生成一個7位的亂數，並將亂數拷貝到pack.random結構內，接著呼叫互斥或函數GetXorKey(uuid)生成加密金鑰，並依次迴圈對pack.Buffer中的資料進行逐位元組加密。最後將加密封包傳送出去，並接著計算該封包的CRC32值，並再次通過send()函數將其傳送給使用者端。
// 加密封包並行送
bool SendEncryptionPage(SOCKET* ptr, char* send_data)
{
char buf[8192] = { 0 };
SocketPackage pack;
memset(buf, 0, 8192);
// 生成亂數並拷貝到結構體
char* uuid = GenRandomString(7);
strcpy(pack.random, uuid);
std::cout << "[使用者端] 本次隨機金鑰對: " << uuid << std::endl;
// 生成並拷貝加密資料
strcpy(pack.Buffer, send_data);
int key = GetXorKey(uuid);
std::cout << " --> 生成隨機 key = " << key << std::endl;
for (int x = 0; x < strlen(pack.Buffer); x++)
{
pack.Buffer[x] = pack.Buffer[x] ^ key;
}
// 加密封包並行送
memcpy(buf, &pack, sizeof(SocketPackage));
send(*ptr, buf, sizeof(buf), 0);
// 計算CRC32校驗和,並行送給伺服器端
DWORD crc32 = CRC32(buf, 100);
char send_crc32[1024] = { 0 };
sprintf(send_crc32, "%x", crc32);
std::cout << " --> 傳送CRC32校驗和 = " << send_crc32 << std::endl;
// 傳送CRC32計算結果
send(*ptr, send_crc32, sizeof(send_crc32), 0);
return true;
}
14.11.3 實現解密函數
解密函數RecvDecryptPage的實現流程與加密函數需要對應，首先當收到加密後的封包時，該封包會被存入buf變數記憶體儲，並強制型別轉為結構體。接著呼叫GetXorKey函數生成亂數，該亂數是通過本機時間通過分鐘與秒數生成的鹽，並與使用者密碼進行互斥或得到。通過接收伺服器端發過來的CRC32校驗碼，比對原始封包有沒有被修改過，該校驗碼是伺服器端通過封包生成的，最後使用者端計算收到的封包CRC32是否與伺服器端一致，一致則繼續執行互斥或迴圈對封包進行逐位元組解包。
// 接收封包並解密
char* RecvDecryptPage(SOCKET *ptr)
{
char buf[8192] = { 0 };
// 接收加密後的封包
memset(buf, 0, sizeof(buf));
recv(*ptr, buf, sizeof(buf), 0);
SocketPackage* pack = (SocketPackage*)buf;
// 接收亂數並獲取互斥或金鑰
int key = GetXorKey(pack->random);
std::cout << "[伺服器端] 基於時間計算 key = " << key << std::endl;
// 伺服器端驗證網路CRC32封包是否一致
char recv_crc32[1024] = { 0 };
recv(*ptr, recv_crc32, sizeof(recv_crc32), 0);
std::cout << " --> 收到使用者端CRC32校驗和 = " << recv_crc32 << std::endl;
// 計算CRC32是否與傳送值一致
DWORD crc32 = CRC32(buf, 100);
char this_crc32[1024] = { 0 };
sprintf(this_crc32, "%x", crc32);
std::cout << " --> 計算本地封包CRC32校驗和 = " << this_crc32 << std::endl;
if (strcmp(recv_crc32, this_crc32) == 0)
{
std::cout << " --> 校驗和一致" << std::endl;
// 開始解密封包
for (int x = 0; x < strlen(pack->Buffer); x++)
{
pack->Buffer[x] = pack->Buffer[x] ^ key;
}
std::cout << " --> 解密後的資料: " << pack->Buffer << std::endl;
std::cout << std::endl;
return pack->Buffer;
}
}
14.11.4 資料加密收發
當有了上述完整加解密函數的封裝之後讀者就可以通過使用通訊端的方法來實現封包的通訊，當需要接收資料時可以直接呼叫RecvDecryptPage()函數並傳入當前活動通訊端，而如果需要傳送資料則也只需要呼叫SendEncryptionPage()函數即可，由於函數已被封裝所以在傳輸資料時與普通通訊端函數的使用沒有任何區別。
針對伺服器端的主函數如下所示；
int main(int argc, char* argv[])
{
WSADATA WSAData;
SOCKET sock, msgsock;
struct sockaddr_in ServerAddr;
if (WSAStartup(MAKEWORD(2, 0), &WSAData) != SOCKET_ERROR)
{
ServerAddr.sin_family = AF_INET;
ServerAddr.sin_port = htons(9999);
ServerAddr.sin_addr.s_addr = INADDR_ANY;
sock = socket(AF_INET, SOCK_STREAM, 0);
bind(sock, (LPSOCKADDR)&ServerAddr, sizeof(ServerAddr));
listen(sock, 10);
}
while (1)
{
msgsock = accept(sock, (LPSOCKADDR)0, (int*)0);
// 接收資料並解密
char * recv_data = RecvDecryptPage(&msgsock);
std::cout << "獲取包內資料: " << recv_data << std::endl;
// 傳送資料
SendEncryptionPage(&msgsock, (char*)"ok");
std::cout << std::endl;
closesocket(msgsock);
}
closesocket(sock);
WSACleanup();
return 0;
}
針對使用者端的主函數如下所示；
int main(int argc, char* argv[])
{
while (1)
{
WSADATA WSAData;
SOCKET sock;
struct sockaddr_in ClientAddr;
if (WSAStartup(MAKEWORD(2, 0), &WSAData) != SOCKET_ERROR)
{
ClientAddr.sin_family = AF_INET;
ClientAddr.sin_port = htons(9999);
ClientAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
sock = socket(AF_INET, SOCK_STREAM, 0);
int Ret = connect(sock, (LPSOCKADDR)&ClientAddr, sizeof(ClientAddr));
if (Ret == 0)
{
// 傳送資料
char send_message[4096] = "hello lyshark";
SendEncryptionPage(&sock, send_message);
// 接收資料
char* recv_data = RecvDecryptPage(&sock);
std::cout << "接收封包: " << recv_data << std::endl;
std::cout << std::endl;
}
}
closesocket(sock);
WSACleanup();
Sleep(5000);
}
return 0;
}
讀者可自行將上述程式碼片段組合起來，並分別執行伺服器端與使用者端，當執行後讀者可看到如下圖所示的輸出資訊；
本文作者： 王瑞
本文連結： https://www.lyshark.com/post/f1f85090.html
版權宣告： 本部落格所有文章除特別宣告外，均採用 BY-NC-SA 許可協定。轉載請註明出處！
文章作者：lyshark
文章出處：https://www.cnblogs.com/LyShark/p/17773320.html
本部落格所有文章除特別宣告外，均採用 BY-NC-SA 許可協定。轉載請註明出處！
文章出處：https://www.cnblogs.com/LyShark/p/17773320.html
本部落格所有文章除特別宣告外，均採用 BY-NC-SA 許可協定。轉載請註明出處！