test.py:
import ctypes
lib = ctypes.CDLL('TCPSocket.dll')
def opaque_ptr(name):
cls = type(name, (ctypes.Structure,),{})
return ctypes.POINTER(cls)
class CTCPSocket(object):
_CTCPSocket = opaque_ptr('CPP_CTCPSocket')
lib.CTCPSocket_new.restype = _CTCPSocket
#lib.CTCPSocket_new.argtypes = ctypes.c_char_p,
lib.CTCPSocket_destruct.argtypes = _CTCPSocket,
lib.CTCPSocket_EncryptBuffer.argtypes = [_CTCPSocket,ctypes.c_char_p,ctypes.c_char_p,ctypes.c_int]
lib.CTCPSocket_EncryptBuffer.restype=ctypes.c_int
def __init__(self, func=lib.CTCPSocket_new):
self._obj = func()
def __del__(self):
self.destruct()
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
self.destruct()
def destruct(self, func=lib.CTCPSocket_destruct):
if self._obj:
func(self._obj)
self._obj = None
def CTCPSocket_EncryptBuffer(self,name,Encrypted,xlen, func=lib.CTCPSocket_EncryptBuffer):
return func(self._obj,name,Encrypted,xlen)
def pyEncryptBuffer(a,Packet):
stringlen=len(Packet)
EncryptedString=ctypes.create_string_buffer(16384)
EncryptedSize=a.CTCPSocket_EncryptBuffer(kkk,EncryptedString,stringlen)
EncryptedString=ctypes.string_at(EncryptedString,EncryptedSize)
#print repr(EncryptedString)
return EncryptedString
kkk="\x05\x00\xA2\x00\x00\x00\x01\x00\x03\x00\x06\x06\x03\x00\x06\x06\x03\x00\x06\x06\x55\x6F\x00\x00\x33\x00\x41\x00\x38\x00\x31\x00\x42\x00\x36\x00\x31\x00\x45\x00\x34\x00\x42\x00\x43\x00\x39\x00\x31\x00\x32\x00\x46\x00\x42\x00\x44\x00\x30\x00\x30\x00\x34\x00\x30\x00\x31\x00\x41\x00\x31\x00\x43\x00\x41\x00\x44\x00\x32\x00\x34\x00\x38\x00\x30\x00\x45\x00\x00\x00\x39\x00\x32\x00\x30\x00\x33\x00\x41\x00\x37\x00\x41\x00\x36\x00\x31\x00\x46\x00\x38\x00\x33\x00\x30\x00\x32\x00\x42\x00\x32\x00\x31\x00\x41\x00\x44\x00\x33\x00\x41\x00\x33\x00\x43\x00\x37\x00\x42\x00\x35\x00\x31\x00\x46\x00\x35\x00\x34\x00\x34\x00\x34\x00\x00\x00\x34\x00\x00\x00\x01\x00"
a=CTCPSocket()
newkkk=pyEncryptBuffer(a,kkk)
print "new:",repr(newkkk)
TCPSocket.cpp
// TCPSocket.cpp : 定义 DLL 应用程序的入口点。
//
#include "stdafx.h"
#include "Packet.h"
void CTCPSocket:: XInitial()
{
m_wRecvSize=0;
m_cbSendRound=0;
m_cbRecvRound=0;
m_dwSendXorKey=0x12345678;
m_dwRecvXorKey=0x12345678;
m_dwSendTickCount=GetTickCount()/1000L;
m_dwRecvTickCount=GetTickCount()/1000L;
m_Encryptsize=0;
return;
}
void CTCPSocket::XConclude()
{
//恢复数据
m_wRecvSize=0;
m_cbSendRound=0;
m_cbRecvRound=0;
m_dwSendXorKey=0;
m_dwRecvXorKey=0;
m_dwSendTickCount=0;
m_dwRecvTickCount=0;
m_dwSendPacketCount=0;
m_dwRecvPacketCount=0;
return;
}
//构造函数
CTCPSocket::CTCPSocket()
{
m_wRecvSize=0;
m_cbSendRound=0;
m_cbRecvRound=0;
m_dwSendXorKey=0;
m_dwRecvXorKey=0;
m_dwSendTickCount=0;
m_dwRecvTickCount=0;
m_dwSendPacketCount=0;
m_dwRecvPacketCount=0;
m_Encryptsize=0;
m_hSocket=INVALID_SOCKET;
// m_pITCPSocketSink=NULL;
// m_cbSocketStatus=SOCKET_STATUS_IDLE;
}
//析构函数
CTCPSocket::~CTCPSocket()
{
// CloseSocket();
}
//随机映射
WORD CTCPSocket::SeedRandMap(WORD wSeed)
{
DWORD dwHold=wSeed;
return (WORD)((dwHold=dwHold*241103L+2533101L)>>16);
}
//映射发送数据
BYTE CTCPSocket::MapSendByte(BYTE const cbData)
{
BYTE cbMap=g_SendByteMap[(BYTE)(cbData+m_cbSendRound)];
m_cbSendRound+=3;
return cbMap;
}
//映射接收数据
BYTE CTCPSocket::MapRecvByte(BYTE const cbData)
{
BYTE cbMap=g_RecvByteMap[cbData]-m_cbRecvRound;
m_cbRecvRound+=3;
return cbMap;
}
//加密数据
WORD CTCPSocket::EncryptBuffer(BYTE pcbDataBuffer[], WORD wDataSize, WORD wBufferSize)
{
int i = 0;
//效验参数
ASSERT(wDataSize >= sizeof(TCP_Head));
ASSERT(wBufferSize >= (wDataSize + 2*sizeof(DWORD)));
ASSERT(wDataSize <= (sizeof(TCP_Head) + SOCKET_TCP_BUFFER));
//调整长度
WORD wEncryptSize = wDataSize - sizeof(TCP_Command), wSnapCount = 0;
if ((wEncryptSize % sizeof(DWORD)) != 0)
{
wSnapCount = sizeof(DWORD) - wEncryptSize % sizeof(DWORD);
memset(pcbDataBuffer + sizeof(TCP_Info) + wEncryptSize, 0, wSnapCount);
}
//效验码与字节映射
BYTE cbCheckCode = 0;
for (WORD i = sizeof(TCP_Info); i < wDataSize; i++)
{
cbCheckCode += pcbDataBuffer[i];
pcbDataBuffer[i] = MapSendByte(pcbDataBuffer[i]);
}
//填写信息头
TCP_Head * pHead = (TCP_Head *)pcbDataBuffer;
pHead->TCPInfo.cbCheckCode = ~cbCheckCode + 1;
pHead->TCPInfo.wPacketSize = wDataSize;
pHead->TCPInfo.cbDataKind = 0x05;
//创建密钥
DWORD dwXorKey = m_dwSendXorKey;
if (m_dwSendPacketCount == 0)
{
//生成第一次随机种子
GUID Guid;
CoCreateGuid(&Guid);
dwXorKey = GetTickCount() * GetTickCount();
dwXorKey ^= Guid.Data1;
dwXorKey ^= Guid.Data2;
dwXorKey ^= Guid.Data3;
dwXorKey ^= *((DWORD *)Guid.Data4);
//随机映射种子
dwXorKey = SeedRandMap((WORD)dwXorKey);
dwXorKey |= ((DWORD)SeedRandMap((WORD)(dwXorKey >> 16))) << 16;
dwXorKey ^= g_dwPacketKey;
m_dwSendXorKey = dwXorKey;
m_dwRecvXorKey = dwXorKey;
}
//加密数据
WORD * pwSeed = (WORD *)(pcbDataBuffer + sizeof(TCP_Info));
DWORD * pdwXor = (DWORD *)(pcbDataBuffer + sizeof(TCP_Info));
WORD wEncrypCount = (wEncryptSize + wSnapCount) / sizeof(DWORD);
for (WORD i = 0; i < wEncrypCount; i++)
{
*pdwXor++ ^= dwXorKey;
dwXorKey = SeedRandMap(*pwSeed++);
dwXorKey |= ((DWORD)SeedRandMap(*pwSeed++)) << 16;
dwXorKey ^= g_dwPacketKey;
}
//插入密钥
if (m_dwSendPacketCount == 0)
{
MoveMemory(pcbDataBuffer + sizeof(TCP_Head) + sizeof(DWORD), pcbDataBuffer + sizeof(TCP_Head), wDataSize);
*((DWORD *)(pcbDataBuffer + sizeof(TCP_Head))) = m_dwSendXorKey;
pHead->TCPInfo.wPacketSize += sizeof(DWORD);
wDataSize += sizeof(DWORD);
}
//设置变量
m_dwSendPacketCount++;
m_dwSendXorKey = dwXorKey;
return wDataSize;
}
//解密数据
WORD CTCPSocket::CrevasseBuffer(BYTE pcbDataBuffer[], WORD wDataSize)
{
WORD i = 0;
//效验参数
ASSERT(wDataSize >= sizeof(TCP_Head));
ASSERT(((TCP_Head *)pcbDataBuffer)->TCPInfo.wPacketSize == wDataSize);
//调整长度
WORD wSnapCount = 0;
if ((wDataSize % sizeof(DWORD)) != 0)
{
wSnapCount = sizeof(DWORD) - wDataSize % sizeof(DWORD);
memset(pcbDataBuffer + wDataSize, 0, wSnapCount);
}
//提取密钥
if (m_dwRecvPacketCount == 0)
{
ASSERT(wDataSize >= (sizeof(TCP_Head) + sizeof(DWORD)));
if (wDataSize < (sizeof(TCP_Head) + sizeof(DWORD))) throw TEXT("数据包解密长度错误");
m_dwRecvXorKey = *(DWORD *)(pcbDataBuffer + sizeof(TCP_Head));
m_dwSendXorKey = m_dwRecvXorKey;
MoveMemory(pcbDataBuffer + sizeof(TCP_Head), pcbDataBuffer + sizeof(TCP_Head) + sizeof(DWORD),
wDataSize - sizeof(TCP_Head) - sizeof(DWORD));
wDataSize -= sizeof(DWORD);
((TCP_Head *)pcbDataBuffer)->TCPInfo.wPacketSize -= sizeof(DWORD);
}
//解密数据
DWORD dwXorKey = m_dwRecvXorKey;
DWORD * pdwXor = (DWORD *)(pcbDataBuffer + sizeof(TCP_Info));
WORD * pwSeed = (WORD *)(pcbDataBuffer + sizeof(TCP_Info));
WORD wEncrypCount = (wDataSize + wSnapCount - sizeof(TCP_Info)) / 4;
for (i = 0; i < wEncrypCount; i++)
{
if ((i == (wEncrypCount - 1)) && (wSnapCount > 0))
{
BYTE * pcbKey = ((BYTE *) & m_dwRecvXorKey) + sizeof(DWORD) - wSnapCount;
CopyMemory(pcbDataBuffer + wDataSize, pcbKey, wSnapCount);
}
dwXorKey = SeedRandMap(*pwSeed++);
dwXorKey |= ((DWORD)SeedRandMap(*pwSeed++)) << 16;
dwXorKey ^= g_dwPacketKey;
*pdwXor++ ^= m_dwRecvXorKey;
m_dwRecvXorKey = dwXorKey;
}
//效验码与字节映射
TCP_Head * pHead = (TCP_Head *)pcbDataBuffer;
BYTE cbCheckCode = pHead->TCPInfo.cbCheckCode;
for (i = sizeof(TCP_Info); i < wDataSize; i++)
{
pcbDataBuffer[i] = MapRecvByte(pcbDataBuffer[i]);
cbCheckCode += pcbDataBuffer[i];
}
//if (cbCheckCode != 0)
//{
// VERIFY(0);
// ZASSERT_R(0);
// throw TEXT("数据包效验码错误");
//}
return wDataSize;
}
extern "C" {
__declspec(dllexport) CTCPSocket *CTCPSocket_new() {
CTCPSocket * myCTCPSocket=new CTCPSocket;
printf("myCTCPSocket:%d\n",myCTCPSocket->m_dwSendXorKey);
myCTCPSocket->XInitial();
printf("myCTCPSocket:%d\n",myCTCPSocket->m_dwSendXorKey);
return myCTCPSocket;
}
__declspec(dllexport) void CTCPSocket_destruct(CTCPSocket *obj) {
delete obj;
}
//__declspec(dllexport) unsigned char * CTCPSocket_EncryptBuffer(CTCPSocket *obj, unsigned char *EncodeString,int len) {
__declspec(dllexport) int CTCPSocket_EncryptBuffer(CTCPSocket *obj, unsigned char *EncodeString,unsigned char *EncryptedString,int len) {
WORD wDatasize=len;
WORD EncryptByte=0;
printf("wDatasize:%d EncodeString:%s m_dwSendPacketCount:%d\n",wDatasize,EncodeString,obj->m_dwSendPacketCount);
//obj->m_dwSendPacketCount++;
memset(obj->m_EncryptBufferString,0,16384);
CopyMemory(obj->m_EncryptBufferString,EncodeString,len);
printf("before encrypt:\n");
for(int i=0;i<len;i++)
printf("\\x%02x",obj->m_EncryptBufferString[i]);
printf("\n");
EncryptByte=obj->EncryptBuffer(obj->m_EncryptBufferString,wDatasize,16384);
obj->m_Encryptsize=EncryptByte;
printf("EncryptByte:%d newEncodeString:%s\n",EncryptByte,obj->m_EncryptBufferString);
printf("after encrypt:\n");
for(int i=0;i<EncryptByte;i++)
{
printf("\\x%02x",obj->m_EncryptBufferString[i]);
EncryptedString[i]=obj->m_EncryptBufferString[i];
}
printf("\n");
return EncryptByte;
}
}
TCPSocket.h
#ifndef TCP_SOCKET_HEAD_FILE
#define TCP_SOCKET_HEAD_FILE
#pragma once
#include <Afxmt.h>
#include <Comutil.h>
#include <ICrsint.h>
#include <Process.h>
#include <Wininet.h>
#include <WinSock2.h>
//#include "WHSocketHead.h"
#pragma comment(lib, "comsupp.lib")
#define SOCKET_TCP_BUFFER 16384 //网络缓冲
//
//TCP 网络连接
class CTCPSocket //: public CWnd
{
//辅助变量
protected:
WORD m_wSocketID; //网络标识
BYTE m_cbSocketStatus; //网络状态
//内核变量
protected:
SOCKET m_hSocket; //连接句柄
//接收变量
public:
WORD m_wRecvSize; //接收长度
BYTE m_cbRecvBuf[SOCKET_TCP_BUFFER*10]; //接收缓冲
//缓冲变量
public:
bool m_bNeedBuffer; //缓冲状态
DWORD m_dwBufferData; //缓冲数据
DWORD m_dwBufferSize; //缓冲大小
LPBYTE m_pcbDataBuffer; //缓冲数据
//加密数据
public:
BYTE m_cbSendRound; //字节映射
BYTE m_cbRecvRound; //字节映射
DWORD m_dwSendXorKey; //发送密钥
DWORD m_dwRecvXorKey; //接收密钥
//计数变量
public:
DWORD m_dwSendTickCount; //发送时间
DWORD m_dwRecvTickCount; //接收时间
DWORD m_dwSendPacketCount; //发送计数
DWORD m_dwRecvPacketCount; //接受计数
public:
WORD m_Encryptsize;
unsigned char m_EncryptBufferString[16384];
//函数定义
public:
//构造函数
CTCPSocket();
void XInitial();
void XConclude();
//析构函数
virtual ~CTCPSocket();
//基础接口
public:
//释放对象
virtual VOID Release()
{
delete this;
}
//信息接口
public:
//获取状态
virtual BYTE GetSocketStatus() { return m_cbSocketStatus; }
//发送间隔
virtual DWORD GetLastSendTick() { return m_dwSendTickCount; }
//接收间隔
virtual DWORD GetLastRecvTick() { return m_dwRecvTickCount; }
//加密函数
public:
//解密数据
WORD CrevasseBuffer(BYTE cbDataBuffer[], WORD wDataSize);
//加密数据
WORD EncryptBuffer(BYTE cbDataBuffer[], WORD wDataSize, WORD wBufferSize);
//内联函数
private:
//字节映射
inline WORD SeedRandMap(WORD wSeed);
//发送映射
inline BYTE MapSendByte(BYTE cbData);
//接收映射
inline BYTE MapRecvByte(BYTE cbData);
// DECLARE_MESSAGE_MAP()
};
//
#endif