PureBoard

Verfasst: **11.01.2008 22:46**

Hmpf,

wahrscheinlich war der Tag einfach zu lange, aber ich habe gerade Probleme die Anzahl an Möglichkeiten für eine Brute-Force-Attacke zu berechnen. Hintergrund ist, dass ich gerne eine Rainbow-Tabelle erstellen würde. Diese Tabelle enthält Strings, die exakt 6 Zeichen lang sind und sich aus Zahlen sowie Großbuchstaben in beliebiger Kombination (sprich mehrfaches Vorkommen eines Zeichens pro String ist möglich) zusammensetzt. Oder anders erklärt:

Code: Alles auswählen

A3G5NN

Ich würde nun gerne wissen, wieviele Möglichkeiten es gibt. Ich hab mir das gerade über Falkutäten irgendwie zusammengerechnet und komme auf 36.582.584.325 Möglichkeiten. Stimmt das? Kommt mir so wenig vor...

Danke für Erleuchtungen

P.S.:
Angabe des Rechenwegs wäre cool, falls ich falsch liegen sollte (und das tue ich bestimmt)

Verfasst: **11.01.2008 22:53**

da mehrvachforkommen erlaubt sind ist Falkutäten hier nicht richtig, sondern:

Zeichenmenge^Stellen

also du du da 26+10 Zeichen hast (ABC...123..) sind das
36^6 = 2.176.782.336

Verfasst: **11.01.2008 23:31**

Echt? Nur so wenig? Krass

Ich dachte ehrlich, es wäre mehr. Angenommen, ich würde pro String 7 Byte zum speichern benötigen, dann wäre die Rainbow-Tabelle rund 14,5 Gigabyte groß - stimmt das? DAS wäre heftig...

*gleichinsbettgeht*

Verfasst: **11.01.2008 23:44**

wieso willst du die denn alle Speichern ?

Erzeuge sie doch lieber dann wenn du sie brauchst in echtzeit
Oder hast du Zeitdruck ^^

Verfasst: **12.01.2008 12:22**

Aaah, ausgeschlafen

Also Zeit ist bei meinem Vorhaben eher relativ. Der Schlüssel, den ich bruteforcen möchte, sieht etwa so aus:

Code: Alles auswählen

123456-123456-123456-ABC123-ABC123

Die drei Zahlenblöcke, die am Anfang stehen, sollten einen festen Wert haben. Die setzen sich aus bestimmten Kriterien zusammen. Sorgen machen mir halt nur die letzten beiden Blöcke, da ich IMHO 200 Gigabyte Daten an die Schnittstelle schicken müsste, um mindestens einen Treffer zu bekommen. Puh, das wird interessant. Naja, ich muss mal schauen, wieviele Schlüssel ich pro Minute erstellen kann und vor allem, ob ich die Schnittstelle direkt mit PB ansprechen kann. Normalerweise geht's nur per Scriptsprache, daher die Rainbow-Tabelle...

Verfasst: **12.01.2008 14:19**

Vllt lohnt ein Blick hinter diesem Link: http://www.1pw.de/brute-force.html

Verfasst: **12.01.2008 15:48**

Danke für die Info

Also ich muss das Script mit PHP schreiben. Mit PureBasic kann ich leider nicht auf die Resourcen zugreifen. Naja, ich hab mal ein kleines Test-Script geschrieben:

Code: Alles auswählen

<?php
$block_d_output   = '000000';

$block_d_possible = array( '0'
                         , '1'
                         , '2'
                         , '3'
                         , '4'
                         , '5'
                         , '6'
                         , '7'
                         , '8'
                         , '9'
                         , 'A'
                         , 'B'
                         , 'C'
                         , 'D'
                         , 'E'
                         , 'F'
                         , 'G'
                         , 'H'
                         , 'I'
                         , 'J'
                         , 'K'
                         , 'L'
                         , 'M'
                         , 'N'
                         , 'O'
                         , 'P'
                         , 'Q'
                         , 'R'
                         , 'S'
                         , 'T'
                         , 'U'
                         , 'V'
                         , 'W'
                         , 'X'
                         , 'Y'
                         , 'Z'
                         );

$timestamp = time();
$count = 0;

