Dic Generator anhand von Wörtern

S

sonz

0
Hallo Leute,
ich habe folgendes Problem :
Ich habe ein altes Jetico Bestcrypt-File auf einem Wechselmedium gefunden.
Natürlich kann ich mich nicht mehr an mein Passwort erinnert, ABER ich verwende normalerweise immer eine Kombination aus verschiedenen Wörtern!
Ich möchte also nun ein Dictionary erzeugen, was alle Wörter untereinander Kombiniert.

Beispiel : dic.txt

Haus
Katze
Peter

Wird zu : dic_gen.txt

Haus
HausKatze
HausKatzePeter
KatzeHaus
KatzeHausPeter
PeterHaus
PeterHausKatze
PeterKatzeHaus

etc etc....


Das dürfte dann das Bruteforcen doch etwas erleichtern ;)

Kennt jemand so ein Programm ?

Mfg

SonZ

PS: Nein,ich habe keine Hauskatze namens Peter ;)
 
Jo Hi,

ein Programm das diese Problem löst könnte man coden. ;)
Du müsstes die Sache nur ein wenig einschränken sonst geht die Anzahl der möglichen Kombinationen sehr schnell ins Uferlose.

Hierzu ein kleines Beispiel:

Wenn du in dic.txt "nur" 100 Wörter vorgibst und wir davon ausgehen das Du maximal 5 Wörter miteinander kombiniert hast müssten daraus alle 1er,2er,3er,4er und 5er Kombinationen gebildet werden.

Für alle Kombinationen ohne Wiederholung und ohne Berücksichtigung der Anordnung ~also PeterHausKatze == HausKatzePeter usw. und sowas wie HausHausPeter ausgeschlossen~ ergibt sich folgendes:

100 x 1 Wort
4.950 Kombinationen aus 2 Wörtern
161.700 Kombinationen aus 3 Wörtern
3.921.225 Kombinationen aus 4 Wörtern
75.287.520 Kombinationen aus 5 Wörtern

In der so generierten Datei dic_gen.txt würden dann 79.375.495 generierte Wortkombinationen stehen.
Bei einer angenommenen Wortlänge von 5 Zeichen + CR/LF(nach Wortende) hätte die generierte Datei jetzt schon die beachtliche Göße von:
100*7+4950*12+161700*17+3921225*22+75287520*27 = 2.121.838.990 Byte!
Das sind fasst 2 GigaByte!! :rolleyes:

Hier wären wir jedoch noch lange nicht fertig nun kommen noch alle möglichen Anordnungen der Wörtergruppen hinzu ~weil ja eben HausPeterKatze was anderes als PeterHausKatze ist~, also:

Die 4.950 2er Gruppen können auf 2 Weisen geordnet sein, macht 9900 Kombinationen.
Die 161.700 3er Gruppen können auf 6 Weisen geordnet sein = 970.200 Kombinationen.
Die 3.921.225 4er Gruppen können auf 24 Weisen geordnet sein = 94.109.400 Kombinationen.
Und die 75.287.520 5er Gruppen können auf 120 Weisen geordnet sein = 9.034.502.400 Kombinationen.

Wie Du nun leicht nachvollziehen kannst würde die dic_gen.txt Datei jetzt ein kleinwenig größer sein, knapp 230 GigaByte!! ;)

Hoffe ick hab mich niX verrechnet.
MfG
WeesNix
 
Hallo,
ich suche auch so ein Programm da ich die Reihenfolge eines älteren Passwortes vergessen habe.

Die Wörter weiss ich noch sind 8 bis 10 Wörter die in einer zufälligen Reihenfolge zusammengeschrieben wurden.

Gibt es eine Möglichkeit wie ich eine Wortliste daraus automatisch generieren lassen kann?

Währe sehr froh über jede Hilfe oder Tipps.
 
Prolog:
Code: 
make_dic(InFile,OutFile):-processfile(InFile,Words),
              open(OutFile,write,Stream),
              forall(permutate(Words,[],Result),(output(Result,Stream,[]),nl(Stream))),
              close(Stream).
              
output([],Stream,Line):- atom_codes(String,Line),write(Stream,String).
output([[Word]|Words],Stream,Line):- output(Words,Stream,[Word|Line]).


permutate([],Combos,Combos).
permutate([_],Combos,Combos).
permutate([_,_],Combos,Combos).
permutate(Words,Acc,Result):-
        select(Word,Words,Tail),permutate(Tail,[Word|Acc],Result).

processfile(File,Words):-
        open(File,read,Stream), 
        reader(Stream,Words),close(Stream).

reader(Stream,[]):-peek_char(Stream,end_of_file).
reader(Stream,[Word|Words]):-read_line_to_codes(Stream,Word),
                             reader(Stream,Words),!.
läuft in SWI Prolog.
Code: 
:-use_module(library(lists)).
:-use_module(library(aggregate)).

make_dic(InFile,OutFile):-processfile(InFile,Words),
              open(OutFile,write,Stream),
              forall(permutate(Words,[],Result),(output(Result,Stream,[]),nl(Stream))),
              close(Stream).
              
output([],Stream,Line):- atom_codes(String,Line),write(Stream,String).
output([[Word]|Words],Stream,Line):- output(Words,Stream,[Word|Line]).

permutate([],Combos,Combos).
permutate([_],Combos,Combos).
permutate([_,_],Combos,Combos).
permutate(Words,Acc,Result):-
        select(Word,Words,Tail),permutate(Tail,[Word|Acc],Result).

processfile(File,Words):-
        open(File,read,Stream), 
        reader(Stream,Chars),close(Stream),
        get_words(Chars,Words).

reader(Stream,[]):-peek_char(Stream,end_of_file),!.
reader(Stream,[Char|Chars]):- get_char(Stream,Char),reader(Stream,Chars).

get_words([],[]).
get_words([Char|Chars],[[]|Words]):-Char=='\n',get_words(Chars,Words).
get_words([Char|Chars],[[Char|Wordchars]|Words]):-
        Char\=='\n',get_words(Chars,[Wordchars|Words]),!.


Hab mal eine Binary beigelegt (SWI).
Benutzung:
Zuerst erstellt man eine Liste mit Wörtern:
hallo
ich
bin
ein
Wort
Zum Vergrößern anklicken....
Wichtig: nicht mehr als ein Zeilenumbruch am Ende, keine Leerzeichen nach den Wörtern (es sei denn, diese sind in der Kombination gewünscht ;) ).

Dann startet man die Dict.exe
Es sollte sich eine Prologkonsole öffnen.
Da gibst man ein:
make_dic(Infile,Outfile).
Infile=Eingabe;Datei mit Deinen Wörtern
Outfile=Ausgabe;generiertes Wörterbuch
Bsp:
make_dic('test.txt','out.txt').
Zum Vergrößern anklicken....
(ja, mit . (Punkt) am Ende ;) )
Sofern alles korrekt war, kommt ein "true" bzw die Generierung wird angestossen.
Wenn man selber Prolog auf seinem System installiert hat:
consult('dictbruteforce.pl').
make_dic(Infile,Outfile).

Es werden aus N Wörtern alle Kombinationen der Länge N,N-1,N-2 generiert (da Du geschrieben hast 8-10). Also bei 10 Wörtern werden alle Kombinationen
aus allen 10 Wörtern gemacht + alle Kombinationen mit 9 (aus allen 10) + mit 8 aus 10. D.h er generiert für 10 Wörter 10*9*8*6...*1+10*9*8..*2+10*9*8*7*...*3 =10!*2+10!/2=9072000 Kombinationen. Wenn Dein Bruteforcetool 100 Passwörter pro Sekunde ausprobiert, dauert es "nur" 25 Stunden :)

hab mal testweise von 0-9 als Wörter genommen:
ergibt eine 96MB Dictionary, dauert ca 2 Minuten.
Bei richtigen Wörtern würde ich das Endfile auf 500+ MB schätzen.

http://www.hackerboard.de/attachment.php?attachmentid=3627
 
Super danke werde es gleich mal probieren :)

Habe es gerade ausprobiert sobald ich Wörter in das test.txt schreibe bekomme ich ein fail.
Mit Zahlen geht es aber nicht mit Wörtern.
 
Sorry, *hatte nämlich noch auf den letzen drücker die Writefunktion optimiert, damits schneller ging*
Code: 
make_dic(InFile,OutFile):-processfile(InFile,Words),
              open(OutFile,write,Stream),
              forall(permutate(Words,[],Result),(output(Result,Stream),nl(Stream))),
              close(Stream).
output([],_).
output([Word|Words],Stream):- atom_chars(String,Word),write(Stream,String),
                              output(Words,Stream).
permutate([],Combos,Combos).
permutate([_],Combos,Combos).
permutate([_,_],Combos,Combos).
permutate(Words,Acc,Result):-
        select(Word,Words,Tail),permutate(Tail,[Word|Acc],Result).

processfile(File,Words):-
        open(File,read,Stream), 
        reader(Stream,Words),close(Stream).

reader(Stream,[]):-peek_char(Stream,end_of_file).
reader(Stream,[Word|Words]):-read_line_to_codes(Stream,Word),
                             reader(Stream,Words),!.

Zum Speed:
Auf meinem Rechner werden jeden jedenfalls ca ~1 MB pro Sekunde "generiert". Testlauf mit
hello
dubist
ichbin
ersiehtsie
nixverstehen
nein nun
nur er
nicht wir
nocheinwort
riesenwort oder
Zum Vergrößern anklicken....
dauerte jedenfalls 8 Minuten und erzeugte eine 800 MB Datei
 
Um antworten zu können musst du eingeloggt sein.
Zurück
Oben