X-TRAP

Page 20 of 24 « First 101819 20 2122 Last »
08/14/2010 16:20 FireflieZ#286
man müsste sich mal mit nem spambot unterhalten .. die habens ja auch iwie geschafft xD
08/14/2010 16:26 Elongate#287
Die benutzen aber keine funktion die detected wird ganz einfach.
08/14/2010 16:32 DarkAngel134#288
Leuzzz ihr seid glasse :D
08/14/2010 16:35 nkkk#289
Quote:
Originally Posted by Offensivkiller View Post
Die benutzen aber keine funktion die detected wird ganz einfach.
hmm ich dachte eig früher immer das sind professionelle bots die nichtmal ein LC fenster offen haben, sondern nurnoch TcpIp-Packete schicken, aber immoment zweifel ich daran stark.
08/14/2010 16:42 wurstbrot123#290
So ist es auch oftmals. Und wenn man die Packetverschlüsselung handshake
etc alles fertig hat, sollte X-Trap auch keine große hürde sein.
Dann muss man halt nur noch wissen wie die Antwort für X-Trap erstellt
wird und das auch selber tun.
08/14/2010 16:58 dsfgd#291
Quote:
Originally Posted by shadow52 View Post
Kann jemand was hiermit Anfangen ?
Sind 2 Daten mit denen X-Trap irgendwas macht wen es startet und während man LastChaos an hatt und spielt.)

"http://xtrap.lastchaos.de/XDataV1.Xtp"
"http://xtrap.lastchaos.de/XDataFM0.Xtp"
das sind Patch dateien, damit updated sich Xtrap

Quote:
Originally Posted by wurstbrot123 View Post
So ist es auch oftmals. Und wenn man die Packetverschlüsselung handshake
etc alles fertig hat, sollte X-Trap auch keine große hürde sein.
Dann muss man halt nur noch wissen wie die Antwort für X-Trap erstellt
wird und das auch selber tun.
die Verschlüsselung ist nicht weiter ein problem, ist relativ einfach zu knacken, (haufenweise BitShift+Xor), das problem ist der 128 Byte Key,
dieser wird aus 6 Datenpacketen zufällig generiert, wie der client das genau macht und der server das versteht hab ich noch nicht raus, soweit ich das sehen kann muss der Key aber bei jedem Paket identisch sein, da das Login Packet immer den selben Key benutzt

hier mein versuch decrypt versuch, vieleicht kannst du ja fortführen womit ich angefangen hab wurstbrot ^^ (alle werte beziehen sich auf den Eternia Client, weil dieser sich ja nicht ändern kann)

Code:
#include <stdio.h>
#include <stdlib.h>

int DecrypterData_105E0A48[64] = {
	0x01010400, 0x00000000, 0x00010000, 0x01010404, 0x01010004, 0x00010404, 0x00000004, 0x00010000,
	0x00000400, 0x01010400, 0x01010404, 0x00000400, 0x01000404, 0x01010004, 0x01000000, 0x00000004,
	0x00000404, 0x01000400, 0x01000400, 0x00010400, 0x00010400, 0x01010000, 0x01010000, 0x01000404,
	0x00010004, 0x01000004, 0x01000004, 0x00010004, 0x00000000, 0x00000404, 0x00010404, 0x01000000,
	0x00010000, 0x01010404, 0x00000004, 0x01010000, 0x01010400, 0x01000000, 0x01000000, 0x00000400,
	0x01010004, 0x00010000, 0x00010400, 0x01000004, 0x00000400, 0x00000004, 0x01000404, 0x00010404,
	0x01010404, 0x00010004, 0x01010000, 0x01000404, 0x01000004, 0x00000404, 0x00010404, 0x01010400,
	0x00000404, 0x01000400, 0x01000400, 0x00000000, 0x00010004, 0x00010400, 0x00000000, 0x01010004
};

int DecrypterData_105E0B48[64] = {
	0x80108020, 0x80008000, 0x00008000, 0x00108020, 0x00100000, 0x00000020, 0x80100020, 0x80008020,
	0x80000020, 0x80108020, 0x80108000, 0x80000000, 0x80008000, 0x00100000, 0x00000020, 0x80100020,
	0x00108000, 0x00100020, 0x80008020, 0x00000000, 0x80000000, 0x00008000, 0x00108020, 0x80100000,
	0x00100020, 0x80000020, 0x00000000, 0x00108000, 0x00008020, 0x80108000, 0x80100000, 0x00008020,
	0x00000000, 0x00108020, 0x80100020, 0x00100000, 0x80008020, 0x80100000, 0x80108000, 0x00008000,
	0x80100000, 0x80008000, 0x00000020, 0x80108020, 0x00108020, 0x00000020, 0x00008000, 0x80000000,
	0x00008020, 0x80108000, 0x00100000, 0x80000020, 0x00100020, 0x80008020, 0x80000020, 0x00100020,
	0x00108000, 0x00000000, 0x80008000, 0x00008020, 0x80000000, 0x80100020, 0x80108020, 0x00108000
};

