Browsing posts in: C#/C++

Dirt Rally – Joystick zum Schalten

Dirt Rally ist eine bekannte Autorennsimulation. Die teils sehr anspruchsvollen Kurse zu meistern ist ohne Lenkrad quasi unmöglich. Praktischerweise hatte ich ein altes Lenkrad herumstehen um ein wenig Dirt Rally zu spielen. Mein altes Lenkrad besteht nur aus dem Steuerrad und zwei Fußpedalen, es kommt daher ohne einen zusätzlichen Schalthebel aus. Praktischer und realistischer wäre es doch wenn man sich irgendwie einen Schalthebel aus einem alten Joystick bauen kann! Und genau dieses Projekt mit all seinen auftretenden Problemen soll in diesem Blogpost beschrieben werden.

Die Grundidee besteht aus einem externen Programm welches im Hintergrund mit dem Joystick kommuniziert. Sobald eine Schaltbewegung (= Joystick nach vorne/hinten und wieder in die Ruhelage) detektiert wird soll das Programm den Tastendruck zum Hoch- bzw. Runter schalten an Dirt Rally senden. Zum Auslesen des Joysticks gibt es ein nettes Tutorial mit dem Managed DirectX Framework mit dem das gewünschte Verhalten schnell implementiert werden konnte. Dabei wird die Y-Achse des Joysticks abgerufen ob sich der Wert auf 0 (= Vorne) oder 65535 ( = Hinten) befindet. Falls dieser Zustand erreicht wurde und wieder verlassen wird findet das „Schalten“ statt.

Joystick1

Nun ging es nur noch darum die Taste zum Hoch- bzw. Runterschalten an Dirt zu senden. Dazu gibt es verschiedene Wege wie z.B. SendKeys unter .NET oder die nativen Methoden wie SendMessage/SendInput . Problematisch war dass selbst nach mehreren Stunden des Experimentierens keine Tasteneingabe von diesem externen Programm an Dirt Rally gelangte. Ich weiß bis heute nicht warum das Programm nicht auf die Signale reagierte. Die Vermutung ist dass direkt mit dem Tastaturtreiber kommuniziert wird. Aber dieses Verhalten für den Blogpost ist es eigentlich sehr positiv denn sonst wäre er nie entstanden. Man musste sich also einen anderen Weg überlegen Tastatureingaben an Dirt Rally zu schicken.

Continue Reading

0

SQLiDumper 8.2 – Proxys!

Elektrotechnik wird zunächst einmal Beiseite gelegt, ich habe die Lust zum Reversen wiedergefunden. Ein Bekannter spielte mir ein Sample des SQLiDumpers 8.2 zu. Dieses universelle SQL Injection Tool nimmt faulen Leuten (und damit leider auch Leuten die keine Ahnung haben) die ganze Arbeit ab. Über das Suchen der SQL Injections per Google Dorks kann das Tool die gefunden Lücken direkt exploiten und auch Datensätze dumpen. Deswegen sei direkt gesagt: Das Tool wird hier definitiv nicht veröffentlicht, wer nur darauf aus ist kann sofort aufhören weiterzulesen.

Ich hatte bereits mit einigen alten Versionen dieses Tools zu tun, die immer unzureichend geschützt waren. Mal war es ein nativer Packer, der direkt die schön lesbare .NET Assembly lieferte, mal war der Code zum Generieren von gültigen Keys direkt mitgeliefert. Umso erstaunter war ich also, als ich ein Proxysystem entdeckte. Es ist lange nicht so komplex wie das Proxysystem von Confuser, was bereits behandelt wurde, aber dennoch komplex genug um spannende Erkentnisse mitzunehmen. Öffnen wir doch einfach die Assembly und schauen rein!

Ein paar Sachen fallen dem geübten Reverser direkt ins Auge: Wir haben eine Ressourcen Datei (Knappe 10 MB! ) und einen statischen <Module>.cctor-Konstruktor. In diesem Konstruktor stecken die Funktionen, die statische Variablen initialisert. Es wird daher von Obfuscatoren gerne genutzt um Anti-Debug funktionen zu starten oder Ressourcen zu entschlüsseln, denn diese Methode wird vor allen anderen aufgerufen. Des weiteren haben wir keine Namespaces und nur komisch benannte Klassen. Wer im .NET Bereich unterwegs ist erkennt sofort die Namen: Es sind Namen des .NET Frameworks die es so gibt! Allerdings enthalten sie nicht den Inhalt der originalen Framework-Klassen. Auch sieht man schon an dem Icon, dass es sich zum Teil um unterschiedliche Typen handelt. Wir behandeln erstmal den einfachsten Typ: Ein Delegate Proxy.

Continue Reading

0

RRT – Ein Auto Parken

Besser spät als nie! Hier der abschließende Post zu RRT – Eine Simulationsumgebung. Ich habe mich an einer typischen RRT Aufgabe Versucht: Parke das Auto in eine enge Parklücke und stelle es am Ende möglichst paralell zum Bordstein hin. Dabei nutzen wir genau das Automodell wie es im ersten Post eingeführt und verwendet wurde. Für anspruchsvollere Simulationen kann man z.B ein Auto mit Anhänger nehmen. Hier ist das Fahrverhalten nochmal komplett anders, RRT findet aber meist auch schöne Lösungen.

Das Interface der simplen Parksimulation hat ein paar Einstellmöglichkeiten spendiert bekommen. So können auch User die nicht im Sourcecode Werte manipulieren wollen mit der Simulation rumspielen. Ich freue mich übrigens auf Screenshots von euren schönsten Einparkmanövern in den Kommentaren 😉

rrt_new_interface

Bevor ihr allerdings mit Simulieren loslegen könnt, braucht ihr noch ein paar Informationen zur Simulationsumgebung: Die Umgebung ist 200 x 100 Pixel groß, das Auto startet bei (100,20) und will nach (102, 78). Dabei kann es Lenkwinkel von -50° bis +50° annehmen und dabei eine Stecke von -20 bis 20px pro „Schritt“ zurücklegen. Der Lenkwinkel und die Geschwindigkeit kann jeweils mit einem Multiplikator versehen werden, die voreingestellten Werte liefern ganz gute Resultate.

Spannend wird es, wenn man das Verhalten des Autos einschränkt: Wie parkt es, wenn es plötzlich nur noch nach Rechts lenken darf? Oder der Rückwärsgang kaputt ist und nur vorwährtsfahrend einparken muss? Ein paar dieser Fälle sind weiter unten mit Gif und Erklärung zu sehen . Continue Reading

0

EarthCore – Injecting, Sicherheit und Spieldaten

Earthcore: Shattered Elements ist ein Online Kartenspiel für Android und iOS, programmiert mit dem Unity Framework. Von den vier Handkarten spielt man drei auf das Spielfeld aus, wobei jede Karte eines von 3 Elementen hat: Feuer, Wasser oder Erde. Am Ende der Runde wird das eigene Kartenelement mit dem Element der gegnerischen, gegenüberliegenden Karte verglichen. Nun schlägt Wasser Feuer, Feuer Erde und Erde Wasser. Der Verlierer auf dem jeweiligen Feld bekommt Lebenspunkte abgezogen, die sich aus dem ausgespielten Kartenwert berechnen. Sollten sich gleiche Elemente gegenüberliegen, wird der Angriffswert jeweils für die nächste Runde gespeichert. Im Grunde also ein „Schere-Stein-Papier“ auf drei Feldern gleichzeitig. Spannend wird das Spiel, wenn man die Skills der Karten dazunimmt. Man kann Karten auf Feldern tauschen, die Elemente von Karten ändern oder auch Direktschaden am Gegener verursachen. Mehr möchte ich an dieser Stelle garnicht über das Spiel erzählen, hier geht es um die Internals, das Injecten und natürlich das Daten auslesen.

earthcoreNicht ohne Grund habe ich direkt im ersten Satz erwähnt, dass das Spiel mit Unity entwickelt wurde. Für den Programmierer ist das praktisch, da er Plattformunabhängig und sogar mit .NET Programmieren kann. Für uns hat das den Vorteil, dass wir den kompletten Sourcecode unobfuscated vor uns liegen haben! Dabei befinden sich alle interessanten Klassen in der Assembly-CSharp.dll, die wiederrum in den Ressourcen der APK liegt. Zwar hat man alle Daten unverschlüsselt vor sich liegen, nur ohne die Möglichkeit des Auslesens oder Veränderns bringen uns die schönsten Klassenstrukturen nichts. Wir müssen also eigenen Code in die Android Applikation bekommen. Während schon bei dem Hearthstone-Artikel das CLRHosting mit Mono fehlschlägt, haben hier hier nichtmal die Möglichkeit den Mono Kontext zu kapern. Nach einigem hin und herüberlegen fiel mir eine passable Lösung ein: Benötigt ist ein Loader, der wiederrum weitere DLLs zur Laufzeit nachladen kann. Dieser Loader wird mit in die APK gepackt und muss nun irgendwo im Spiel aufgerufen werden um den eigenen Thread zu starten. Was ist da passender, als die Init-Funktion des Hauptmenüs? In Unity erbt jede Klasse die Renderlogik enthält von „MonoBehaviour“. Davon wird die Start()-Methode aufgerufen sobald die Klasse initialisiert wird, und genau hier packen wir einen call auf unsere statische Loader-Klasse rein. Die will ich nun etwas genauer Besprechen:

Continue Reading

0

Age of Empires 2 – External Entity Hack

Ich glaube annährend jeder Besucher dieses Blogs hat früher, oder sogar in letzter Zeit als HD Remake, Age of Empires 2 gespielt. Dieses Kultspiel wird hier exemplarisch herrangezogen, um die Schritte beim Programmieren eines Hacks nachvollziehbarer zu machen. Genaue Offsets und Klassen gibt es nicht, wohl aber die Möglichkeit die Schritte nachzumachen. Damit stösst man unweigerlich auch auf die Offsets und lernt den Umgang mit IDA Pro und dem Debugger. Es ist definitiv nicht meine Intention, die Grundlage für einen Hack zu schaffen. Vielmehr hab ich gemerkt, wie schön man das Finden der Entites als Beispiel nutzen und abstrahieren kann.

Am Ende des Blogposts werden wir die Positionen aller Entites und aller Spieler auf eine Grafik plotten können. Natürlich wären weitere Features möglich, aber es geht nur um den Weg bis zu diesem Punkt 😉

Fangen wir mit etwas allgemeinen Informationen an. AoE2 ist wie eigentlich jedes ältere Spiel in C++ geschrieben. Konkret heißt das für uns, dass wir eine Entity-Basisklasse haben, von denen alle Einheiten und Gebäude erben. Im Speicher befindet sich also immer die Basisklasse, gefolgt von den speziellen Attributen je nach Klassentyp. Damit wissen wir auch, dass der erste Eintrag in diesen Entity-Klassen die VTable ist. Das Konzept dahinter wurde schon bei Siedler3 und Interfaces erklärt: Um bei einem Aufruf von „Building->Update()“ und „Unit->Update()“ bei unterschiedlichen Funktionen zu landen, wird der Update()-Funktionszeiger überschrieben, der sich an einer fixen Stelle innerhalb der VTable befindet. Das hat den Vorteil, das wenn wir ein riesiges Array von Entites haben, einfach alle durchlaufen und die Update()-Funktion aufrufen können. Die VTable sorgt dann schon dafür, dass die richtige spezielle Methode aufgerufen wird und wir müssen uns nicht darum kümmern.

Soviel zur gleich gebrauchten Theorie, los gehts in der Praxis mit Memory Scanning. Wie brauchen nämlich eine Variable, die sicher in der Entity-Klasse steht. Optional sollte sie noch leicht zu verändern und eindeutig sein. Was gibt es da passenderes wie das Leben der Entity? Starten wir Cheat Engine und stellen den Typ auf Float. Wir markieren eine Einheit, lesen das Leben ab und verändern es, indemaok1 wir die Einheit einen Gegner angreifen lassen. Zum Glück können wir über F3 das Spiel pausieren, so ist entspanntes Suchen nach der richtigen Variable möglich ohne in die Trickkiste greifen zu müssen. Übrig bleiben sollten zwei Variablen die jeweils das aktuelle Leben anzeigen. Mit der Adresse der Variable selbst fangen wir nichts an, denn spätenstens beim nächsten Spielstart sieht diese ganz anders ist. Spannender ist aber die Funktion von Cheat Engine, über den Debugger herraus zu finden welche Instruktionen auf die Variable zugreifen. Das ist natürlich auch im normalen Debugger über einen Memory-Breakpoint möglich, allerdings bekommen wir bei den doch vielen Zugriffen eine schöne Liste von CheatEngine.

Continue Reading

0

RRT – Eine Simulationsumgebung

Warum nicht auch Themen in einem Blogpost verarbeiten, die in der Uni Beachtung fanden und das Interesse auf eine eigene Implementierung wecken? In diesem ersten von zwei Teilen geht es darum, eine Simulationsumgebung für ein Auto zu schaffen, das später diverse Wege und Einparkroutinen findet. Das ganze Funktioniert über Rapidly-Exploring Random Trees, indem man einfach losfährt und dadurch einen Suchbaum aufspannt. Keine Wegfindung, keine Heuristik oder Gradientenfelder, aber vieeele Knoten und Versuche.

Langweilig denkt Ihr? Wenn ihr kein Interesse an dem eigenlichen Thema habt, so lernt ihr doch einiges über C# und objektorientierte Programmierung, welche uns das Leben wieder mal einfacher macht. Den aktuellen Sourcecode findet ihr unten im Anhang, da doch einige „unnötige“ Sachen wie Properties und Hilfsklassen nicht gepostet werden. Hier schonmal eine kleine Vorschau, was die Simulation am Ende vom Post mit wenigen Codezeilen kann:

rotation_colilision

Los ans Coden, beginnen wir mit der abstrakten Enviroment-Klasse. Von einer abstrakten Klasse kann keine Instanz (= kein Objekt) erstellt werden, und das ist auch gut so. Denn die Environment-Klasse dient nur als grobes Schema für alle weiteren Szenarien, daher halten wir sie sehr allgemein. Zunächst reicht es zu überlegen, was eine Simulationsumgebung braucht: Eine Höhe und Breite (ohne Einheit, aber rechnen wir in Metern) , natürlich ein sich bewegendes Objekt (Auto, Lastwagen mit Anhänger, Flugzeug) und eine Liste von Hindernissen, die es zu vermeiden gilt. In Code ausgedrückt sieht es sehr ähnlich aus:

Continue Reading

0

Code Injection und dynamische String Decryption

Bei der Analyse eines Programm sties ich heute Mittag auf eine String-Encryption der wildesten Art. In dem heutigen Post wird es um die Entschlüsselung dieser String-Encryption mit Mitteln der Code-Injection gehen.

Bei der String-Decryption wurde ein Offset der verschlüsselten Daten in EBX übergeben und im Gegenzug spucke die Funktion den entschlüsselten String in EAX wieder aus. Eine solche Entschlüsselung wurde in dieser Form schon oft gesehn und ist weiter nichts besonders. Folglich vermutete ich ein XOR decrypt in irgend einer Art. Daher staunte ich nicht schlecht, als ich mit einer unglaublich langen und mit mehreren Subfunktionen durchzogenen Methode stand. Eigentlich baut man die String-Decryption nach, aber in diesem Fall gab ich es nach 20 Minuten auf. Aus der Adresse (!) des Offsets wurden nach Bitshifting-Operationen Offsets in andere Speicherbereiche errechnet, die wiederrum mit in die Decryption einflossen. Diese Speicherbereiche wurden wiederrum erst zur Laufzeit berechnet etc etc. Das dumpen dieser ganzen Daten stellte sich als schwierig herraus, daher verfolgte ich einen anderen Ansatz: Code Injection!

StringDecryptDie Idee dahinter ist schnell erklärt: Anstatt dass man die String-Decrypt-Funktion rekonstruiert um sie im Programm zu verwenden, ruft man die Decrypt-Funktion direkt im zu crackenden Programm auf. Man schreibt also Shellcode der nichts anderes macht als einen String zu entschlüsseln. In diesem Fall ist der Umfang des Shellcodes beschränkt, denn wir müssen nur den gewünschten Offset in EBX laden, die Funktion aufrufen und das Resultat aus EAX auswerten. Uns werden dabei noch einige Steine in den Weg gelegt, aber über die steigen wir nach und nach drüber. Fangen wir erstmal damit an, wie der Shellcode überhaupt ins Programm gelangt und ausgeführt wird.

Continue Reading

0

HearthstoneCalc – Injecting

Der Werdegang von HearthstoneCalc hat einen eigenen Post verdient, in welchem dann weitere Ansätze (Monte Carlo Tree Search) vorgestellt werden. In diesem Blogeintrag geht es allerdings um das Injecten und Daten abrufen aus Hearthstone. Denn ohne Daten aus dem Spiel müssen wir HearthstoneCalc garnicht mehr weiterentwickeln.

Uns wird es zum Glück leicht gemacht. Hearthstone ist mit der Engine Unity3D geschrieben. Für Blizzard hat das den großen Vorteil, das Spiel einfach auf mobile Geräte (Tables und Smartphones, Android und iOS) portieren zu können. Für uns hat es den großen Vorteil, dass Unity .NET (genauer gesagt: Mono) verwendet. Und da die Binaries noch nicht einmal obfuscated vorliegen, haben wir ein relativ einfaches Spiel.

Der für Unity relevante Code wird in der Assembly-CSharp.dll gespeichert. Die Anzahl der Klassen überschreitet alles, was ich bisher gesehen habe. Dementsprechend fällt es am Anfang schwer, uns zurecht zu finden. Auch muss man sich zunächst an die Unity-Eigenarten gewöhnen: Jedes Objekt ist eine Entity, die wiederrum mehrere Unterentities haben kann. Oftmals haben Klassen Unterklassen, enthalten viel zu viel Renderlogik oder scheinen nie erzeugt zu werden.

