python 调用加密函数dll

来源：互联网发布：js字符串函数传对象编辑：程序博客网时间：2024/06/05 00:29

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

0 0