int DecrypterData_105E0C48[64] = {
	0x00000208, 0x08020200, 0x00000000, 0x08020008, 0x08000200, 0x00000000, 0x00020208, 0x08000200,
	0x00020008, 0x08000008, 0x08000008, 0x00020000, 0x08020208, 0x00020008, 0x08020000, 0x00000208,
	0x08000000, 0x00000008, 0x08020200, 0x00000200, 0x00020200, 0x08020000, 0x08020008, 0x00020208,
	0x08000208, 0x00020200, 0x00020000, 0x08000208, 0x00000008, 0x08020208, 0x00000200, 0x08000000,
	0x08020200, 0x08000000, 0x00020008, 0x00000208, 0x00020000, 0x08020200, 0x08000200, 0x00000000,
	0x00000200, 0x00020008, 0x08020208, 0x08000200, 0x08000008, 0x00000200, 0x00000000, 0x08020008,
	0x08000208, 0x00020000, 0x08000000, 0x08020208, 0x00000008, 0x00020208, 0x00020200, 0x08000008,
	0x08020000, 0x08000208, 0x00000208, 0x08020000, 0x00020208, 0x00000008, 0x08020008, 0x00020200
};

int DecrypterData_105E0D48[64] = {
	0x00802001, 0x00002081, 0x00002081, 0x00000080, 0x00802080, 0x00800081, 0x00800001, 0x00002001,
	0x00000000, 0x00802000, 0x00802000, 0x00802081, 0x00000081, 0x00000000, 0x00800080, 0x00800001,
	0x00000001, 0x00002000, 0x00800000, 0x00802001, 0x00000080, 0x00800000, 0x00002001, 0x00002080,
	0x00800081, 0x00000001, 0x00002080, 0x00800080, 0x00002000, 0x00802080, 0x00802081, 0x00000081,
	0x00800080, 0x00800001, 0x00802000, 0x00802081, 0x00000081, 0x00000000, 0x00000000, 0x00802000,
	0x00002080, 0x00800080, 0x00800081, 0x00000001, 0x00802001, 0x00002081, 0x00002081, 0x00000080,
	0x00802081, 0x00000081, 0x00000001, 0x00002000, 0x00800001, 0x00002001, 0x00802080, 0x00800081,
	0x00002001, 0x00002080, 0x00800000, 0x00802001, 0x00000080, 0x00800000, 0x00002000, 0x00802080
};

int DecrypterData_105E0E48[64] = {
	0x00000100, 0x02080100, 0x02080000, 0x42000100, 0x00080000, 0x00000100, 0x40000000, 0x02080000,
	0x40080100, 0x00080000, 0x02000100, 0x40080100, 0x42000100, 0x42080000, 0x00080100, 0x40000000,
	0x02000000, 0x40080000, 0x40080000, 0x00000000, 0x40000100, 0x42080100, 0x42080100, 0x02000100,
	0x42080000, 0x40000100, 0x00000000, 0x42000000, 0x02080100, 0x02000000, 0x42000000, 0x00080100,
	0x00080000, 0x42000100, 0x00000100, 0x02000000, 0x40000000, 0x02080000, 0x42000100, 0x40080100,
	0x02000100, 0x40000000, 0x42080000, 0x02080100, 0x40080100, 0x00000100, 0x02000000, 0x42080000,
	0x42080100, 0x00080100, 0x42000000, 0x42080100, 0x02080000, 0x00000000, 0x40080000, 0x42000000,
	0x00080100, 0x02000100, 0x40000100, 0x00080000, 0x00000000, 0x40080000, 0x02080100, 0x40000100
};

int DecrypterData_105E0F48[64] = {
	0x20000010, 0x20400000, 0x00004000, 0x20404010, 0x20400000, 0x00000010, 0x20404010, 0x00400000,
	0x20004000, 0x00404010, 0x00400000, 0x20000010, 0x00400010, 0x20004000, 0x20000000, 0x00004010,
	0x00000000, 0x00400010, 0x20004010, 0x00004000, 0x00404000, 0x20004010, 0x00000010, 0x20400010,
	0x20400010, 0x00000000, 0x00404010, 0x20404000, 0x00004010, 0x00404000, 0x20404000, 0x20000000,
	0x20004000, 0x00000010, 0x20400010, 0x00404000, 0x20404010, 0x00400000, 0x00004010, 0x20000010,
	0x00400000, 0x20004000, 0x20000000, 0x00004010, 0x20000010, 0x20404010, 0x00404000, 0x20400000,
	0x00404010, 0x20404000, 0x00000000, 0x20400010, 0x00000010, 0x00004000, 0x20400000, 0x00404010,
	0x00004000, 0x00400010, 0x20004010, 0x00000000, 0x20404000, 0x20000000, 0x00400010, 0x20004010
};

