Bruteforce eines Schlüssels?

[Lyan]

Hallo,

ich sage schon mal im Voraus: ich habe keine Ahnung wie das geht und ich möchte auch keine Komplettlösung oder Codebeispiele.

Ich möchte im groben eine Verschlüsselungs- und Entschlüsselungsroutine haben, wobei die Entschlüsselungsroutine den Key, mit der die Verschlüsselungsroutine einen String vorher verschlüsselt hat, nicht kennt.

Dementsprechend soll beim Aufruf der Entschlüsselungsroutine zuerst der Key ->bruteforced<- werden, der zur Entschlüsselung gebraucht wird. Das Bruteforcen sollte nicht länger als 5 Minuten dauern, jedoch nicht kürzer als 30 Sekunden. Klar ist dass es von Rechner zu Rechner stark unterschiedliche Bruteforcezeiten geben wird und man den Wunsch mit 30 Sekunden und 5 Minuten natürlich nicht genau einhalten kann. Man kann zumindest bei der Vorstellung an durchschnittsrechner denken anstatt an das Rechenzentrum von google :X

Was brauche ich?

Mathematische Themen mit denen ich mich befassen muss. Bsp.: Ich habe vor kurzem zum Spaß mit primitivwurzeln gearbeitet und das hat mir schon ganz gut gefallen, jedoch meinen Vorstellungen nach nicht gut genug.

Ich hoffe ihr versteht was ich suche (was ich genau machen möchte ist ja nicht relevant :))


EDIT://

Habe was gefunden: https://github.com/Veil-Framework/Ve...executable.asm

Meine ASM Kenntnisse reichen aber leider nicht aus :D Ich denke aber dort geschieht genau das was ich brauche, da er auf der Frontpage folgendes sagt:

Zitat:

The key space size can be changed in the crypter source code to speed up the brute force key search algorithm.

EDIT:// tested. Funktioniert genau wie ich es möchte. Jetzt müsste ich nurnoch ASM lernen um zu verstehen was er da genau tut ;D
EDIT:// Hab den ASM code doch nachvollziehen können, ist mir aber definitiv viel zu simple wie er es macht :/ XOR wollte ich nicht als main Verschlüsselung benutzen, er tut es und dann noch in einer Schleife :X

Danke im voraus.

Lg, Lyan

[dGeek]

Also das mit den 30 Sekunden und 5 Minuten kannst du vergessen wenn du keinen NASA-PC hast.

Keys sind generell immer sehr lang. Bei einer Länge von 16, a-z, A-Z, äöüÄÖÜß und 0-9 wären das 2,63989996910095*10^29 verschiedene Möglichkeiten.
Selbst bei einer Länge von 8 und nur a-z und äöüß wären es 656100000000 Möglichkeiten.
Vergiss es :)

[Lyan]

Ich verstehe deinen Ansatz, der ist aber leider nicht ganz da wo ich hin möchte ;)

In deinem Beispiel:
Entweder ich hab direkt einen treffer, oder es dauert ein wenig, oder ich bin 2020 noch nicht fertig.

Ich suche, nochmals für die anderen die das lesen gesagt, ein VERFAHREN(mathematisch) mit dem sich ein Schlüssel bruteforcen lässt. Ich kann mir gut vorstellen, dass ich z.b. anfangs einen "public key" habe und damit den "private key" bruteforcen muss.

Vor langer Zeit habe ich einen Artikel gelesen. Ich glaube paar Leute aus dem MIT hatten "dieses" mathematische Verfahren angewandt und genau das gemacht was ich grade vorhabe. Ärgere mich darüber den Artikel nicht mehr zu haben ;(

[himitsu]

Bruteforce eines Wertes mit 32 Bit länge. :stupid:

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.

[Uwe Raabe]

Zitat:

Zitat von Lyan (Beitrag 1283363)

Ich suche, nochmals für die anderen die das lesen gesagt, ein VERFAHREN(mathematisch) mit dem sich ein Schlüssel bruteforcen lässt.

Kannst du mal beschreiben, was du mit dem Begriff "bruteforcen" meinst bzw. was du glaubst, was das heißt? Ich habe so den Eindruck, daß es hier noch Verständnisschwierigkeiten gibt.

[himitsu]

Ich denk mal daß es nicht Brutefoce sein soll ... das Entschlpsseln soll einfach sinnlos etwas länger dauern.
Man lade sich das Programm Cryptload und versuche damit mal eine CryptloadContainerFile (CCF) zu laden ... soweit ich mich erinnere dauerte das auch schwachsinnig lange.

Im Prinzip ist das eher eine Methode um Bruteforce und Co. zu unterbinden auszubremsen oder um zu verhindern daß unendlich viele Dateien in kurzer Zeit entschlüsselt werden können.

[p80286]

Zitat:

Zitat von himitsu (Beitrag 1283372)

Bruteforce eines Wertes mit 32 Bit länge. :stupid:

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.

Ich befürchte er möchte etwas mehr "Rauch" haben. Nach dem Motto "Chemie ist's wenn's knallt und stinkt"

Gruß
K-H

[himitsu]

Schraub einfach mal den Kühlkörper von deiner CPU ab und führe den Code aus :firejump:

[p80286]

Brute heat!

Gruß
K-H

[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.

[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:

Zitat von Lyan (Beitrag 1283361)

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? :stupid:

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:

Zitat von sx2008 (Beitrag 1283384)

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:

Zitat von himitsu (Beitrag 1283386)

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:

Zitat von dGeek (Beitrag 1283394)

- 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 :thumb:

[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 :D Habe den Lüfter abgemacht und es hat in der Tat etwas geraucht bei Ausführung himitsus codes.

Zitat:

Zitat von himitsu (Beitrag 1283372)

Bruteforce eines Wertes mit 32 Bit länge. :stupid:

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:

Zitat von Lyan (Beitrag 1283399)

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:

Zitat von Mavarik (Beitrag 1283432)

Zitat:

Zitat von Lyan (Beitrag 1283399)

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...