Verschlüsselung reversen?

[MaxMilimeter]

Hi,
ich würde gerne wissen wie man am besten an eine Packetverschlüsselung rangeht um diese zu reversen. Ich weiß, dass die von Nostale z.B. nicht sehr schwer zu knacken ist und mithilfe eines Sessionkeys encrypted wird, ab der Channelauswahl.

Jemand ne Idee wie ich das am besten lernen kann?

Aus
88226

wird (in HEX)
9A AC E4 90 DB 75 AF 0E

MfG,
Max

[meak1]

man schreibt 'hallo' im chat, macht einen breakpoint auf ws32_send und verfolgt es solang zurück(mit breakpoints) bis man das 'hallo' als argument übergabe sieht.

Dann benutzt man diese Funktion selber und tadaaaaa

[MaxMilimeter]

Ich würde sie aber gerne reversen um Client unabhängig zu arbeiten ^^

[meak1]

dann guckst du halt welche calls gemacht werden bis zur send, bzw wo das argument gecrypted wird und dann kopierst du diese mit IDA hex rays zu c++ code

[MaxMilimeter]

Ich habe noch nie mit IDA gearbeitet, wie wähle ich da überhaupt das Main Module wie bei OllyDBG?
Kannst Du mir kurz die Schritte nennen um den Code umzuwandeln?
Danke für den Tipp!

[meak1]

musst nur die funk finden die das argument crypted, dann guckst du halt welche addresse, auf diese jumpst du in IDA und dann i-wo show as hex rays oder so...

[MaxMilimeter]

Ok, war nicht einfach, aber ich habs nach ner Weile gefunden.

Falls mal wer das gleiche Problem hat:
View->Open subviews->Pseude Code

Man benötigt das Hex-Rays Plugin und muss vorher die Compilereinstellungen ändern (ich habe alles auf 4 gestellt), damit es läuft.

Sieht jedenfalls interessant aus, falls noch wer Tipps zu meiner Ausgangssituation hat, immer her damit

EDIT2:
OK, man könnte versuchen die Funktion zu übernehmen, aber was macht LOBYTE(a4) = a4 - 10; ?
Der Compiler weiß natürlich auch nicht was er mit dem = a4 - 10 anfangen soll.

Edit:
Gut, das müsste wohl der Code sein, bei dem die Verschlüsselung stattfindet. Das ist doch ein Unding daraus zu erknnen, wie nun verschlüsselt wird !? (EDX ist meine Zahlenkombi und eine Art Salt, schätz ich "57119(salt) 88226(meine_zahl)")

 Spoiler

signed int __userpurge sub_4ABB98<eax>(int a1<eax>, int a2<edx>, signed int a3<ecx>, int a4<ebx>, int a5)
{
int v5; // eax@4
int v6; // esi@4
char v7; // bl@5
char v8; // bl@6
char v9; // cf@7
char v10; // cf@8
signed int v11; // edi@12
signed int v12; // esi@18
signed int v13; // esi@29
char v14; // bl@32
char v16[4097]; // [sp+1h] [bp-101Dh]@3
int v17; // [sp+1Eh] [bp-1000h]@1
int v18; // [sp+1002h] [bp-1Ch]@13
char v19; // [sp+1009h] [bp-15h]@24
int i; // [sp+100Ah] [bp-14h]@17
int v21; // [sp+100Eh] [bp-10h]@4
int v22; // [sp+1012h] [bp-Ch]@1
int v23; // [sp+1016h] [bp-8h]@1
int v24; // [sp+101Ah] [bp-4h]@1

v17 = a1;
v22 = a3;
v23 = a2;
v24 = a1;
if ( a3 >= 4096 )
v22 = 4096;
sub_4052DC(v24, 2 * v22 + 1);
sub_403740(v16, v22);
v16[v22] = 0;
if ( v22 - 1 >= 0 )
{
v6 = v22;
v21 = 0;
v5 = (int)v16;
do
{
v7 = *(_BYTE *)(v23 + v21);
if ( !v7 )
break;
v8 = v7 - 32;
if ( v8 )
{
LOBYTE(a4) = a4 - 13;
v9 = (_BYTE)a4 < 2u;
LOBYTE(a4) = a4 - 2;
if ( !v9 )
{
--a4;
v10 = (_BYTE)a4 < 0xAu;
LOBYTE(a4) = a4 - 10;
if ( !v10 )
{
if ( (_BYTE)a4 != -59 )
continue;
}
}
}
*(_BYTE *)v5 = 49;
++v21;
++v5;
--v6;
}
while ( v6 );
}
v21 = 0;
v11 = 1;
while ( v21 < v22 )
{
v18 = v21;
while ( v16[v21] == 48 )
++v21;
if ( v21 > v18 )
{
for ( i = v21 - v18; i > 0; i -= 126 )
{
v12 = i;
if ( i > 126 )
v12 = 126;
for ( *(_BYTE *)(sub_4051A8() + v11++ - 1) = v12; v12 > 0; --v12 )
*(_BYTE *)(sub_4051A8() + v11++ - 1) = ~*(_BYTE *)(v23 + v18++);
}
}
if ( v21 >= v22 )
break;
v18 = v21;
v19 = 1;
while ( v16[v21] == 49 )
++v21;
if ( v21 > v18 )
{
for ( i = v21 - v18; i > 0; i -= 126 )
{
v13 = i;
if ( i > 126 )
v13 = 126;
for ( *(_BYTE *)(sub_4051A8() + v11++ - 1) = v13 | 0x80; v13 > 0; --v13 )
{
v14 = *(_BYTE *)(v23 + v18++);
if ( (unsigned __int8)(v14 - 48) >= 0xAu )
{
switch ( v14 )
{
case -224:
LOBYTE(a4) = 1;
break;
case -211:
LOBYTE(a4) = 2;
break;
case -210:
LOBYTE(a4) = 3;
break;
case -1:
LOBYTE(a4) = 14;
break;
default:
a4 = 0;
break;
}
}
else
{
LOBYTE(a4) = a4 - 44;
}
if ( v19 )
{
a4 *= 16;
*(_BYTE *)(sub_4051A8() + v11 - 1) = a4;
v19 = 0;
}
else
{
*(_BYTE *)(sub_4051A8() + v11 - 1) = a4 | *(_BYTE *)(*(_DWORD *)v24 + v11 - 1);
++v11;
v19 = 1;
}
}
if ( !v19 )
++v11;
}
}
}
*(_BYTE *)(sub_4051A8() + v11 - 1) = -1;
sub_4052DC(v24, v11);
return v11;
}