int DecrypterData_105E1048[64] = {
	0x00200000, 0x04200002, 0x04000802, 0x00000000, 0x00000800, 0x04000802, 0x00200802, 0x04200800,
	0x04200802, 0x00200000, 0x00000000, 0x04000002, 0x00000002, 0x04000000, 0x04200002, 0x00000802,
	0x04000800, 0x00200802, 0x00200002, 0x04000800, 0x04000002, 0x04200000, 0x04200800, 0x00200002,
	0x04200000, 0x00000800, 0x00000802, 0x04200802, 0x00200800, 0x00000002, 0x04000000, 0x00200800,
	0x04000000, 0x00200800, 0x00200000, 0x04000802, 0x04000802, 0x04200002, 0x04200002, 0x00000002,
	0x00200002, 0x04000000, 0x04000800, 0x00200000, 0x04200800, 0x00000802, 0x00200802, 0x04200800,
	0x00000802, 0x04000002, 0x04200802, 0x04200000, 0x00200800, 0x00000000, 0x00000002, 0x04200802,
	0x00000000, 0x00200802, 0x04200000, 0x00000800, 0x04000002, 0x04000800, 0x00000800, 0x00200002
};

int DecrypterData_105E1148[64] = {
	0x10001040, 0x00001000, 0x00040000, 0x10041040, 0x10000000, 0x10001040, 0x00000040, 0x10000000,
	0x00040040, 0x10040000, 0x10041040, 0x00041000, 0x10041000, 0x00041040, 0x00001000, 0x00000040,
	0x10040000, 0x10000040, 0x10001000, 0x00001040, 0x00041000, 0x00040040, 0x10040040, 0x10041000,
	0x00001040, 0x00000000, 0x00000000, 0x10040040, 0x10000040, 0x10001000, 0x00041040, 0x00040000,
	0x00041040, 0x00040000, 0x10041000, 0x00001000, 0x00000040, 0x10040040, 0x00001000, 0x00041040,
	0x10001000, 0x00000040, 0x10000040, 0x10040000, 0x10040040, 0x10000000, 0x00040000, 0x10001040,
	0x00000000, 0x10041040, 0x00040040, 0x10000040, 0x10040000, 0x10001000, 0x10001040, 0x00000000,
	0x10041040, 0x00041000, 0x00041000, 0x00001040, 0x00001040, 0x00040040, 0x10000000, 0x10041000,
};

// Der Login Key, ist nur beim LoginPaket Valid
int DecrypterData_ESI[32] = {
	0x000D2E32, 0x2F312913, 0x3B012A06, 0x2E15332E, 0x031C292E, 0x3C1A0523, 0x1B061529, 0x213B2037,
	0x2F213527, 0x38093818, 0x022A001D, 0x361A1B19, 0x0F361E10, 0x031C3B24, 0x15311A36, 0x2209042E,
	0x16270536, 0x02352F20, 0x25102A35, 0x1E2D0231, 0x301E3A28, 0x30263E12, 0x3E2A1D1C, 0x0925141A,
	0x24092701, 0x1B2A110E, 0x281B310B, 0x05360F24, 0x3D2D0C3B, 0x05040A2D, 0x19351810, 0x2132271D
};


char KeyData_105E0960[56] = {
	0x38, 0x30, 0x28, 0x20, 0x18, 0x10, 0x08, 0x00, 
	0x39, 0x31, 0x29, 0x21, 0x19, 0x11, 0x09, 0x01, 
	0x3A, 0x32, 0x2A, 0x22, 0x1A, 0x12, 0x0A, 0x02, 
	0x3B, 0x33, 0x2B, 0x23, 0x3E, 0x36, 0x2E, 0x26,
	0x1E, 0x16, 0x0E, 0x06, 0x3D, 0x35, 0x2D, 0x25, 
	0x1D, 0x15, 0x0D, 0x05, 0x3C, 0x34, 0x2C, 0x24, 
	0x1C, 0x14, 0x0C, 0x04, 0x1B, 0x13, 0x0B, 0x03
}

char KeyData_105E0998[24] = {
	0x0D, 0x10, 0x0A, 0x17, 0x00, 0x04, 0x02, 0x1B, 
	0x0E, 0x05, 0x14, 0x09, 0x16, 0x12, 0x0B, 0x03, 
	0x19, 0x07, 0x0F, 0x06, 0x1A, 0x13, 0x0C, 0x01
}

