Code:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include <winsock.h>
#include <winnt.h>
#include <wtypes.h>
#pragma comment(lib, "ws2_32")
#include <stdarg.h>
#include <time.h>
#define GetTwoKeys(keyone,keytwo) if(GetAsyncKeyState(keyone) &0x8000 && GetAsyncKeyState(keytwo) &0x8000)
extern void *x_malloc(size_t siz, const char *alloc_info);
extern CRITICAL_SECTION plvl_cs,cs_packetID,cs_malloc, unmangle_cs;
extern CRITICAL_SECTION io_cs, packet_reading;
extern struct pointers pointers[16000];
extern struct Command_Packet *MakePacket(char *packet, size_t packet_len, short isUnencrypted, char *key);
extern unsigned char packet_ID;
extern char key[32], stageKey[32], NATKey[32];
extern void x_free(void *ptr);
extern int fd, peer_fd;
unsigned char packet_ID = 0x01;
CRITICAL_SECTION io_cs, packet_reading;
CRITICAL_SECTION plvl_cs,cs_packetID,cs_malloc, unmangle_cs;
char key[32], stageKey[32], NATKey[32];
struct pointers {
char *ptr;
const char *alloc_info;
};
struct pointers pointers[16000];
struct Command_Packet {
char *msg;
size_t len;
};
int send_to_server(int fd, char *packet, size_t siz) {
size_t ret;
EnterCriticalSection(&io_cs);
ret = send(fd,packet,siz,0);
LeaveCriticalSection(&io_cs);
return ret;
}
void add_identifier(char *packet,short id) {
memcpy(packet+sizeof(short),&id,sizeof(id));
}
void add_packetID(char *packet) {
EnterCriticalSection(&cs_packetID);
*packet = packet_ID++;
if(packet_ID > 0xFF) {
packet_ID = 0x01;
}
LeaveCriticalSection(&cs_packetID);
}
size_t add_param(char *packet, int type, void *param, size_t siz) {
size_t local_size = 0;
if((type == 4 || type == 10)) {
if(!siz) {
siz = (short)strlen((char*)param)+1;
}
memcpy(packet+local_size,&siz,sizeof(short));
local_size += sizeof(short);
}
memcpy(packet+local_size,param,siz);
return siz+local_size;
}
void fix_size(char *packet, short siz) {
memcpy(packet,&siz,sizeof(siz));
}
void *x_malloc(size_t siz, const char *alloc_info) {
unsigned char *ptr;
int i;
EnterCriticalSection(&cs_malloc);
for(i=0;i<10;i++) {
ptr = malloc(siz);
if(ptr) {
break;
}
Sleep(500);
}
for(i=0;i<=15999;i++) {
if(!pointers[i].ptr) {
pointers[i].ptr=ptr;
pointers[i].alloc_info=alloc_info;
break;
}
}
LeaveCriticalSection(&cs_malloc);
return (void *)ptr;
}
char *encrypt(char *packet,size_t packet_len, char *key) {
unsigned int key_len = 32;
unsigned int magic_shl = 0x03;
unsigned int temp_num=0,second;
unsigned int i,j;
unsigned char *new_packet = x_malloc(packet_len,"encrypt(), new_packet");
memset(new_packet,0,packet_len);
for(i=0,j=0,temp_num=0,second=0;i<packet_len;i++) {
temp_num = *(key+j);
temp_num = (temp_num) ^ (*(packet+i));
temp_num = temp_num & 0xffff00ff;
temp_num <<= magic_shl;
second = (temp_num >> 8);
second |= (temp_num & 0xff);
second ^= 0xf0 & 0xff;
if(j == key_len-1) {
j = 0;
} else {
j++;
}
*(new_packet+i)=second & 0xff;
}
return new_packet;
}
void x_free(void *ptr) {
int i;
EnterCriticalSection(&cs_malloc);
for(i=0;i<15999;i++) {
if(pointers[i].ptr==ptr) {
pointers[i].ptr=NULL;
break;
}
}
if(i>=15999) {
LeaveCriticalSection(&cs_malloc);
return;
}
free(ptr);
LeaveCriticalSection(&cs_malloc);
}
unsigned short packet_checksum(unsigned char *packet, size_t len) {
unsigned int skip_header_len = 6;
unsigned int count,i;
unsigned int sum = 0;
if(len > 50000) {
return 1;
}
if(len > skip_header_len) {
for(count = skip_header_len-1; count < len; count++) {
sum += *(packet+count);
}
}
i = 0;
i += *(packet);
i += *(packet+1);
i += *(packet+2);
i += *(packet+3);
sum -= i;
i = sum;
sum >>= 0x10;
sum += i;
return sum;
}
struct Command_Packet *MakePacket(char *packet, size_t packet_len, short isUnencrypted, char *key) {
short version = 0x65; // 0x64 for unencrypted mode.
short full_len = packet_len + 6;
short ret;
char *ptr;
struct Command_Packet *cmdpkt = x_malloc(sizeof(struct Command_Packet),"MakePacket(), cmdpkt");
char *packetOut = x_malloc(packet_len+6,"MakePacket(), PacketOut");
if(!strncmp(key,NATKey,32)) {
isUnencrypted = 1;
}
if(isUnencrypted) {
version = 0x64;
}
memset(packetOut,0,packet_len+6);
memcpy(packetOut,&version,sizeof(short));
if(!isUnencrypted) {
ptr = encrypt((char *)&full_len,sizeof(short),key);
memcpy(packetOut+2,ptr,sizeof(short));
x_free(ptr);
} else {
memcpy(packetOut+2,&full_len,sizeof(short));
}
memcpy(packetOut+6,packet,sizeof(short));
memcpy(packetOut+6,packet,packet_len);
if(!isUnencrypted) {
ptr = encrypt(packetOut+6,packet_len,key);
memcpy(packetOut+6,ptr,packet_len);
x_free(ptr);
}
ret = packet_checksum(packetOut,full_len);
memcpy(packetOut+4,&ret,sizeof(short));
cmdpkt->msg = packetOut;
cmdpkt->len = full_len;
return cmdpkt;
}
int Echo(int fd, char*Text)
{
char *packet = x_malloc(8096,"Echo(), packet");
struct Command_Packet *cmdpkt;
short siz = 0;
memset(packet,0,8096);
add_identifier(packet,0x1B5A); //Global Announce packet ID
siz += 4;
add_packetID(packet+siz);
siz += 1;
siz += add_param(packet+siz,4,Text,0); //strAnnounce parameter
fix_size(packet,siz);
cmdpkt = MakePacket(packet,siz,0,key);
siz = send_to_server(fd,cmdpkt->msg,cmdpkt->len);
x_free(packet);
x_free(cmdpkt->msg);
x_free(cmdpkt);
return siz;
}
void Main()
{
while(1)
{
GetTwoKeys(0x12, 'A')
{
Echo(fd, "Popad Plugin by Popad");
Sleep(500);
}
Sleep(50);
}
}
bool APIENTRY DllMain(HMODULE hModule, DWORD dwReason, LPVOID lpvReserved){
if(dwReason == DLL_PROCESS_ATTACH){
DisableThreadLibraryCalls(hModule);
CreateThread(NULL, 0, (unsigned long(__stdcall*)(void*))Main, NULL, 0, NULL);
}
return true;
}
Errors: