EmulateMe

CDW

CDW

0
Mitarbeiter
ein sehr einfaches Crackme - entweder eine richtige Serial finden oder gleich patchen.
Ziel: als Ausgabe ein false (also 0) zu bekommen.
Der Hacken: es ist kein 0x86 ;)
Aber ich bin mal heute in der Weinachtsstimmung: ihr bekommt die Referenz, eine Hilfe und einen Emulator mit eingebautem Assembler dazu ;).

PS: Emulator ist schon recht betagt (2003). CPU ist ein 16-bitter mit 10 allgemein nutzbaren Registern.Wie der "Compile" Knopf andeutet, sollte es eigentlich ein einfacher Compiler werden.

Beispielcode währe:
Code: 
START ;PROGRAM RECHNE EINGABE
INI      EINGABE
ADD    0 EINGABE
ADD    0 VIER
OUTI   EINGABE
EOJ
EINGABE     DS F
VIER           DC 4
Code: 
START ;PROGRAMM ZUM ADDIEREN
INI ZAHL1
INI ZAHL2
LOAD 0, ZAHL1
ADD 0, ZAHL2
STORE 0, ZAHL2
OUTI ZAHL2
EOJ
ZAHL1 DS F
ZAHL2 DS F
Syntax muss man nur beachten, dass eigentlich nur ein Leerzeichen zwischen den Opernden notwendig ist (das Komma habe ich wegen der Intel-Syntax aus Gewohnheit mitgeschleppt - auch beim Komma muss man zusätzlich ein Leerzeichen lassen)


Emulator samt Hilfe und Referenz:
www.cdw.de.vu/emu.rar

Das Crackme:
Code: 
 0000: 115  000  000  078
 0004: 114  000  000  084
 0008: 088  001  000  090
 0012: 088  003  000  090
 0016: 080  001  000  086
 0020: 088  000  000  084
 0024: 088  002  000  088
 0028: 029  000  000  002
 0032: 026  003  000  000
 0036: 025  000  000  001
 0040: 071  007  000  028
 0044: 088  000  000  084
 0048: 029  000  000  002
 0052: 080  000  000  084
 0056: 089  003  000  084
 0060: 071  007  000  072
 0064: 115  000  000  080
 0068: 071  015  000  076
 0072: 115  000  000  082
 0076: 010  000 
 0078: 005  057 
 0080: 000  000 
 0082: 000  001 
 0084: 000  000 
 0086: 000  000 
 0088: 000  010 
 0090: 000  000

oder auch als Anhang (die Endung TXT entfernen und als crackme.bin abspeichern):
 
bin mir nicht sicher, ob ich das jetzt richtig "gepatcht" hab (nur eine zahl verändert)... aber richtige serials für das original EmulateMe sind z.b. "6", "7" oder "8"...

---------gepatcht---------
0000: 115 000 000 078
0004: 114 000 000 084
0008: 088 001 000 090
0012: 088 003 000 090
0016: 080 001 000 086
0020: 088 000 000 084
0024: 088 002 000 088
0028: 029 000 000 002
0032: 026 003 000 000
0036: 025 000 000 001
0040: 071 007 000 028
0044: 088 000 000 084
0048: 029 000 000 002
0052: 080 000 000 084
0056: 089 003 000 084
0060: 071 007 000 072
0064: 115 000 000 080
0068: 071 015 000 076
0072: 115 000 000 086
0076: 010 000
0078: 005 057
0080: 000 000
0082: 000 001
0084: 000 000
0086: 000 000
0088: 000 010
0090: 000 000
Zum Vergrößern anklicken....
//edit:
bei dem gepatchten sollte eigentlich immer 0 herauskommen, wie gefordert ;)

cYa
 
Ich bin mir nicht sicher Crystal, aber hast du nicht genau gepatcht was er verbieten wollte xD ?
Zum Vergrößern anklicken....
das war schon richtig (in diesem Fall die "Falschmeldung" dem Output unterzuschieben), und wie ich sehe, hätte ich etwas schwirigeres wählen sollen ;). Aber ich wollte ja erstmal sehen, ob jemand damit klarkommt - ein paar weitere Crackmes für die "ALI-Plattform" werden bald folgen. Das war frührer ein "übungsprojekt" und hat bietet einiges. Leider war ich damals so faul, dass ich viele Programme nicht mitgeschrieben habe - jetzt habe ich nur irgendwelche Demos, (die ich zum Teil auch dazugelegt habe)). Ist nämlich schon recht spannend,auf dieser Ebene rekursiv einenen Array sortieren zu lassen ;)
 
Ich hab mir gedacht: Warum sollte sich jeder Cracker die Mühe machen und jedes einzelne Mnem. einzeln raussuchen und sich durch die Binary quälen?

Damit ist jetzt Schluss (klingt nach Werbung :D)
Hier der ultimative ALI Disassembler. :P

http://home.arcor.de/neotracer/AliDasm.rar

Und hier die disassemblierte Crackme.bin:

Code: 
START
OUTI VAR1
INI VAR2
LOAD 1 VAR3
LOAD 3 VAR3
STORE 1 VAR4
LOAD 0 VAR2
LOAD 2 VAR5
ADDR1: DR 0 2
AR 3 0
CR 0 1
BNE ADDR1
LOAD 0 VAR2
DR 0 2
STORE 0 VAR2
CMP 3 VAR2
BNE ADDR2
OUTI VAR6
B ADDR3
ADDR2: OUTI VAR7
ADDR3: EOJ 
VAR1 DC 1337
VAR6 DS F
VAR7 DC 1
VAR2 DS F
VAR4 DS F
VAR5 DC 10
VAR3 DS F
 
Mist, ok, *denk,denk - aha:*
Ich habe mich dazu entschlossen, den Usern mehr Sicherheit und Überschaubarkeit zu bieten - zu diesem Zwecke werden in der nächsten Version ein CPM und CRM (Cdws Rrigth Managment) Chips integriert :D

Netter Disassembler ;). Jetzt muss kann man viel längere Crackmes schreiben (RAM: 4096 Byte) :D

Leider habe ich damals den Zeitpunkt verpasst, denn das Projekt war eigentlich sehr schön geeignet, um Assembly beizubringen.
PS: die "restliche" Syntax (vollständigkeitshalber):

Code: 
START
OUTI HALLO
LOAD 1 HALLO
LA 0 ARRAY
ST 1, 2(0)
ST 1, 4(0)
OUTI 2(0)
LA 8 ENDE
BR 8
OUTI 0(0)
ENDE:
EOJ
HALLO DC 1337
ARRAY DS 1000F

DC ist nichts anderes als Konstante.
mit XYZ DS F werden Variablen (16-bit) reserviert,
mit XY DS 1000F (Zahl)F ganze Speicherbereiche reserviert (also 1000 Variablen).
mit 2(0) leitet man die relative Adressierung ein (in Klammer immer das Register und davor eben der dazuaddierende Wert).
Adressierbar sind jetweils immer 16-Bit Werte.

LA lädt Adresse der Variablen/Sprungmarke
BR ist eben Brunch Rergister.
Es müssten noch mehr "nette Spielereien" da sein, die mir nicht mehr so richtig einfallen.
 
Um antworten zu können musst du eingeloggt sein.
Zurück
Oben