char KeyData_105E09B0[24] = {
	0x28, 0x33, 0x1E, 0x24, 0x2E, 0x36, 0x1D, 0x27, 
	0x32, 0x2C, 0x20, 0x2F, 0x2B, 0x30, 0x26, 0x37, 
	0x21, 0x34, 0x2D, 0x29, 0x31, 0x23, 0x1C, 0x1F
}

char KeyData_105E09C8[16] = {
	0x01, 0x00, 0x02, 0x00, 0x04, 0x00, 0x08, 0x00, 
	0x10, 0x00, 0x20, 0x00, 0x40, 0x00, 0x80, 0x00
}

char KeyData_105E09D8[96] = {
	0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x40, 0x00, 
	0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x10, 0x00, 
	0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 
	0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00,
	0x00, 0x80, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 
	0x00, 0x20, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 
	0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 
	0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
	0x80, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 
	0x20, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 
	0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 
	0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00
}

char KeyData_105E0A38[16] = {
	0x01, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E, 
	0x0F, 0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1C
}


void GenerateKey(int *Data, int * Key)
{
	/*
  int v2; // edx@1
  char *v3; // esi@1
  int result; // eax@2
  unsigned int v5; // ecx@2
  int v6; // eax@2
  int v7; // ebx@2
  int v8; // edi@2
  unsigned int v9; // ebx@2
  unsigned int v10; // ebx@2
  int v11; // edi@2
  char v12; // zf@2
  signed int v13; // [sp+10h] [bp-84h]@1
  char v14; // [sp+14h] [bp-80h]@1

  v2 = a2;
  v3 = &v14;
  v13 = 16;
  do
  {
    v5 = *(_DWORD *)(v2 + 4);
    v6 = *(_DWORD *)v2;
    v7 = *(_DWORD *)v2;
    v8 = v7 & 0xFC0000 | 16 * (*(_DWORD *)v2 & 0xFC0);
    v9 = v5 >> 4;
    v3 += 8;
    v10 = (*(_DWORD *)(v2 + 4) & 0xFC0 | v9 & 0xFC000) >> 6;
    v2 += 8;
    *((_DWORD *)v3 - 2) = v10 | (v8 << 6);
    v11 = v5 & 0x3F | (v5 >> 4) & 0x3F00 | ((v6 & 0x3F000 | 16 * (v6 & 0x3F)) << 12);
    result = v13 - 1;
    v12 = v13 == 1;
    *((_DWORD *)v3 - 1) = v11;
    --v13;
  }
  while ( !v12 );
  if ( a1 < (char *)a1 + 128 )
    memcpy(a1, &v14, 0x80u);
  return result;
	*/
}

