[S]BruteForce Pseudocode

[snify]

Hey,
ich versuche einen BruteForcer zu coden,
allerdings komme ich nicht weit ^^
hier mal mein Anfang:

(keine definierte Programmiersprache)

array kleinbuchstabe [25]
kleinbuschtstabe [0] = 'a'
...
usw...

jetzt kann ich den Index mit ner Variable voll knallen und dann von 0 bis 25 zählen lassen. Allerdings weiß ich nicht wie ich dann weiter machen muss?
Es geht ja weiter mit:
ab
ac
ad
ae
usw...
danach:
ba
bb
bc
bd
usw...


Muss ich dort Zählerschleifen verschachteln? Wenn ja, wie oft?
Hoffe, mir kann jemand helfen

[blackberry]

Sorry für die späte Antwort, aber ich habe diesen Thread erst jetzt gesehen.
Tatsächlich ist es möglich eine solche Folge von Wörtern zu berechnen.
Als Grundlage habe ich eine kleine Funktion zum Umwandeln eines Integers in einen String (der diesen Integer-Wert im Hexadezimalsystem darstellt) verwendet (daher auch die Variablennamen in dem folgenden Code), die ich in einer ähnlichen Form schonmal irgendwann gepostet habe!

Das Prinzip ist das folgende: (mathematische Grundlage(n): http://de.wikipedia.org/wiki/Hexadez...adezimalzahlen http://de.wikipedia.org/wiki/Division_mit_Rest )
Bezogen auf das Umrechnungsbeispiel von Wikipedia:
Die Zahl X wird durch 16 geteilt.
Der Ganzzahlquotienz der Operation wird X zugewiesen.
Der Rest repräsentiert ein Zeichen der Hexadezimalzahl.
Das wird so weitergeführt, bis der Ganzzahlquotient 0 ist.

Ok, das kennen wir bereits aus dem Matheunterricht, jetzt kommt der Trick;
Das Hexadezimalsystem besitzt 16 verschiedene Zeichen: 0, 1, 2, 3, ..., A, B, C, D, E, F.
Was für Zeichen hat das Siebzehnersystem? Alle Zeichen des Hexadezimalsystems + G.
Und das Achtzehnersystem? ...

Wir fassen zusammen:
Beim Hexadezimalsystem werden bis zu (zB.) 0xFFFF alle möglichen Kombinationen verwendet, die mit 0, 1, 2, 3, ..., A, B, C, D, E und F mit 1- bis 4-Stellen langen Zeichenketten formbar sind.

Um eine Zahl auf dem Z.-Zahlensystem für eine gegebene Zahl X zu berechnen geht man wie folgt vor:
Die Zahl X wird durch Z geteilt.
Der Ganzzahlquotienz der Operation wird X zugewiesen.
Der Rest repräsentiert ein Zeichen der Z.-Zahlensystemzahl.
Das wird so weitergeführt, bis der Ganzzahlquotient 0 ist.
Z steht hier für die Anzahl an Zeichen des Systems (Dezimalsystem: Z = 10, Oktalsystem: Z = 8, Hexadezimalsystem: Z = 16, Dualsystem: Z = 2, 315-System: Z = 315, usw.)

Schau dir mal folgenden Code an:

char *decimal2combination(unsigned int dec)
{
    static const char table[] = "0123456789ABCDEF";
    static char *hex = (char *) malloc(BUFSZ + 1);
    
    memset(hex, 0, BUFSZ + 1);
    while(dec)
    {
        memmove(hex + 1, hex, BUFSZ);
        *hex = table[dec % (sizeof(table) - 1)];
        dec /= sizeof(table) - 1;
    }
    return hex;
}

Dieser Code ist die C-Implementation der oben aufgeführten Verarbeitungsvorschrift für das Hexadezimalsystem.
Wie du siehst wird der Divisor, also 16 im Fall des Hexadezimalsystems, anhand der Anzahl an für das Zahlensystem verfügbaren Zeichen bestimmt (strlen(table) - 1 wegen des NULL-Zeichens am Stringende).
Das heißt, dass wir das System, in das wir umrechnen wollen, direkt durch Veränderung des table-Strings beeinflussen können.
Setzen wir für Table also folgenden char-Array ein:
"0123456789ABCDEFG"
so erfolgt eine Umrechnung in das Siebzehner-Zahlensystem!

Was ist wenn wir nun in das 62-Zahlensystem umrechnen wollen?
Kein Problem! Wir setzen einfach eigene Zeichen ein.
In diesem Fall benutze ich 0-9, A-Z und a-z.
static const char table[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklm nopqrstuvwxyz";

Und viola; schon kannst du durchzählen:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define BUFSZ 32


char *decimal2combination(unsigned int dec)
{
    static const char table[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
    static char *hex = (char *) malloc(BUFSZ + 1);
    
    memset(hex, 0, BUFSZ + 1);
    while(dec)
    {
        memmove(hex + 1, hex, BUFSZ);
        *hex = table[dec % (sizeof(table) - 1)];
        dec /= sizeof(table) - 1;
    }
    return hex;
}

int main(void)
{
    unsigned int i;
    
    for(i = 0; i < 1000; i++)
    {
        puts(decimal2combination(i));
    }
    
    getc(stdin);
    return 0;
}

Jetzt werden dir die ersten 1000 Kombinationen berechnet!

PS: Da der Maximale Wert für einen unsigned int 0xFFFFFFFF beträgt, ist der Maximalwert dieser String: 4gfFC3.
Um dieses Verfahren praktisch nutzen zu können musst du also mit unsigned long long int's arbeiten, oder gleich mit einem char-Array und dein Hochzählen in Bit-Schritten vornehmen - aber soweit zur Theorie, das war ja nur mehr so in die Richtung Proof-Of-Concept.


Ich hoffe ich habe mich verständlich ausgedrückt und konnte dir helfen
mfG. BlackBerry

[snify]

hey,
sorry, hab erst jetzt deine Antwort gelesen.
Vielen Dank für deine Mühe. Wie gut, dass ich C / C++ kann xDD
Die Variante ist zwar etwas umständlich (habs mir einfacher vorgestellt) aber es funktioniert. Vielen Dank
Jetzt muss ich es zum testen nur noch ausgeben lassen

Gruß

[blackberry]

Die Variante mit unsigned long long int erreicht Passwörter bis zu 11 Buchstaben mit der oben aufgeführten 62-Zeichen Kombination.
Wenn du also höher gehen willst, musst du die Zeichenzahl einschrenken, oder die Zahlen selbst berechnen (dh. eigene Funktionen zum Rechnen mit Variablen > 64 Bit schreiben) - was das ganze noch mal eine Spur umständlicher macht
Viel Erfolg!


mfG. BlackBerry