// Block D Sign A
for($block_d_sign_a = 0; $block_d_sign_a < count($block_d_possible); $block_d_sign_a++) {
    $block_d_output{0} = $block_d_possible[$block_d_sign_a];
    // Block D Sign B
    for($block_d_sign_b = 0; $block_d_sign_b < count($block_d_possible); $block_d_sign_b++) {
        $block_d_output{1} = $block_d_possible[$block_d_sign_b];
        // Block D Sign C
        for($block_d_sign_c = 0; $block_d_sign_c < count($block_d_possible); $block_d_sign_c++) {
            $block_d_output{2} = $block_d_possible[$block_d_sign_c];
            // Block D Sign D
            for($block_d_sign_d = 0; $block_d_sign_d < count($block_d_possible); $block_d_sign_d++) {
                $block_d_output{3} = $block_d_possible[$block_d_sign_d];
                // Block D Sign E
                for($block_d_sign_e = 0; $block_d_sign_e < count($block_d_possible); $block_d_sign_e++) {
                    $block_d_output{4} = $block_d_possible[$block_d_sign_e];
                    // Block D Sign F
                    for($block_d_sign_f = 0; $block_d_sign_f < count($block_d_possible); $block_d_sign_f++) {
                        $block_d_output{5} = $block_d_possible[$block_d_sign_f];
                        // Counter
                        if(time() - $timestamp >= 60) {
                            echo $count;
                            exit;
                        }
                        $count++;
                    }
                }
            }
        }
    }
}
?>

Ist sehr simpel gehalten und "berechnet" (eher erzeugt) nur einen 6er-Block mit Zahlen und Großbuchstaben gemischt. Ich hab es 60 Sekunden laufen lassen (AMD X2 5200 @ 2,6GHz - PHP-CGI auf einem Kern). In dieser Zeit erzeugt es nur 47.731.065 verschiedene Kombinationen. Das sind rund 795.517 pro Sekunden. An die 30 Millionen pro Sekunde komme ich mit PHP wohl nicht ran. Dennoch würde es nur 45 Minuten dauern, die 2 Milliarden Kombinationsmöglichkeiten durchzugehen. Für beide Blöcke bräuchte ich aber schon 33 Stunden. Hm, ist das bescheiden. Wenn ich 30 Millionen Schlüssel pro Sekunde erzeugen könnte, würde ich die 2 Milliarden Kombinationen in etwas mehr wie einer Minute durchgehen können. Und die beiden Blöcke hätte ich einer Stunde durch... *grübel*

Verfasst: **12.01.2008 15:56**

zu deinem denkfehler von gestern abend:
> Angenommen, ich würde pro String 7 Byte zum speichern benötigen
ein byte hat 256 möglichkeiten, deine stellen nur 36.
natürlich nimmst du ein byte zum speichern, aber du brauchst nicht alle 256 variationen jeder stelle.

zu deinem zeitproblem:
ich würde beide felder parallel angreifen, über getrennte ports - falls das ginge...

Verfasst: **12.01.2008 16:10**

Ne, geht nicht. Das ist ein Schlüssel, der komplett übergeben wird. Ich hab grad mal etwas weiter gerechnet: Wenn man davon ausgeht, dass die ersten 3 Blöcke nicht feststehend wären und man diese auch "hochzählt", ergeben sich mit den letzten beiden Blöcken 5.738.378.338.324.616.895 verschiedene Kombinationsmöglichkeiten - wenn ich mich nicht verrechnet habe. Bis man einen gültigen Schlüssel hat, würden bis zu 60.000 Jahre vergehen. Vorausgesetzt man erzeugt 30 Millionen Schlüssel pro Sekunden. Ich glaube, ich kann das getrost vergessen. Was mich allerdings interessieren würde, wieviele Schlüssel man mit ASM erzeugen könnte. Ist jemand so fit (und hat Lust) so ein ASM-Code für PB zu schreiben, der das Gleiche macht wie der PHP-Script oben? Wäre cool

Verfasst: **12.01.2008 17:58**

Wieso sieht dein Schlüssel verdächtig aus wie eine Seriennummer? LOL

PureBoard

Brute-Force: Möglichkeiten berechnen

Brute-Force: Möglichkeiten berechnen