void Crypt(int *DataIn, int *DataOut)
{
	unsigned char *Data1ptr = (unsigned char*)DataIn;
	unsigned char *Data2ptr = (unsigned char*)DataIn+4;
	unsigned char *Data3ptr = (unsigned char*)DataOut;
	unsigned char *Data4ptr = (unsigned char*)DataOut+4;

	unsigned int EAX=0,EDX=0,ECX=0,ESI=0,EBX=0,EDI=0,EBP=0;
	unsigned int j,*DecryptDataPtr,*ESIDataPtr,ESI_DataOffset=0;
	unsigned int tempvar1=0,tempvar2=0;

	EAX = *Data1ptr << 24 | *(Data1ptr+1) << 16 | *(Data1ptr+2) << 8 | *(Data1ptr+3); // EAX
	EDX = *Data2ptr << 24 | *(Data2ptr+1) << 16 | *(Data2ptr+2) << 8 | *(Data2ptr+3); // EDX

	ECX = ((EDX & 0x0F0F0F0F) ^ (EAX >> 4) & 0x0F0F0F0F);

	EAX ^= 16 * ECX;
	EDX ^= ECX;

	ECX = (EDX & 0x0000FFFF) ^ (EAX >> 0x10);

	EDX ^= ECX;								//XOR EDX,ECX
	EAX ^= (ECX << 0x10);					//XOR EAX,ECX + SHL ECX,10

	ECX = (EAX & 0x33333333) ^ ((EDX >> 0x2) & 0x33333333);

	EAX ^= ECX;								//XOR EAX,ECX
	EDX ^= 4 * ECX;

	ECX = (EAX & 0x00FF00FF) ^ (EDX >> 0x8) & 0x00FF00FF;
	EAX ^= ECX;								//XOR EAX,ECX

	ECX = 2 * ((ECX << 0x8) ^ EDX) | (((ECX << 0x8) ^ EDX) >> 0x1F);

	EDX = (ECX ^ EAX) & 0xAAAAAAAA;
	ECX ^= EDX;
	EDX = 2 * (EAX ^ EDX) | ((EAX ^ EDX) >> 0x1F);

	j=8;
	ESIDataPtr = (unsigned int*)DecrypterData_ESI; 
	do
	{
		EAX = *ESIDataPtr ^ ((ECX >> 4) | (ECX << 28));

		ESIDataPtr += 4; 

		EDX ^= DecrypterData_105E1048[(EAX & 0x3F)] |
			DecrypterData_105E0E48[(EAX >> 8) & 0x3F] |
			DecrypterData_105E0C48[(EAX >> 16) & 0x3F] |
			DecrypterData_105E0A48[(EAX >> 24) & 0x3F] |
			DecrypterData_105E1148[(ECX ^ *(ESIDataPtr-0x3)) & 0x3F] |
			DecrypterData_105E0F48[((ECX ^ *(ESIDataPtr-0x3)) >> 8) & 0x3F] | 
			DecrypterData_105E0D48[((ECX ^ *(ESIDataPtr-0x3)) >> 16) & 0x3F] | 
			DecrypterData_105E0B48[((ECX ^ *(ESIDataPtr-0x3)) >> 24) & 0x3F];

		EAX = (*(ESIDataPtr-2) ^ ((EDX >> 4) | (EDX << 28)));

		ECX ^= DecrypterData_105E1048[(EAX & 0x3F)] | 
			DecrypterData_105E0E48[((*(ESIDataPtr-2) ^ ((EDX >> 4) | (EDX << 28))) >> 8)  & 0x3F] | 
			DecrypterData_105E0C48[(EAX >> 16) & 0x3F] |
			DecrypterData_105E0A48[((*(ESIDataPtr-2) ^ ((EDX >> 4) | (EDX << 28))) >> 24) & 0x3F] | 
			DecrypterData_105E1148[(*(ESIDataPtr-1) ^ EDX) & 0x3F] | 
			DecrypterData_105E0F48[((*(ESIDataPtr-1) ^ EDX) >> 8) & 0x3F] | 
			DecrypterData_105E0D48[((*(ESIDataPtr-1) ^ EDX) >> 16) & 0x3F] | 
			DecrypterData_105E0B48[((*(ESIDataPtr-1) ^ EDX) >> 24) & 0x3F];

		--j;
		//printf("ECX: 0x%08X, EDX: 0x%08X\n\n",ECX,EDX); // nur ECX und EDX sind die wichtigen Werte...
	}
	while(j != 0);

	/*
	  v25 = ((unsigned int)v3 >> 1) | (v3 << 31);
	  v26 = (v2 ^ (((unsigned int)v3 >> 1) | (v3 << 31))) & 0xAAAAAAAA;
	  v27 = v26 ^ v25;
	  v28 = v27;
	  v29 = ((v26 ^ v2) >> 1) | ((v26 ^ v2) << 31);
	  v30 = v29 >> 8;
	  v31 = v28 & 0xFF00FF ^ v30 & 0xFF00FF;
	  v32 = v31 ^ v27;
	  v33 = (v31 << 8) ^ v29;
	  v34 = v32 & 0x33333333 ^ ((unsigned int)v33 >> 2) & 0x33333333;
	  v35 = v34 ^ v32;
	  v36 = 4 * v34 ^ v33;
	  v37 = (unsigned __int16)v36 ^ ((unsigned int)v35 >> 16);
	  v38 = v37 ^ v36;
	  v39 = (v37 << 16) ^ v35;
	  v40 = v38 & 0xF0F0F0F ^ ((unsigned int)v39 >> 4) & 0xF0F0F0F;
	  v41 = v39 ^ 16 * (v38 & 0xF0F0F0F ^ ((unsigned int)v39 >> 4) & 0xF0F0F0F);
	  result = a1;
	  *(_DWORD *)a1 = v41;
	  *(_DWORD *)(a1 + 4) = v38 ^ v40;
	  return result;
	*/

	EAX = (ECX >> 1) | (ECX << 0x1F);
	ECX = (EAX ^ EDX) & 0xAAAAAAAA;

	EDX ^= ECX;
	EAX ^= ECX;
	ECX = EDX << 0x1F;
	EDX >>= 1;
	ESI = EAX & 0x00FF00FF;

	ECX |= EDX;
	EDX = (ECX >> 8) & 0x00FF00FF;

	EDX ^= ESI;
	EAX ^= EDX;
	EDX <<= 8;

	ECX ^= EDX;
	ESI = EAX & 0x33333333;

	EDX = (((ECX >> 2) & 0x33333333) ^ ESI);

	EAX ^= EDX;

	ECX ^= (EDX << 2);
	EDX = (EAX >> 16) ^ (ECX & 0x0000FFFF);
	ECX ^= EDX;

	EAX ^= (EDX << 16);
	EDX = (EAX >> 4) & 0x0F0F0F0F ^ (ECX & 0x0F0F0F0F);
	ESI = (EDX << 4) ^ EAX;

	EDX ^= ECX;	

	//ESI & EDX = Verschlüsselte Daten ^^
	//printf("EDX: 0x%08X\nESI: 0x%08X\n\n",EDX,ESI);

	*(Data3ptr+0) = ((ESI & 0xFF000000) >> 24);
	*(Data3ptr+1) = ((ESI & 0x00FF0000) >> 16);
	*(Data3ptr+2) = ((ESI & 0x0000FF00) >>  8);
	*(Data3ptr+3) = ((ESI & 0x000000FF) >>  0);

	*(Data4ptr+0) = ((EDX & 0xFF000000) >> 24);
	*(Data4ptr+1) = ((EDX & 0x00FF0000) >> 16);
	*(Data4ptr+2) = ((EDX & 0x0000FF00) >>  8);
	*(Data4ptr+3) = ((EDX & 0x000000FF) >>  0);

	printf("Unencrypted Data:\tEncrypted Data:\n");
	printf("1: 0x%02X 0x%02X 0x%02X 0x%02X\t0x%02X 0x%02X 0x%02X 0x%02X\n",
		*Data1ptr,*(Data1ptr+1),*(Data1ptr+2),*(Data1ptr+3),
		*Data3ptr,*(Data3ptr+1),*(Data3ptr+2),*(Data3ptr+3));
	printf("2: 0x%02X 0x%02X 0x%02X 0x%02X\t0x%02X 0x%02X 0x%02X 0x%02X\n",
		*Data2ptr,*(Data2ptr+1),*(Data2ptr+2),*(Data2ptr+3),
		*Data4ptr,*(Data4ptr+1),*(Data4ptr+2),*(Data4ptr+3));
}


