Passwort Brute Force rekursiv

[hobbyprogrammierer]

Hallo,

ich bin 17 Jahre alt und überlege mir, Info zu studieren. An meiner Schule konnte ich aber kein Info in der Oberstufe nehmen und programmiere deswegen in meiner Freizeit ein bisschen.

Folgendes Problem: Ein Passwort (klein und Großbuchstaben und zahlen) mit bruteforce zu knacken. Ich habe es jetzt Mal bis zu einer länge von dem Passwort von 5 Buchstaben/zahlen programmiert. Für 5 braucht mein PC auch schon sehr lange.

Aber ich möchte gerne wissen, ob ich es nicht auch rekursiv programmieren kann, damit die Passwortlänge theoretisch unbegrenzt lange sein kann (auch wenn mir klar ist, dass es sehr lange dauern würde)

public class Passwort
{
    private String passwort;
    private String werte[];
    
    public Passwort(String passwort){
    werte=new String[62];
    setPasswort(passwort);
    arrayFuellen();
    }
    
    public void setPasswort(String passwort){
    this.passwort=passwort;
    }
    
    private boolean istGleichPasswort(String passwort){
    return this.passwort.equals(passwort);
    }
    
    private void arrayFuellen(){
    
        for(int i=0; i<10; i++){
        werte[i]=Integer.toString(i);
        }
        
        for (int i=10; i<36; i++){
        werte[i] = Character.toString((char)i+55);
        }
        
        for (int i=36; i<62; i++){
        werte[i] = Character.toString((char)i+61);
        }
    }
    
    
    
    public String suchePasswort(int stellen){
        arrayFuellen();
        String passwort;
        
        for(int i=0; i<werte.length; i++){
        passwort = werte[i];
        System.out.println(passwort);
        if(istGleichPasswort(passwort)){return passwort;}
        }
        
        for(int i=0; i<werte.length; i++){
        passwort = werte[i];
            for (int j=0; j<werte.length; j++){
                passwort= passwort + werte [j];
                System.out.println(passwort);
                if(istGleichPasswort(passwort)){return passwort;}else{passwort = werte[i];}
            }
        }
        
            
            for(int i=0; i<werte.length; i++){
            passwort = werte[i];
                for (int j=0; j<werte.length; j++){
                passwort= werte[i] + werte [j];
                    for(int k=0; k<werte.length; k++){
                        passwort=passwort + werte[k];
                        System.out.println(passwort);
                        if(istGleichPasswort(passwort)){return passwort;}else{passwort = werte[i] + werte [j];}
                    }               
            }
        }
            
            for(int i=0; i<werte.length; i++){
            passwort = werte[i];
                for (int j=0; j<werte.length; j++){
                passwort= werte[i] + werte [j];
                    for(int k=0; k<werte.length; k++){
                        passwort=werte[i] + werte[j] + werte[k];
                            for(int l =0; l<werte.length; l++){
                                passwort=passwort + werte[l];
                                System.out.println(passwort);
                                if(istGleichPasswort(passwort)){return passwort;}else{passwort = werte[i] + werte [j] + werte [k];}
                                
                            }
                    }
                        
                }               
            }
            
            for(int i=0; i<werte.length; i++){
            passwort = werte[i];
                for (int j=0; j<werte.length; j++){
                passwort= werte[i] + werte [j];
                    for(int k=0; k<werte.length; k++){
                        passwort=werte[i] + werte[j] + werte[k];
                            for(int l =0; l<werte.length; l++){
                                passwort=werte[i]+ werte[j]+ werte[k]+werte[l];
                                for(int m=0; m<werte.length; m++){
                                passwort=passwort + werte[m];
                                System.out.println(passwort);
                                if(istGleichPasswort(passwort)){return passwort;}else{passwort = werte[i] + werte [j] + werte [k] + werte[l];}
                                }
                            }
                                
                                
                    }
                }
                        
            }   
            return null;
    }
}

Könnt ihr mir da bitte Helfen? Viele Grüße

 

[Robert Zenz]

Aber ich möchte gerne wissen, ob ich es nicht auch rekursiv programmieren kann, damit die Passwortlänge theoretisch unbegrenzt lange sein kann

Nein, rekursiv und unendlich geht fix nicht, weil dir irgendwann der Stapel ausgehen wird (lange vor dem restlichen Speicher bei einer normalen Schleife).

Jeder Methodenaufruf kommt auf den Stapel, und der Stapel ist im Vergleich zum restlichen Speicher sehr begrenzt. Rekursiv macht in kaum einem Kontext wirklich Sinn, insbesondere dann nicht wenn du eine grosze Tiefe zu erwarten hast.

 

[Robert Zenz]

