Erste Schritte Brute Force Algorithmus

keyvee

Neues Mitglied
Hallo!

Meine Java Kenntnisse sind noch immer eher grundlegend. Um ein wenig Übung zu bekommen habe ich mich mal an einem eigenen Brute Force Algorithmus versucht. Es ist zwar eine sehr naive Implementation, aber sie funktioniert so weit. Das hat mich so motiviert, dass ich diesen Algorithmus gerne mit eurer Hilfe verbessern würde.

Ich sollte an dieser Stelle wohl anmerken, dass ich rein akademische Zwecke verfolge und nicht die Intention habe, mit diesem Algorithmus fremde Passwörter zu knacken. Mein Ziel ist es allerdings schon ein Programm zu erstellen, mit dem ich mein eigenes WPA2 Passwort herausfinden kann. Davon bin ich jedoch noch sehr weit entfernt 🙂

Java:
import java.util.Arrays;


public class BruteForce {

    public static void main(String[] args) {
        int [] targetPW = {1, 4, 11, 3, 5, 13, 18, 18};     // das Passwort, nach dem gesucht wird
        int charset = 18;        // Anzahl an verschiedenen Eingabewerten
        System.out.println(Arrays.toString(brute(targetPW, charset)));

    }
  
    public static int[] brute(int [] targetPW, int charset){
      
        int [] currentPW = new int[targetPW.length];    // Neues Array, mit dem verglichen wird
        int count = 0;    // Gibt Feedback wie weit der Algorithmus gesucht hat
      
        for (int p = 0; p <= charset; p++){                // Schleife läuft max. 18 (Anzahl charset) durch, nach jedem durchlauf wird der Zähler inkrementiert
            currentPW[targetPW.length-8] = p;            // und ausgegeben
            System.out.println(count + "...");            // 8 geschachtelte For-Schleifen, da das target Array 8 Stellen hat
            count++;
                for (int o = 0; o <= charset; o++){
                    currentPW[targetPW.length-7] = o;
                        for (int n = 0; n <= charset; n++){
                            currentPW[targetPW.length-6] = n;
                                for (int m = 0; m <= charset; m++){
                                    currentPW[targetPW.length-5] = m;
                                        for (int l = 0; l <= charset; l++){
                                            currentPW[targetPW.length-4] = l;
                                                for (int k = 0; k <= charset; k++){
                                                    currentPW[targetPW.length-3] = k;
                                                        for (int j = 0; j <= charset; j++){
                                                            currentPW[targetPW.length-2] = j;
                                                                for (int i = 0; i <= charset; i++){
                                                                    currentPW[targetPW.length-1] = i;
                                                                    if (Arrays.equals(targetPW, currentPW)){    // Wenn das richtige Passwort gefunden wurde
                                                                            return currentPW;                    // wird es als Array zurückgegeben
                                                                  
                                                                    }
      
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }
        return currentPW;
    }

}

Diese Dinge würde ich gerne ändern/verbessern:

1) Ich wäre gerne in der Lage die Methode mit einem Array aus Zahlen und Buchstaben aufzurufen (Bsp.: {h, a, n, s, m, u, e, l, l, e, r, 1, 2, 3, ...}). Ich würde dann alle doppelt vorkommenden Elemente entfernen und dann alle möglichen (erstmal 8-Stelligen) Permutationen dieses Arrays mit meinem targetPW Array vergleichen.

Mein Ansatz hier war ein String Array zu erstellen und jedem Element einen Int Wert zuzuweisen (in meinem Bsp.: h = 10, a = 11, ...). Damit könnte ich ein neues Int Array bilden (so wie es mein Code auch schon macht). Wenn eine Permutation gebildet ist müssten die Werte wieder den Buchstaben zugeordnet werden und das Int Array in ein String Array. Dann könnte ich wieder targetPW mit currentPW vergleichen. Ich glaube allerdings, dass dieser Ansatz viel zu umständlich ist.

2) Ich würde die Methode gerne mit einer variablen Password Länge aufrufen (z.B. min. 4 stellig, max. 8 stellig). Der Algorithmus sollte zuerst ein 4 stelliges Array erstellen und alle Permutationen testen. Gibt es keinen Treffer wird ein neues 5 stelliges Array gebildet usw. Da ich in meinem Code jedoch 8 verschachtelte for Schleifen habe kann ich die Länge des Arrays nicht variieren.

Generell bin ich für jeden Hinweis oder Ansatz dankbar, den ihr mir geben könnt. Man sieht ja, dass meine Möglichkeiten durch mein grundlegendes Verständnis sehr begrenzt sind.

Viele liebe Grüße,
keyvee
 
Zuletzt bearbeitet von einem Moderator:
Java:
        for (int p = 0; p <= charset; p++){                // Schleife läuft max. 18 (Anzahl charset) durch, nach jedem durchlauf wird der Zähler inkrementiert
            currentPW[targetPW.length-8] = p;            // und ausgegeben
            System.out.println(count + "...");            // 8 geschachtelte For-Schleifen, da das target Array 8 Stellen hat
            count++;
                for (int o = 0; o <= charset; o++){
                    currentPW[targetPW.length-7] = o;
                        for (int n = 0; n <= charset; n++){
                            currentPW[targetPW.length-6] = n;
                                for (int m = 0; m <= charset; m++){
                                    currentPW[targetPW.length-5] = m;
                                        for (int l = 0; l <= charset; l++){
                                            currentPW[targetPW.length-4] = l;
                                                for (int k = 0; k <= charset; k++){
                                                    currentPW[targetPW.length-3] = k;
                                                        for (int j = 0; j <= charset; j++){
                                                            currentPW[targetPW.length-2] = j;
                                                                for (int i = 0; i <= charset; i++){
                                                                    currentPW[targetPW.length-1] = i;
                                                                    if (Arrays.equals(targetPW, currentPW)){    // Wenn das richtige Passwort gefunden wurde
                                                                            return currentPW;                    // wird es als Array zurückgegeben
                                                                 
                                                                    }
     
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }

Sorry aber diese verschachtelten Schleifen solltest du versuchen aufzulösen -> Stichwort: Rekursion

1) .......
Mein Ansatz hier war ein String Array zu erstellen und jedem Element einen Int Wert zuzuweisen (in meinem Bsp.: h = 10, a = 11, ...).

Warum umständlich jedem Buchstaben selber einen Wert geben? Wenn du einen String hast kannst du dir mittels "toCharArray()" ein "char[]" holen. "char" kann ohne Probleme in ein "int" umgewandelt werden. Du kannst auch mit "char" rechnen. Schau dir doch einfach mal eine ASCII Tabelle an um zu sehen welcher Buchstabe welchen Wert besitzt: https://www.cs.cmu.edu/~pattis/15-1XX/common/handouts/ascii.html

2) Ich würde die Methode gerne mit einer variablen Password Länge aufrufen (z.B. min. 4 stellig, max. 8 stellig). Der Algorithmus sollte zuerst ein 4 stelliges Array erstellen und alle Permutationen testen. Gibt es keinen Treffer wird ein neues 5 stelliges Array gebildet usw. Da ich in meinem Code jedoch 8 verschachtelte for Schleifen habe kann ich die Länge des Arrays nicht variieren.

Wie oben schon geschrieben per Rekursion kannst du diese Verschacheltung anders lösen und dynamischer machen.
 
Also ein Anhaltspunkt wäre das k-fache kartesische Produkt. Hier findest du alle Möglichkeiten aus einer gegebenen Menge. Diese musst du dann noch mit der Eingabe vergleichen.
Ein weiterer Tipp ist: Arbeite mit Collections nicht mit Arrays.

Nur so gesagt: das Wort "password" hat 8 Stellen, wenn du nur das lowercase Alphabet (26 Buchstaben) hernimmst, dann hast du 8^26 Möglichkeiten und das dauert sehr sehr lange. Selbst wenn du weißt welche Buchstaben enthalten sind sind das schon 8^7 Möglichkeiten.
 

Neue Themen


Zurück
Oben