int main()
{

	/*
	char PACKET[] = {
		0x00, 0x00, 0x00, 0x1A,							//Paket Länge, von 0 bis n
		0x03, 0x00,										//REQUEST LOGIN
		0x00, 0x05, 0x29, 0x00,							//CLIENT_PATCH_VERSION
		0x74, 0x65, 0x73, 0x74, 0x69, 0x65, 0x65, 0x00, //ACCOUNT_NAME
		0x70, 0x77, 0x74, 0x65, 0x73, 0x74, 0x00,		//ACCOUNT_PASSWORD
		0x09, 0x15, 0x94, 0xAB, 0x84, 0x44, 0x00		// ZEIT ?
	};
	//*/

	// Dieses Paket ist verschlüsselt
	///*
	char PACKET[] = {
		0x81, 0x94, 0xF2, 0x14, 
		0xA3, 0x05, 0x26, 0xB2, 
		0x77, 0xB2, 0x22, 0x42, 
		0x7F, 0x5A, 0xCE, 0x8D, 
		0xF4, 0x1E, 0xDD, 0x7C, 
		0xB1, 0x74, 0x64, 0xCF, 
		0xCE, 0x1C, 0xB0, 0x2F, 
		0xB7, 0x6A, 0x34, 0xE5, 
		0xA7
	};
	//*/



	char *PACKET_OUT = (char*)malloc(sizeof(PACKET));

	int encrypt = 0, i = 0;


	if (encrypt == 1)
	{
		i = ((sizeof(PACKET) - 1) + 7) >> 3;
	}
	else
	{
		i = (sizeof(PACKET) + 7) >> 3;
	}



	int *Data1ptr,*Data2ptr, j=0;
	unsigned char *Data1ptrByte,*Data2ptrByte;
	int Data1, Data2;

	printf("Count: %d,%d\n",i,sizeof(PACKET));
	
	// GenerateKeyData
	
	int v13 = 0;
	char v49[56];
    do
    {
		//v49[v13] = (KeyData_105E09C8[2 * (KeyData_105E0960[v13] & 7)] & *(&v32 + (KeyData_105E0960[v13] >> 3))) != 0;
		++v13;
    }
    while ( v13 < 56 );
	
    int v15 = 0;
    /*  do
    {
      v19 = &v51[8 * v15];
      v16 = 0;
      v17 = (unsigned __int8)byte_105E0A38[v15];
      *(_DWORD *)v19 = 0;
      *(_DWORD *)&v50[8 * v15] = 0;
      v18 = v17;
      do
      {
        if ( v17 >= 28 )
          v20 = v48[v17];
        else
          v20 = v49[v17];
        v47[v16++] = v20;
        ++v17;
      }
      while ( v16 < 28 );
      v21 = 28;
      v22 = v18 + 28;
      do
      {
        if ( v22 >= 56 )
          v23 = v48[v22];
        else
          v23 = v49[v22];
        v47[v21++] = v23;
        ++v22;
      }
      while ( v21 < 56 );
      v25 = 0;
      v24 = (signed int)&unk_105E09D8;
      do
      {
        if ( v47[(unsigned __int8)byte_105E0998[v25]] )
          *(_DWORD *)&v50[8 * v15] |= *(_DWORD *)v24;
        if ( v47[(unsigned __int8)byte_105E09B0[v25]] )
          *(_DWORD *)v19 |= *(_DWORD *)v24;
        v24 += 4;
        ++v25;
      }
      while ( v24 < (signed int)byte_105E0A38 );
      ++v15;
    }
    while ( v15 < 16 );

	*/
	do
	{
		Data1ptr = (int*)(PACKET+0+j);
		Data2ptr = (int*)(PACKET_OUT+0+j);
		Crypt(Data1ptr,Data2ptr);
        i--;
		j+=8;
		//i=0;
	}
	while ( i );



	getchar();
	return EXIT_SUCCESS;
}
08/14/2010 17:10 wurstbrot123#292
Ich beschäftige mich momentan garnicht damit ^^
Aber ganz ehrlich, ich würds mit den Packets erstmal einfacher Versuchen :p
Ich mein wenn man nicht unbedingt einen eigenen Client schreiben möchte,
kann man ja die Spieleigenen Funktionen benutzen um packete zu verschlüsseln / injezieren. Zum entschlüsseln halt einen hook nach der Funktion zum entschlüsseln setzen um dann die Daten auszulesen. Dann muss man halt noch reversen wie der Client genau die Antworten für den X-Trap Server erstellt.
08/14/2010 18:12 shadow52#293
Das sind die Pakete die der "X-Trap" Server (Ip:211.43.208.219-Port:9110) sendet und Empfängt und vom X-Trap bzw LC-Client die dieser an den Server sendet und Empfängt. [Jedoch kann ich mit dem Buchstaben/Zahlen/SonderZeichen-"Salat" nichts anfangen :D) [Beim Hack finden senden X-trap außerdem auch ein Paket.]
08/15/2010 18:47 Feige^1#294
Quote:
Originally Posted by schattenbob View Post
news:

leute das xtrap isn icht wirklich nur bei lc.exe aktiv, das ding sitzt im ramspeicher und wühlt dort drin rum und schliesst lc.exe sobald auch nur annähernd irgendwas in den ramspeicher geladen wird. somit müsste man den mist im ram speicher eindämmen, oder lockén, freezen oder sonstwie einfrieren. hoffe das konnte helfen

Normal reichtsdoch schon wenn du das teil einfach soo Inaktiv machst .,,
hab was davon gehört das man das wohl auch viel schnelle rhinbekommen würde


Habs ne probiert aber ich gebe es mal preis .... weis nich egnau was der/die jenige damit sagen will aber vlt klappts ja .... also
kollege meinte macht mal rechtslick auf das lc symbol auf dem desktop und
dann auf eigenschaften -> Kompatibilität -> Programm im kompatibilitätsmodus ausführen für : Win xp SP3

damit sollte wohl irgendwas funzen ..... zumindest arbeitet man im mom auch daran das man allgemein nicht emhr fliegt ... weil das prog. xtrap auch immermal sinnlos jemanden raushaut ....

bin immernoch dran hatte die tage nicht viel zeit ....
musst mich um was anderes kümmerne werde mich aber wieder bissel damit ausseeinander setzen

Fg Feige^1
08/15/2010 19:05 .Da Hool#295
Das sich Gamigo damit keine Freunde macht ist klar, das damit noch mehr Leute mit lc aufhören als in der Zeit davor ist auch klar, aber, wurum machen die das wenn die nur auf den Provit aus sind.

Das letzte mal als ich auf LC USA on war, ist schon so 4 Monate her, aber schon zu dieser Zeit haben sehr viel weniger Leute dort gespielt. Man konnte die paar Leute noch auf Server 5 finden, auf den anderen mit Glück 5 Stück zählen...

Ich denke, diese kleinen Sachen wie X-Trap, massen Banns, etc. sind ein Teil von etwas großen. In einigen Ländern wurden die LC Server geschloßen...

Irgendwie kommt es mir vor, als hätte man von ganz oben beschloßen das es keinen sinn mehr mit lc macht und man systematisch alles schließen wird...

