[gelößt] KeyGenMe/SerialMe #1

[GrafZahl]

Soo, wie der Titel schon sagt, gehts darum ein gültiges Pärchen aus Name und Serial zu erzeugen (oder alternativ einen Generator zu bauen der sowas tut)

Das Programm ist recht simpel gestrickt ... passt die SN zum Namen, gibts ein "OK" ... anderfalls ein "falsch"

Sprache: c
Compiler: MinGW
Schwierigkeitsgrad: "kann man das essen?"

 

[ReDoX]

Ich bin mir nicht sicher, ob man's essen kann

Hier mal ein paar Infos zu dem KeygenMe:

Spoiler:

Die Länge des Namens muss glatt durch 4 teilbar seinen, der Serial muss Doppelt so lang seinen wie der Name und darf nur aus folgenden Buchstaben bestehen: "0123456789ABCDEFabcdef". Der Serial wird in eine Zahl umgewandelt, für die gelten muss: Serial - NichtGenauerAnalysierteFunktion(Name) - NichtGenauerAnalysierteFunktion(Name) = 0.

Ich habe den Algorithmus, der dahinter steckt, nicht weiter analysiert.

Hier mal der Sourcecode für einen Keygen in Delphi.

var
  dword_406020, dword_406024, dword_406028: DWord;

  Table1: array [0..15] of byte = ($0F, $00, $0E, $01, $0D, $02, $0C, $03,  $0B, $04, $0A, $05, $09, $06, $08, $07);

  Table2: array [0..49] of byte = ( $0A, $0B, $0C, $0D, $0E, $0F, $00, $01,  $02, $03, $04, $05, $06, $07, $08, $09,
                                    $07, $08, $06, $09, $05, $0A, $04, $0B,  $03, $0C, $02, $0D, $01, $0E, $00, $0F,
                                    $0B, $0C, $0D, $0E, $0F, $00, $01, $02,  $03, $04, $05, $06, $07, $08, $09, $0A,
                                    $00, $00);

  NichtGenauerAnalysierteFunktion: function (ConvertTable, PSerial1, PSerial2: Pointer; Serial3, Serial4: AnsiChar): DWord; cdecl;

function NichtGenauerAnalysierteFunktion_Stub(ConvertTable, PSerial1, PSerial2: Pointer; Serial3, Serial4: AnsiChar): DWord; cdecl;
asm
  PUSH EBP
  MOV EBP,ESP
  PUSH EDI
  PUSH ESI
  PUSH EBX
  SUB ESP,$8
  MOV EAX,DWORD PTR SS:[EBP+$8]
  MOV EDX,DWORD PTR SS:[EBP+$C]
  MOV EBX,DWORD PTR SS:[EBP+$10]
  MOVSX ECX,BYTE PTR SS:[EBP+$14]
  MOV DWORD PTR SS:[EBP-$14],ECX
  MOV ESI,ECX
  AND ESI, $0F
  MOV CL,BYTE PTR SS:[EBP+$14]
  SAR CL,$4
  MOVSX ECX,CL
  MOVSX ECX,BYTE PTR DS:[EAX+ECX]
  SHL ECX,$4
  OR CL,BYTE PTR DS:[EAX+ESI]
  XOR BYTE PTR DS:[EDX],CL
  MOVSX ESI,BYTE PTR SS:[EBP+$18]
  MOV EDI,ESI
  AND EDI,$0F
  MOV CL,BYTE PTR SS:[EBP+$18]
  SAR CL,$4
  MOVSX ECX,CL
  MOVSX ECX,BYTE PTR DS:[EAX+ECX]
  SHL ECX,$4
  OR CL,BYTE PTR DS:[EAX+EDI]
  XOR CL,BYTE PTR DS:[EBX]
  MOV BYTE PTR DS:[EBX],CL
  MOVSX EDX,BYTE PTR DS:[EDX]
  MOVSX ECX,CL
  MOV DWORD PTR DS:[dword_406020],EDX
  MOV DWORD PTR DS:[dword_406024],ECX
  MOV EAX,DWORD PTR DS:[dword_406028]
  XOR EAX,$1
  MOV DWORD PTR DS:[&dword_406028],EAX
  MOV EDI,DWORD PTR SS:[EBP-$14]
  SHL EDI,$8
  LEA ESI,DWORD PTR DS:[EDI+ESI]
  MOV EAX,EDX
  SHL EAX,$18
  LEA EAX,DWORD PTR DS:[ESI+EAX]
  MOV EBX,ECX
  SHL EBX,$10
  ADD EAX,EBX
  SHL EDX,$8
  ADD ECX,EDX
  IMUL ECX,ESI
  XOR EAX,ECX
  ADD ESP,$8
  POP EBX
  POP ESI
  POP EDI
  LEAVE
  RETN
end;

function Keygen(Name: AnsiString): AnsiString;
var
  Hash1, Hash2: DWord;
  i: Integer;
begin
  result := '';
  NichtGenauerAnalysierteFunktion:= Pointer(DWord(@NichtGenauerAnalysierteFunktion_Stub) + 3); //Kill STACKFRAME!11
  if ((Length(Name) mod 4) = 0) then
  begin
    for i := 0 to pred(Length(Name) div 4) do
    begin
      Hash1 := NichtGenauerAnalysierteFunktion(@Table1[0], @Name[(i*4) + 1], @Name[(i*4) + 2], Name[(i*4) + 3], Name[(i*4) + 4]);
      Hash2 := NichtGenauerAnalysierteFunktion(@Table2[0], @Name[(i*4) + 3], @Name[(i*4) + 4], Name[(i*4) + 1], Name[(i*4) + 2]);
      result := result + IntToHex(Hash1 + Hash2, 8);
    end;
  end;
end;

Es Funktioniert allerdings nur für Namen der Länge 4. Bei Namen der Länge 8+ stimmt der in eine Zahl umgewandelte Serial-Teil nicht. Die ersten Teile sind immer 0, nur der letzte Teil stimmt. Ich bin mir nicht sicher, ob das ein Bug bei Dir ist oder ob ich einfach was übersehen habe.

Beispiel Serial:
Name: test
Serial: D96C51DC

Grüß,
redox

 

[GrafZahl]

mhh ... bei näherer betrachtung stelle ich fest ... falsche datei hochgeladen ... ;( ... die erste die ich gebaut hatte hat den besagten fehler ... und auch nur 2 substitutionsregister ...

aber das ändert nichts an der richtigen lösung