Du musst deine Logik auf zwei Schleifen umbauen um beliebig lange Passworte zu unterstuetzen, das hat dann aber nichts mit rekursiv zu tun.

 

[hobbyprogrammierer]

Nein, rekursiv und unendlich geht fix nicht, weil dir irgendwann der Stapel ausgehen wird (lange vor dem restlichen Speicher bei einer normalen Schleife).

Jeder Methodenaufruf kommt auf den Stapel, und der Stapel ist im Vergleich zum restlichen Speicher sehr begrenzt. Rekursiv macht in kaum einem Kontext wirklich Sinn, insbesondere dann nicht wenn du eine grosze Tiefe zu erwarten hast.

Du musst deine Logik auf zwei Schleifen umbauen um beliebig lange Passworte zu unterstuetzen, das hat dann aber nichts mit rekursiv zu tun.

Ist Rekursiv hier auch theoretisch nicht möglich? Also auch nicht bis zB Länge 9 und nur zur Vereinfachung und Strahlung des Codes? Weil ich habe Mal gehört, wenn man viel copy and paste braucht und immer wieder das gleiche wo reinkopiert, würde rekursiv nahe liegen.

Und wie würde das mit zwei schleifen dann aussehen?

 

[Robert Zenz]

Ist Rekursiv hier auch theoretisch nicht möglich?

Theoretisch ja, praktisch macht es aber keinen Sinn. Die klassische Loesung mit rekursiv in dem Fall waere ja das du fuer jede Permutation einen Methodenaufruf hast, aber damit kommst du eben nicht weit weil dir der Stapel ausgeht.

Weil ich habe Mal gehört, wenn man viel copy and paste braucht und immer wieder das gleiche wo reinkopiert, würde rekursiv nahe liegen.

Nein, da liegt entweder eine Schleife oder eine Methode nahe, um das was man immer wieder macht einfach den Computer immer wieder machen zu lassen.

Und wie würde das mit zwei schleifen dann aussehen?

Sorry, das muss dir gerade jemand anderes zeigen, ich bin gerade zu blank im Kopf fuer tatsaechlichen Code (g'scheit daherred'n geht aber immer).

 

[hobbyprogrammierer]

Theoretisch ja, praktisch macht es aber keinen Sinn. Die klassische Loesung mit rekursiv in dem Fall waere ja das du fuer jede Permutation einen Methodenaufruf hast, aber damit kommst du eben nicht weit weil dir der Stapel ausgeht.


Nein, da liegt entweder eine Schleife oder eine Methode nahe, um das was man immer wieder macht einfach den Computer immer wieder machen zu lassen.


Sorry, das muss dir gerade jemand anderes zeigen, ich bin gerade zu blank im Kopf fuer tatsaechlichen Code (g'scheit daherred'n geht aber immer).

OK danke für deine Antworten. Wenn noch jemand anderes hier ist, mich würden sowohl die theoretische rekursive Lösung als auch die zwei schleifen Lösung interessieren.

 

[httpdigest]

Eine eine (iterative) Lösung für (theoretisch) beliebig lange Strings (in der Implementierung unten aber nur bis Länge 10) mit zwei Schleifen wäre:

import java.util.Optional;
import java.util.function.Predicate;
public class BruteForce {
  private static final String CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
  public static Optional<String> findPassword(Predicate<String> tester) {
    long n = 0L;
    char[] password = new char[10];
    while (true) {
      int len = 0;
      for (long v = n; v != 0L; v /= CHARS.length())
        password[len++] = CHARS.charAt((int) (v % CHARS.length()));
      if (tester.test(new String(password, 0, len)))
        return Optional.of(new String(password, 0, len));
      n++;
    }
  }

  // Test
  public static void main(String[] args) {
    String correctPassword = "te5t";
    System.out.println(findPassword(correctPassword::equals));
  }
}

 

[berndoa]

Nicht zwingend die schönste, effizienteste oder schnellste Methode aber wie bei einem Stellenwertsystem könnte man auch ein String Array bestimmter Länge haben, dieses zuerst auf den "kleisntmöglichen" Wert setzen (bspw. {a,a,a,a,a}) und dann in jedem Schritt "eins hoch zählen.
wenn deine möglichen Zeichen also bspw. von a-z gehen , würdest du zählen:
{a,a,a,a,a}
{a,a,a,a,b}
{a,a,a,a,c}
.....
{a,a,a,a,z}
{a,a,a,b,a}
{a,a,a,b,b}
{a,a,a,b,c}
immer weiter bis
{z,z,z,z,z}

Die methode zum "um eins erhöhen" lässt sich durchaus programmieren.
habe sowas shcon mal mit zahlen 0-49 durchgespielt, insofenr sollte das mit etwas Abwandlung auch mit Buchstaben oder so gehen 🙂