196 lines
No EOL
3.2 KiB
C++
196 lines
No EOL
3.2 KiB
C++
#include "StdAfx.h"
|
|
#include "RLKTAuth.h"
|
|
#include "RLKTPackets.h"
|
|
#include "Singleton.h"
|
|
|
|
#include <Windows.h>
|
|
#include <stdio.h>
|
|
#include <conio.h>
|
|
#include <tchar.h>
|
|
#pragma comment(lib, "user32.lib")
|
|
|
|
|
|
RLKTAuth::RLKTAuth()
|
|
{
|
|
}
|
|
|
|
|
|
RLKTAuth::~RLKTAuth()
|
|
{
|
|
}
|
|
bool isConnected = false;
|
|
bool isLicenseValid = false;
|
|
HANDLE hPipe;
|
|
|
|
#define PACKET_LEN sizeof(Header)
|
|
#define SERVICE_TYPE GameServer
|
|
|
|
//o zona periculoasa.
|
|
void DangerZone()
|
|
{
|
|
isConnected = false;
|
|
isLicenseValid = false;
|
|
//printf("Danger Zone Called.\n");
|
|
ExitProcess(0);
|
|
}
|
|
|
|
|
|
//o simpla encriptie
|
|
byte XOR_KEYS[] = { 0x12, 0x58, 0xA2, 0x91, 0xDF, 0xAB, 0x92, 0xFC };
|
|
void encdec(BYTE *data, DWORD size)
|
|
{
|
|
for (int i = 0; i < size; i++)
|
|
{
|
|
data[i] ^= XOR_KEYS[i%sizeof(XOR_KEYS)];
|
|
}
|
|
}
|
|
|
|
BYTE * CraftPacket(int id, BYTE* data)
|
|
{
|
|
Header *head = new Header;
|
|
head->id = id;
|
|
if (data != 0)
|
|
memcpy(head->data, data, sizeof(head->data));
|
|
|
|
return (BYTE*)head;
|
|
}
|
|
///
|
|
bool SendPacket(int id, BYTE* data)
|
|
{
|
|
DWORD dwWritten = 0;
|
|
WriteFile(hPipe,
|
|
CraftPacket(id, data),
|
|
PACKET_LEN, // = length of string + terminating '\0' !!!
|
|
&dwWritten,
|
|
NULL);
|
|
|
|
if (dwWritten == PACKET_LEN)
|
|
{
|
|
return true;
|
|
}
|
|
else{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
Header *RecvPacket()
|
|
{
|
|
DWORD totalread;
|
|
Header *head = new Header;
|
|
ReadFile(hPipe, head, PACKET_LEN, &totalread, 0);
|
|
if (totalread != PACKET_LEN)
|
|
{
|
|
printf("Err. recv packet size != \n");
|
|
}
|
|
|
|
//decriptare.
|
|
encdec((BYTE*)head, PACKET_LEN);
|
|
|
|
return head;
|
|
}
|
|
|
|
void PacketHandler(int ID, BYTE * data)
|
|
{
|
|
switch (ID)
|
|
{
|
|
case SC_CONNECT:
|
|
{
|
|
PSC_CONNECT *pack = new PSC_CONNECT;
|
|
pack = (PSC_CONNECT*)data;
|
|
if (pack->OK)
|
|
{
|
|
isConnected = true;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case SC_CHECKLICENSE:
|
|
{
|
|
if (!isConnected)
|
|
{
|
|
DangerZone();
|
|
return;
|
|
}
|
|
|
|
PSC_CHECKLICENSE *pack = new PSC_CHECKLICENSE;
|
|
pack = (PSC_CHECKLICENSE*)data;
|
|
if (pack->valid)
|
|
{
|
|
isLicenseValid = true;
|
|
}
|
|
else{
|
|
DangerZone();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case SC_PING:
|
|
{
|
|
//check
|
|
if (!isConnected || !isLicenseValid)
|
|
{
|
|
DangerZone();
|
|
return;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case SC_CLIENT_CLOSE:
|
|
PSC_CLOSE *d = new PSC_CLOSE;
|
|
d = (PSC_CLOSE*)data;
|
|
|
|
if (d->OK)
|
|
{
|
|
DangerZone();
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
//
|
|
void RLKTAuth::Main()
|
|
{
|
|
|
|
DWORD dwWritten;
|
|
bool isConnected = false;
|
|
|
|
hPipe = CreateFile(TEXT("\\\\.\\pipe\\RLKT"),
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
0,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
0,
|
|
NULL);
|
|
if (hPipe != INVALID_HANDLE_VALUE)
|
|
{
|
|
PCS_CONNECT *ConnPacket = new PCS_CONNECT;
|
|
ConnPacket->ServiceType = SERVICE_TYPE;
|
|
SendPacket(CS_CONNECT, (BYTE*)ConnPacket);
|
|
Sleep(500);
|
|
Header *headConnect = RecvPacket();
|
|
PacketHandler(headConnect->id, headConnect->data);
|
|
|
|
|
|
|
|
PCS_CHECKLICENSE *LicensePacket = new PCS_CHECKLICENSE;
|
|
LicensePacket->ServiceType = SERVICE_TYPE;
|
|
SendPacket(CS_CHECKLICENSE, (BYTE*)LicensePacket);
|
|
Sleep(500);
|
|
Header *headLicense = RecvPacket();
|
|
PacketHandler(headLicense->id, headLicense->data);
|
|
|
|
|
|
// while (1) {
|
|
//send
|
|
SendPacket(CS_PING, 0);
|
|
Sleep(500);
|
|
//recv
|
|
Header *head = RecvPacket();
|
|
PacketHandler(head->id, head->data);
|
|
// }
|
|
CloseHandle(hPipe);
|
|
}
|
|
|
|
|
|
} |