code optimierung

[Gaara]

hi, ich schreib immoment nen MD5 cracker, eig. nicht weil ich ihn brauchen oder sonstwas, geht nur darum dass ich wenigstens irgendwas code...
ich hab schon von vielen gelesen dass ihre md5 cracker mit ca 1,2mio hashs/s cracken und meiner macht ca. 8mio/minute was mir um ehrlich zu sein etwas zu langsam is... ich weis nicht wie die anderen cracker die hashs erstellen aber ich hab eine funktion geschrieben die alle kombinationen aus groß/klein buchstaben,zahlen und sonderzeichen berechnet, diese strings wandel ich dann in hashs um... somit ist es zwar langsam aber dafür hab ich komplett alle möglichkeiten durch.
da diese funktion aber sehr groß und ich vermute auch umständlich ist würd ich gern hier mal fragen wie ihr das lösen würdet...

string ausgabe(int a, int b, int c,int d, int e, int f,int g, int h, int i, int j,int k,int l,int m, valarray<string> &arr)
{
    string passwort;
    if(i==-1)
    {
        passwort=arr[m]+arr[l]+arr[k]+arr[j];
        return passwort;
    }
    else if(h==-1)
    {
       passwort=arr[m]+arr[l]+arr[k]+arr[j]+arr[i];
       return passwort;
    }
    else if(g==-1)
    {
       passwort=arr[m]+arr[l]+arr[k]+arr[j]+arr[i]+arr[h];
       return passwort;
    }
    else if(f==-1)
    {
       passwort=arr[m]+arr[l]+arr[k]+arr[j]+arr[i]+arr[h]+arr[g];
       return passwort;
    }
    else if(e==-1)
    {
       passwort=arr[m]+arr[l]+arr[k]+arr[j]+arr[i]+arr[h]+arr[g]+arr[f];
       return passwort;
    }
    else if(d==-1)
    {
       passwort=arr[m]+arr[l]+arr[k]+arr[j]+arr[i]+arr[h]+arr[g]+arr[f]+arr[e];
       return passwort;
    }
    else if(c==-1)
    {
       passwort=arr[m]+arr[l]+arr[k]+arr[j]+arr[i]+arr[h]+arr[g]+arr[f]+arr[e]+arr[d];
       return passwort;
    }
    else if(b==-1)
    {
       passwort=arr[m]+arr[l]+arr[k]+arr[j]+arr[i]+arr[h]+arr[g]+arr[f]+arr[e]+arr[d]+arr[c];
       return passwort;
    }
    else if(a==-1)
    {
       passwort=arr[m]+arr[l]+arr[k]+arr[j]+arr[i]+arr[h]+arr[g]+arr[f]+arr[e]+arr[d]+arr[c]+arr[b];
       return passwort;
    }
    else
    {
       passwort=arr[m]+arr[l]+arr[k]+arr[j]+arr[i]+arr[h]+arr[g]+arr[f]+arr[e]+arr[d]+arr[c]+arr[b]+arr[a];
       return passwort;
    }

das hier ist die funktion

valarray sieht so aus:

valar[0]="a";
    valar[1]="b";
    valar[2]="c";
    valar[3]="d";
    valar[4]="e";
    valar[5]="f";
    valar[6]="g";
    valar[7]="h";
    valar[8]="i";
    valar[9]="j";
    valar[10]="k";
    valar[11]="l";
    valar[12]="m";
    valar[13]="n";
    valar[14]="o";
    valar[15]="p";
    valar[16]="q";
    valar[17]="r";
    valar[18]="s";
    valar[19]="t";
    valar[20]="u";
    valar[21]="v";
    valar[22]="w";
    valar[23]="x";
    valar[24]="y";
    valar[25]="z";
    valar[26]="1";
    valar[27]="2";
    valar[28]="3";
    valar[29]="4";
    valar[30]="5";
    valar[31]="6";
    valar[32]="7";
    valar[33]="8";
    valar[34]="9";
    valar[35]="0";
    valar[36]="!";
    valar[37]="<";
    valar[38]="§";
    valar[39]="$";
    valar[40]="%";
    valar[41]="&";
    valar[42]="/";
    valar[43]="(";
    valar[44]=")";
    valar[45]="=";
    valar[46]="?";
    valar[47]="`";
    valar[48]="´";
    valar[49]="@";
    valar[50]="+";
    valar[51]="*";
    valar[52]="~";
    valar[53]="'";
    valar[54]="#";
    valar[55]="-";
    valar[56]="_";
    valar[57]=".";
    valar[58]=":";
    valar[59]=",";
    valar[60]=";";
    valar[61]="{";
    valar[62]="[";
    valar[63]="]";
    valar[64]="}";
    valar[66]="A";
    valar[67]="B";
    valar[68]="C";
    valar[69]="D";
    valar[70]="E";
    valar[71]="F";
    valar[72]="G";
    valar[73]="H";
    valar[74]="I";
    valar[75]="J";
    valar[76]="K";
    valar[77]="L";
    valar[78]="M";
    valar[79]="N";
    valar[80]="O";
    valar[81]="P";
    valar[82]="Q";
    valar[83]="R";
    valar[84]="S";
    valar[85]="T";
    valar[86]="U";
    valar[87]="V";
    valar[88]="W";
    valar[89]="X";
    valar[90]="Y";
    valar[91]="Z";

und so wird die funktion (dummerweise auf gewisse weise) aufgerufen:

int arr_len = valar.size();

    for(int a = -1;a < arr_len;a++)
    {
        for(int b = -1;b < arr_len;b++)
        {
            for(int c = -1;c < arr_len;c++)
            {
                for(int d = -1;d < arr_len;d++)
                {
                    for(int e = -1;e < arr_len;e++)
                    {
                        for(int f = -1;f < arr_len;f++)
                        {
                            for(int g = -1;g < arr_len;g++)
                            {
                                for(int h = -1;h < arr_len;h++)
                                {
                                   for(int i = -1;i < arr_len;i++)
                                    {
                                        for(int j = 0;j < arr_len;j++)
                                        {
                                            for(int k = 0;k < arr_len;k++)
                                            {
                                                for(int l = 0;l < arr_len;l++)
                                                {
                                                     for(int m = 0;m < arr_len;m++)
                                                    { 

ausgabe(a,b,c,d,e,f,g,h,i,j,k,l,m,valar);
                                                        
                                                      }

                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

das ganze funktioniert echt gut und die trefferquote ist ja auch nicht schlecht, aber ich vermute dass sich das ganze extrem optimieren lässt, ich möchte hier eig. nicht unbedingt code oder sonst was, (falls ihr welchen habt ist er natürlich dennoch erwünscht) sondern reine logische denkanstöße würden mir eig. schon reichen.

[ocz]

Bitte mehr so Threads, endlich mal was interessantes
Mal ne Frage: Ist das java code oder warum rufst du da ne size funktion auf nem Array auf (in dem Falle wäre die Langsamkeit ja erklärt)?
Ansonsten vielleicht erstma gucken was der Compiler da hinterher draus macht und auf speed optimieren lassen

Edit: der übersichtlichkeit halber kannst du die ganzen geschweiften Klammern bei den Forschleifen weglassen

[deagleD]

Die besten Hashcracker arbeiten, soweit ich weiss, mit dem GPU und nicht mit dem CPU, da dieser um einiges schneller ist.

Nur als kleiner Hinweis... zu deinem Code kann ich leider nicht viel sagen

Grüße

[Gaara]

also es handelt sich um c++^^ wieso ich ne size funktion aufrufe ist einfach zu erkläre, es handelt sich dabei um keinen normalen array sondern um nen valarray, dieser liefert solche und paar weitere funktionen.
den rest deiner aussage kann ich irgendwie nicht ganz auffassen, was der compiler hinterher draus macht?^^ und was meinst du optimieren lassen? das kann ja eig. nur ich machen oder?

als IDE benutze ich übrigends code::blocks

werd jetzt pennen gehen, also antworten sind vor 9 uhr nicht mehr zu erwarten^^ auf antworten freu ich mich natürlich.

p.s., der verständlichkeit halber:

die funktion hat schrittweise folgende ausgabe:

aaaa
baaa
caaa
.....
zaaa
abaa
bbaa
....
usw.

[fred777]

Wenn du wüsstest was der Compiler noch aus deinem Code fertigt.
Wie der Name Hochsprache schon sagt, wird dein Code erst nochmal tüchtig verändert, dann in Instruktionen übersetzt. Als Beweis kann man die smarten ASM Apps vorzeigen

[Gaara]

dass mein code verändert wird und viele compiler den code automatisch bisschen optimieren is mir bewusst, aber bei meinem problem hilft mir das nicht unbedingt weiter, da ich echt ka hab was ich noch tun soll... ich werd mir jetzt erstmal nen analyser holen und schaun wo die meiste zeit drauf geht... für weitere vorschläge bin ich dankbar.

[psyborg]

Du kannst ja die kritischen Zeilen in Assembler coden, so sparst du Zeit.

Sonst sieht der Code schon recht optimiert aus.. (bin da eh nicht so der experte)

[The-God-of-all]

Mir fällt jetzt eigentlich nur eines auf, und zwar, dass du mit Strings arbeitest. Du fügst sie immer mit + zusammen. Ich vermute mal, dass der String immer wenn du + aufrufst den kompletten String Inhalt einmal in ein neues Array kopiert weil man ja nicht einfach mal so ein Array verlängern kann. Vielleicht könntest du hier weiter optimieren indem du ein char Array mit fester Länge benutzt und das füllst. Auch sollte man mal überprüfen wie die Performance von dem valarray ist, es kann sein, dass bei einem normalen char Array (was es vermutlich genauso tun würde) die Zugriffszeiten geringer sind. Vor allem weil dann nicht mehr mit String Objekten gearbeitet würde sondern nur noch mit chars.

Du sagtest, dass das ein MD5 Cracker werden soll. Bei einem MD5 Cracker ist normalerweise die Methode für die MD5 Berechnung das kritischste, also das was am Zeit intensivsten ist. Das was du da geschrieben hast ist ja nur die Funktion um die Kombinationen durchzugehen, mehr machst du ja eigentlich gar nicht. Du musst also damit rechnen, dass wenn du die MD5 Funktion implementierst die Geschwindigkeit noch mal um einiges runtergeht (falls du sie noch nicht drinnen hast, ansonsten poste sie am besten mal).

[Gaara]

also meine oben genannte geschwindigkeit beeinhaltet das Hashing bereits, also noch langsamer würde es nicht werden, über char hab ich auch schon nachgedacht aber auch wenn sich das etwas dumm anhört... ich hab ka wie man nen char an nen char anhängt >.< weil char[0] =+ char[1] funzt in dem fall ja nicht. werd mal googlen, und wenn es jemand weis kann er es mir ja sagen.

//EDIT

kk habs, werds mit strcat machen.

[The-God-of-all]

Ein char ist immer ein buchstabe. Also kannst du an einen char keinen weiteren char anhängen. Wenn du einen String mit chars bilden willst dann musst du ein char Array nehmen. Die Funktion gibt also ein char[] zurück. Am Anfang am besten eine Variable char[16] passwort; deklarieren. Dann füllst du jeweils die zeichen mit passwort[0] = ...; passwort [1] = ...; so weiter. Wenn du alle Buchstaben drinnen hast musst du noch ein Null Byte anhängen um zu sagen, dass der String da zu ende ist (passwort[lastIndex + 1] = 0.

Und wie ich oben bereits schrieb ist denke ich auch die Funktion um den Hash zu berechnen noch sehr wichtig. Die solltest du auch nochmal hier posten oder hast du da schon eine fertig optimierte Funktion aus dem Internet verwendet? Weil du musst bedenken, diese Funktion muss für jedes Passwort aufgerufen werden --> Sie wird extrem oft ausgeführt. Da können bereits wenige Optimierungen viel ändern.