Das klingt zwar bischen paronoid, aber das ist das, was ich denke, also in diese Richtung...
08/15/2010 19:09 Eckenstehernante#296
Quote:
Originally Posted by Isall09 View Post
Das sich Gamigo damit keine Freunde macht ist klar, das damit noch mehr Leute mit lc aufhören als in der Zeit davor ist auch klar, aber, wurum machen die das wenn die nur auf den Provit aus sind.

Das letzte mal als ich auf LC USA on war, ist schon so 4 Monate her, aber schon zu dieser Zeit haben sehr viel weniger Leute dort gespielt. Man konnte die paar Leute noch auf Server 5 finden, auf den anderen mit Glück 5 Stück zählen...

Ich denke, diese kleinen Sachen wie X-Trap, massen Banns, etc. sind ein Teil von etwas großen. In einigen Ländern wurden die LC Server geschloßen...

Irgendwie kommt es mir vor, als hätte man von ganz oben beschloßen das es keinen sinn mehr mit lc macht und man systematisch alles schließen wird...

Das klingt zwar bischen paronoid, aber das ist das, was ich denke, also in diese Richtung...

paranoid würde ich nicht sagen aber in diesem jahr kommt ja eine neues game von gaymigo raus... "black prophecy" galub ich... vllt wollen die ja nur keinen neuen server kaufen weil sie sich von dem spiel mehr erwarten ;)
( spässle )
08/15/2010 19:33 nkkk#297
im offi forum hat jmd. geschrieben, dass er die packete an den koreaserver blocken konnte und keinen DC bekommen hat, kann dasss hier nochmal jmd testen bitte?

Die logiche folge währe ja dass die wenig damit zu tun haben..
(PS: kann man dass auch über den router machen? ich hab kein wirklichen zugriff auf meinen router da er nciht mir gehört, aber es innterressiert mich)
08/19/2010 10:52 teufel6688#298
Quote:
Originally Posted by wurstbrot123 View Post
Ich beschäftige mich momentan garnicht damit ^^
Aber ganz ehrlich, ich würds mit den Packets erstmal einfacher Versuchen :p
Ich mein wenn man nicht unbedingt einen eigenen Client schreiben möchte,
kann man ja die Spieleigenen Funktionen benutzen um packete zu verschlüsseln / injezieren. Zum entschlüsseln halt einen hook nach der Funktion zum entschlüsseln setzen um dann die Daten auszulesen. Dann muss man halt noch reversen wie der Client genau die Antworten für den X-Trap Server erstellt.

Es geht wirklich viel einfacher als es ausschaut um den x trap zu umgehn. Die Trainer funktionieren zum Teil, zumindestens speedhack geht, nur er erkennt den char net. Hmm da liegt mein Pbm da ich mich zwar neuerdings damit beschäftige aber noch net so recht weiss wie das alles so geht, aber sicher ist das mit CE auf alle fälle es funzt und kein dc dabei bis jetzt bekommen. Auch der alte Multiclient von Wurstbrot geht als ob nix wär.

Ihr müsst nur ne kopie erstellen vom gamigo, dann in der kopie y trap ordner löschen alles patchen wie bisher es immer so war und die Nksp aus dem Thread hier im vorfeld ersetzen ud LC normal starten, dann die kopie lc exe als admin starten so habt ihr erstmal n doppelfenster, dann das erste schliessen und damit is der x trap weg aus euer leiste. steht zwar immer noch im bin Ordner drin damit es funktioniert. dann startet ihr aus dem orginalen oder der Kopie LC ganz normal über wURSTBROT mULTICLIENT WIEDR LC, und damit hab t ihr dan den x trap umgangen da dieser nicht mehr bei euch in der taskleiste erscheint und auch somit nicht aktiv ist. Hab es selber gestern dden ganzen Tag getestet und ging ohne dc, auch wurde das durch n Kollege bestätigt der es parallel selbst getestet hat

so nun wünsch ich euch viel glück beim probieren und viel Spass beim gamen danach:D

MfG
08/19/2010 10:58 teufel6688#299
das einzige wo ich ne kleine unterstützung bräucht is das mit dem trainer gängig zu machen , da ich von KD die CE Einstellung ales zwar habe mir aber doch noch unsicher bin wo ich es in der basedatei es reingebe.
Würde mich freun wenn da mir eine rmal bissl helfen könnt, Danköööö im vorraus
08/19/2010 11:31 Nerowinger187#300
nimm doch einfach den . net trainer von dsgd..oder wie der nochmal genau heist....sry kann mir das buchstaben gewirr nie merken....
der hat nen Realease 16.08.10 bugfix. der geht soweit ich ihn getestet habe... hatte immer nur die probs das ich dc´s bekamm aber gelaufen ist er vor 1-2 tagen noch
Page 20 of 24 « First 101819 20 2122 Last »