Bruteforce hashes mit multithreading. Funktioniert das so?

[Rusticus1999]

Hallo zusammen. Ich setze mich grad mit Kryptographie auseinader, genauer mit Hashes. Meine Idee war, da es jeden hash ja nur einmal geben sollte, aus dem hash und der ursprungslänge den originaltext wieder zu gewinnen durch ausprobieren aller kombinationen aus einer Menge von vorgegebenen zeichen. Das Ganze nennt sich meiner Kenntnis nach "Bruteforce" und könnte daran scheitern, dass hashes in diesem bereich doch mehr als einmal vorkommen. Um das ganze so schnell wie möglich laufen zu lassen hab ich das ganze mit multithreading gelöst und die günstigsten parameter angegeben. Beim ersten ausführen tat sich nach einer langen Zeit (10 min) nichts, weshalb ich mich jetzt frage ob dieses programm überhaupt funktioniert. Ich bin aber leider mit Multithreading und Hashes erst ganz kürzlich bekannt geworden, weshalb ich keine chance sehe das sagen zu können. Kann sich bitte jemand das programm mal angucken und mir sagen ob es funktioniert und wenn nicht, was ich ändern muss? Oder villeicht muss ich es ja auch einfach nur 3 jahre ausführen.

Würde mich sehr über hilfe freuen!
Nico

Der code:

import java.util.Arrays;

public class Analysis {
    public static void main(String[] args){
       String text = "hallo";
       System.out.println(new Analysis().bruteHash(text.hashCode(), text.length(), new char[]{'h','a','l','o'}));
    }
    int works = 1;
    boolean done = false;
    String bruteText;
    private class hashWorker extends Thread{
        int[] beg;
        int[] end;
        int hash;
        char[] zeichen;
        public synchronized void run(){
            System.out.println("Worker: " + works++ +" started!");
            int[] akt = Arrays.copyOf(beg, beg.length);
            while(!done && !Arrays.equals(akt, end)){
                 for(int i = 1; i < akt.length; i++){
                     if(akt[i] == (zeichen.length-1)){
                         akt[i] = 0;
                         akt[i-1]++;
                     }
                 }
                 String sAkt = "";
                 for(int i = 0; i < akt.length; i++){
                     sAkt += zeichen[akt[i]];
                 }
                 if(sAkt.hashCode() == hash){
                     bruteText = sAkt;
                     done = true;
                     return;
                 }
            }
        }
        public hashWorker(int[] anfang, int[] ende, int hash , char[] zeich) {
            beg = Arrays.copyOf(anfang, anfang.length);
            end = Arrays.copyOf(ende, ende.length);
            this.hash = hash;
            zeichen = Arrays.copyOf(zeich, zeich.length);
        }
      
    }
  
    public String bruteHash(int hash, int length, char[] zeichensatz){
        int threads = 12;
        hashWorker[] workers = new hashWorker[threads];
        for(int i = 0; i < threads; i++){
            int[] beg = new int[length];
            int[] end = new int[length];
            //beg
            if(i != 0)beg[0] = ((zeichensatz.length-1) * i/threads);
            //end
            if(i == threads-1){
                for(int j = 0; j < end.length; j++){
                    end[j] = zeichensatz.length-1;
                }
            }
            else end[0] = ((zeichensatz.length-1) * (i + 1)/threads)+1;
             workers[i] = new hashWorker(beg, end, hash, zeichensatz);
        }
        for(hashWorker w : workers){
            w.start();
        }
        for(hashWorker w : workers){
            try {
                w.join();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return bruteText;
    }
}