[EasyTale]

Hex-Rays finde ich persönlich schwachsinnig, bis ich da irgendwie durchblicke, bin ich mit dem Debugger 100x schneller. Zumal kennst du damit nicht die Inhalte der Variablen.

Da du die Funktion schon hast, schaust du ebend wieviele Parameter übergeben werden und was der Inhalt ist und steppst halt die Funktion durch, da sieht man ja was mit den jeweiligen Bytes passiert.
Dabei übersetzt du den asm Code (meistens nur die Schleife).
Es kann aber vorkommen, dass vor der Schleife noch Funktionsaufrufe kommen die, die Bytes präparieren oder vor dem eigentlichen Verschlüsselungsaufruf und sogar nach.
Es kommt also am Ende darauf an, wie geübt du mit einem Debugger umgehen kannst und wie schnell du asm Code liest.
Vielleicht kannst du dich versuchen etwas an Hey-Rays zu orientieren, aber mein Fall ist das definitiv nicht und die meisten die ich kenne auch nicht (mehr Zeitverschwendung als hilfe).

[Tyrar]

Originally Posted by EasyTale

Hex-Rays finde ich persönlich schwachsinnig, bis ich da irgendwie durchblicke, bin ich mit dem Debugger 100x schneller. Zumal kennst du damit nicht die Inhalte der Variablen.

Da du die Funktion schon hast, schaust du ebend wieviele Parameter übergeben werden und was der Inhalt ist und steppst halt die Funktion durch, da sieht man ja was mit den jeweiligen Bytes passiert.
Dabei übersetzt du den asm Code (meistens nur die Schleife).
Es kann aber vorkommen, dass vor der Schleife noch Funktionsaufrufe kommen die, die Bytes präparieren oder vor dem eigentlichen Verschlüsselungsaufruf und sogar nach.
Es kommt also am Ende darauf an, wie geübt du mit einem Debugger umgehen kannst und wie schnell du asm Code liest.
Vielleicht kannst du dich versuchen etwas an Hey-Rays zu orientieren, aber mein Fall ist das definitiv nicht und die meisten die ich kenne auch nicht (mehr Zeitverschwendung als hilfe).

Dem stimme ich teilweise zu, der Code den Hex-Rays ausspuckt ist in kleineren Funktionen nicht zu gebrauchen, in größeren kann man sich aber einen guten Überblick verschaffen.
Das wichtigste was die Verschlüsselung angeht ist wohl erst mal die Blockgröße. In deinem Fall dürften das wohl 64 Bit sein. In dem Fall würden wohl folgende (bekannteren) in frage kommen: CAST, TEA, XTEA, Skipjack, IDEA, Blowfish, FEAL, DES, 3DES und RC2 (hoffe ich habe keinen vergessen)
Um da genauer zu werden wäre die Schlüssellänge wichtig.

[EasyTale]

Da ich das obige Spiel kenne, kann ich mit gutem Gewissen sagen, dass das Spiel für Zahlen und bestimmte Zeichen eine Tabelle hat.
Für jede Zeichen und Zahlen in der Tabelle finden einige bitweise Operationen statt (es werden teilweise auch neue Bytes hinzugefügt), alle Zeichen die nicht in der Tabelle sind werden einfach gexored.
Es wird auch jedesmal die Lange angegeben, wenn z.B. die Zeichen beginnen die nicht in der Tabelle sind.
Bei den Bytes aus der Tabelle wird die Länge auch nochmal extra 'verschlüsselt'.
Anschließend wird anhand der SessionID nochmal ein Key erstellt und der Key gibt in einer Switchanweisung die nächsten Operationen (komplettes Paket wird nochmal gexored und +/- einer bestimmten Zahl addiert, ist aber unterschiedlich case zu case).

@Threadersteller: Wenn du willst, kannst du mir eine PN schreiben und ich helfe dir, vorrausgesetzt du bemühst dich dann noch ein bisschen.

[meak1]

ja okay, die hex ray funktion war sehr nützlich bei verschlüsselungen, hat mir sehr geholfen beim hackshield emu.

Weil die funktionen meist solang sind das es zu schwer wäre sie selber nach c++ umzuschreiben etc.

Aber an sich ja, man muss gucken welche argumente übergeben werden bzw sie verstehen woher sie kommen, meist werden argumente übergeben wie 'tabellen' die zum crypten benutzt werden <- man muss zb. gucken ob diese 'tabellen' statisch sind oder auch per ner funktion erstellt werden...

Ich hatte damals einen Bot mit kompletter verschlüsselung, ich dachte immer derjenige sei sehr erfahren bis ich i-wann rausfand das er einfach den kompletten verschlüsselungsteil aus IDA-hex rays kopiert hat..

Bin noch beim kumpel, lade mir das Spiel heut Abend mal oder mittwoch