Bruteforce eines Schlüssels?

[himitsu]

Du weißt was ein Hash ist?

Ein Hash hat gerade die absichtliche Eigenschaft, daß man den Eingangsstring nicht berechnen kann ... nichtmal mit Bruteforce.

OK, wenn man eine bestimmte Vorgabe hat (z.B. genaue Länge und der Zeichensatz), dann kann man mit einer gewissen Wahrscheinlichkeit die Aussage treffen, daß dieser Eingangcode jenen Hash ergibt.
Es kann aber sein, daß es noch einen/mehrere andere Codes gibt, welche ebenfalls diesen Hash ergeben.

Bei Dateien mit einer Größe von nur 17 Byte, gibt es statistisch gesehn 256 weitere Dateien, die alle den selben Hash 128-Bit-Hash ergeben.

[Zacherl]

Zitat von Lyan:

was ich genau machen möchte ist ja nicht relevant )

Es geht nicht zufällig darum, die Ausführung der Anwendung explizit zu verzögern, um Software VMs / Sandboxes von z.b. AntiViren Programmen dazu zu bringen die Laufzeit-Analyse abzubrechen?

Bei einer Themida geschützten Anwendung habe ich mal gesehen, dass dort im Startup (sinnlos) PI bis zu einer bestimmten Stelle berechnet wurde, um genau das von mir beschriebene Ziel zu erreichen.

[dGeek]

Zitat von sx2008:

Also wenn ich eine Demoanwendung schreiben müsste dann würde ich es so machen:
Man wähle einen zufälligen String mit maximal 8 Ziffern.
Aus diesem String wird mit MD5 ein Hash erstellt.
Dabei hilft z.B. diese Webseite: http://www.hashgenerator.de/

Hier einige Beispiele:

Code:

23449ce8ea5e51c73d43784b13028a52 - 8 Ziffern (100000000 Möglichkeiten)
51f6f8fe03a390d3de50ad49913d4b66 - 6 Ziffern (1000000 Möglichkeiten)
131ab68be139f348e6aa22bab7e16627 - 5 Buchstaben A-Z (11881376 Möglichkeiten)

Jetzt soll ein Programm dem nur der Hashwert bekannt ist den ursprünglichen String (Passwort, Pin) per Bruteforce ermitteln.

Mit genau solch einem Programm habe ich ein paar Tests gemacht.

Bei einem Intel Core i7 720QM mit TurboBoost 2.8 GHz sind das etwa die Zeiten:
- 23449ce8ea5e51c73d43784b13028a52 (08154711) nach 8154712 Versuchen, 25 Sekunden
- 51f6f8fe03a390d3de50ad49913d4b66 (123459) nach 123460 Versuchen, 0.150 Sekunden
- 131ab68be139f348e6aa22bab7e16627 (ZAPPY) nach 11434955 Versuchen, 25 Sekunden

[sx2008]

Zitat von himitsu:

Ein Hash hat gerade die absichtliche Eigenschaft, daß man den Eingangsstring nicht berechnen kann ... nichtmal mit Bruteforce.

Das spielt doch keine Rolle! Sobald man nur einen Treffer findet ist der Schlüssel/Passwort/WasAuchImmer gebrochen.
Natürlich gibt es zu einem Hashwwert im Prinzip unendlich viele Schüssel.
Aber der Schlüssel mit der kürzesten Länge wird mit höchster Wahrscheinlichkeit der ursprüngliche Schlüssel sein.

Wenn man weiss dass ein Passwort eine bestimmte maximale Länge hat, sich auch ganz bestimmten Zeichen (z.B. nur Ziffern) zusammensetzt und mit MD5 (oder MD4, Sha1,...) gehasht wurde kann man ausrechnen wie viele mögliche Kombinationen er gibt.
Wenn es nicht zu viele Kombinationen sind kann man mit Bruteforce leicht zum Erfolg kommen.
Selbst wenn das Passwort "gesalzen" ist, aber die Methode bekannt ist kann man Bruteforce ansetzen.

Delphi-Quellcode:

// Pseudocode
function SaltPW(const PW:string):string;
begin
   return "salt42" + PW;
end;

for i:= minlen to maxlen do
   foreach pw:string in Range(['0'..'9', 'a'..'z'], i) do
   begin
      if(MD5string(SaltPW(pw)) = '51f6f8fe03a390d3de50ad49913d4b66' then
      begin
         ShowMessage('Passwort='+pw);
         return;
      end;
   end

[sx2008]

Zitat von dGeek:

- 23449ce8ea5e51c73d43784b13028a52 (08154711) nach 8154712 Versuchen, 25 Sekunden
- 51f6f8fe03a390d3de50ad49913d4b66 (123459) nach 123460 Versuchen, 0.150 Sekunden
- 131ab68be139f348e6aa22bab7e16627 (ZAPPY) nach 11434955 Versuchen, 25 Sekunden

Alle 3 Schlüssel sind richtig

[Lyan]

Code:

;Decrypt the exe which is stored in the data section
proc decryptExecutable stdcall APITable:DWORD, image_base:DWORD, section_header:DWORD

local str1[256]:BYTE, ret_val:DWORD, section_address:DWORD,\
section_size:DWORD, key[KEY_SIZE]:BYTE, encrypted_backup:DWORD

   pushad
   ;get section adress and size
   stdcall writeNewLineToLog, [APITable]
   writeWithNewLine createStringDecrypting, str1, dec_exit_error
   mov eax,[image_base]
   mov ebx,[section_header]
   mov edx,[ebx+IMAGE_SECTION_HEADER.VirtualSize]
   mov [section_size],edx
   mov edx,[ebx+IMAGE_SECTION_HEADER.VirtualAddress]
   add eax,edx
   mov [section_address],eax

   ;init key
   lea edi,[key]
   mov ecx, KEY_SIZE
   mov al,0
dec_init_key:
   mov [edi],al
   inc edi
   dec ecx
   jnz dec_init_key

   ;create a copy of the encrypted file
   ;which is used to brute force the key
   mov eax,[APITable]
   stdcall dword [eax+VirtualAlloc], 0, [section_size], MEM_COMMIT+MEM_RESERVE, PAGE_READWRITE
   test eax, eax
   jz dec_exit_error
   mov [encrypted_backup],eax
   ;now copy the file into the buffer
   mov edi,eax
   mov esi,[section_address]
   mov ecx,[section_size]
   ;we can mov dwords because buffer is a multiple of 16
   shr ecx,2
   repz movsd

keyspace_loop:
   lea eax,[key]
   stdcall decAES, [section_size],  [section_address],  [section_address], eax
   stdcall verifyChecksum, [section_address], [section_size]
   test eax,eax
   jnz dec_decrypted_success

   ;restore the encrypted version to try the next key
   mov esi,[encrypted_backup]
   mov edi,[section_address]
   mov ecx,[section_size]
   shr ecx,2
   repz movsd
   ;lea eax,[key]
   ;stdcall encAES, [section_size],  [section_address],  [section_address], eax

   ;next key
   lea eax,[key]
   stdcall nextKey, eax
   test eax,eax
   jz dec_exit_error
   ;abort if key space was explored, else continue
   jmp keyspace_loop

dec_decrypted_success:
   mov eax,[APITable]
   stdcall dword [eax+VirtualFree], [encrypted_backup], 0, MEM_RELEASE
   test eax, eax
   jz dec_exit_error

dec_exit_success:
   popad
   mov eax,1
   ret

dec_exit_error:
   popad
   sub eax,eax
   ret

endp

;xor encryption
proc encryptXOR stdcall data_ptr:DWORD, data_size:DWORD, key_ptr:DWORD

local key_counter:DWORD

   pushad
   mov [key_counter],0
   mov edi,[data_ptr]
encxor_loop:
   ;get key, data and xor it
   mov eax,[key_ptr]
   add eax,[key_counter]
   mov bl,byte [eax]
   mov bh,byte [edi]
   xor bh,bl
   mov [edi],bh
   ;increase counter variables
   mov eax,[key_counter]
   inc eax
   cmp eax,KEY_SIZE
   jne encxor_noreset_keycounter
   sub eax,eax
encxor_noreset_keycounter:
   mov [key_counter],eax
   ;increase data ptr
   mov eax,[data_size]
   dec eax
   jz encxor_exit
   mov [data_size],eax
   inc edi
   jmp encxor_loop

encxor_exit:
   popad
   ret
endp

;generate next decryption key
proc nextKey stdcall key_ptr:DWORD

   push ebx
   mov eax,[key_ptr]
   mov ebx,eax
   add ebx,REAL_KEY_SIZE
nkey_next_element:
   inc byte [eax]
   cmp byte [eax],REAL_KEY_RANGE
   jne nkey_not_finished
   mov byte [eax],0
   inc eax
   cmp eax,ebx
   je nkey_finished
   jmp nkey_next_element

nkey_not_finished:
   pop ebx
   mov eax,1
   ret

nkey_finished:
   pop ebx
   sub eax,eax
   ret

endp;

Wie gesagt, das Prinzip ist eigtl. das richtige.
Danke für die bisherigen Antworten, auch wenn himitsu voll am trollen ist Habe den Lüfter abgemacht und es hat in der Tat etwas geraucht bei Ausführung himitsus codes.

Zitat von himitsu:

Bruteforce eines Wertes mit 32 Bit länge.

Delphi-Quellcode:

var Schlüssel, i: Integer

Schlüssel := Random($FFFFFFFF);

//

for i := 0 to $FFFFFFFF-1 do
  if i = Schlüssel then
    ShowMessage('Der Schlüssel ist ' + IntToStr(i));

Für "Schlüssel" kann man auch gern eine Ver-/Entschlüsselungsfunktion einsetzen.



Das mit der Zeit kannst du vergessen, denn es gibt sehr schnelle und auch sehr langsame PCs ... da kann man nichts an tempo vorhersagen.
Du kannst nur einer Entschlüsselungsfunktion bauen, welche eine bestimmte Menge an komplexeren Rechenoperationen benötigt, um etwas zu entschlüsseln.

Das Problem himitsu, besteht darin, dass mein Programm den Schlüssel nicht kennen darf. Ich denke dir ist bewusst was ich suche

Das mit den hashes wird definitiv meine "Notlösung". Nicht dass es schlecht sei oder so, im Gegenteil. Aber ich kann mich nur ungern mit dem Gedanken anfreunden dass es eben ein Hash ist. Das was himitsu sagte, ist ja prinzipiell richtig, auch wenn man die Länge kennt, hat man keine 100%ige Sicherheit..

[Mavarik]

Zitat von Lyan:

Das Problem ... besteht darin, dass mein Programm den Schlüssel nicht kennen darf.

OK! Aber dann musst Du den Inhalt kennen... Womit willst Du sonst Deine erbrüteten Key's vergleichen...

TextA -> PKey -> BLUB -> OKey -> v3"k = ? (TextA)

Mavarik

[Lyan]

Zitat von Mavarik:

Zitat von Lyan:

Das Problem ... besteht darin, dass mein Programm den Schlüssel nicht kennen darf.

OK! Aber dann musst Du den Inhalt kennen... Womit willst Du sonst Deine erbrüteten Key's vergleichen...

TextA -> PKey -> BLUB -> OKey -> v3"k = ? (TextA)

Mavarik

Nun ja, dann werde ich wohl den Vorschlag mit dem Hash verwenden, das ist immerhin das was ich suche, auch wenn man sagen darf dass die Methode nicht 100%ig den richtigen Key bruted...