GameStateDiagDaher gilt zu klären: Welche Daten müssen wir alle Abrufen? Die Daten aus dem Spiel müssen in die Strukturen von HearthstoneCalc gebracht werden. Die wichtigste und größte Struktur ist hierbei die GameState-Klasse (Links). Sie enthält das Spielfeld mit den Monstern, die Karten des Spielers und die Infos über die jeweiligen Helden. Natürlich haben die Helden weitere Unterklassen, wie z.B. die ausgerüstete Waffe oder die gesetzen Geheimnisse. Auch Monster sind inzwischen komplexer geworden, denn sie können verschiedene Buffs besitzen und auf andere umliegende Minions Einfluss ausüben.

Die Klassen aus Hearthstone können wir nicht einfach übernehmen, denn sie enthalten viel zu viele Informationen. Diese Klassen sind nicht dafür ausgelegt, Millionen möglicher Boardzustände zu speichern. Zu diesem Problem werde ich nächsten Post über HearthstoneCalc noch mehr sagen.

Der große Vorteil von Mono ist natürlich, dass wir realtiv einfach .NET Code ausführen können. .NET Code in einem Programm ausführen? Klingt doch sehr nach CLR-Hosting!? Leider ist das nicht so einfach, denn die Unity-Klassen mögen es nicht, wenn sie außerhalb von mscorlib.dll Thread aufgrufen werden. Versucht man eine Unity-Funktion direkt aufzurufen, so erhält man folgende Fehlermeldung zu gesicht:

Continue Reading

0

Cryptoanalyse – Known Plaintext

Es folgt der versprochene Beitrag zur Crypto-Analyse eines Usernet Account-Checkers. Dieser erlaubt es, den Account-Status per BB-Code in andere Seiten grafisch einzubinden. Klingt eigentlich nach einer netten Sache… Wenn dabei nur nicht die Account-Daten übergeben werden! Denn das PHP-Skript, welches das Bild erzeugt nimmt Usenet Username und Passwort als GET-Parameter entgegen. Um zu verhindern, dass die Accountdaten ausgelesen werden, wird der Accountname verschlüsselt.

usenetcheck

Ein solcher Include-Link sieht folgendermaßen aus:

usenext-check/image.php?a=vLjWqt+jvNGWm9S54bU==&p=dGVzdA==

Mit  dem scharfen Kryptoanalyse-Blick stellt man fest, dass a (der Accountname) und p (das Passwort) Base64 encodiert sind. Während das Passwort einfach ASCII-Encoded ist, bekommt man beim Decoden von Parameter a zunächst Probleme. Denn es hängt ein Gleichheitszeichen zu viel hinten dran! Wenn man dieses überflüssige Zeichen entfernt lassen sich die Daten zwar encodieren, aber es handelt sich nicht um einen ASCII-String. Anscheinend ist der Accountname verschlüsselt.

Nun haben wir den großen Vorteil zu einem Accountnamen den Chiptertext generieren können. Also haben wir eine Known-Plaintext-Attack und kommen mit etwas Glück auf den Key. Füttern wir den Account-Checker mit ein paar Werten und schauen uns das Resultat an. Vielleicht stellen wir ja Gesetzmäsigkeiten fest…

Continue Reading

0

DroidJack – Guter Ansatz, schlechte Implementierung

Heute geht es mal wieder um Malware, genauer gesagt um das Android Remote-Administration-Tool DroidJack. Für dieses überteuerte Tool wird es zwar keinen Leak geben, aber dafür ein paar Infos über den Crackschutz. Getreu nach dem Motto: „Guter Ansatz, schlechte Implementierung“.

DroidJack wirft dem Benutzer beim Öffnen des Programms einen Login-Bildschrim entgegen. Durch sniffen wird schnell klar, dass die Logindaten mitsamt Hardware-ID an die Access/DJ4.php des Servers geschickt wird. Ein Punkt gibts bereits Abzug, es wird kein HTTPS verwendet 😉

DJ

Java-Programme lassen sich, ähnlich wie .NET, einfach analysieren. Zumindest solange der Java-Zwischencode nicht verunstaltet wurde, denn in dem Fall versagen die gängigen Decompiler. Die meisten dieser Codeverunstalter-Tools (Obfuscatoren) ändern die Typenbezeichner, Klassennamen, Methoden und alles sonst, was Informationen enthalten könnte. Der hier verwendete Obfuscator schaffte es aber zugleich, Fehler beim Decompilen zu erzeugen. Somit musste ich mich mit dem Java-VM-Bytecode arbeiten, der ähnlich wie MSIL aufgebau ist. Da mir das zu blöd war, schaute ich mir erstmal die DJ4.php Datei an.

Continue Reading

0

Seiten:123456789