Bruteforce Algorithmus, Fortschritt nur bei Aufruf

Hi, einen Bruteforce Algorithmus kann man ja am besten rekursiv und mit einem Loop machen.

Ich möchte aber, dass der nächste String erst beim nächsten Aufruf der Funktion generiert wird, da ich ein Programm mit Threads machen möchte.

ich hatte mir das so vorgestellt:

getgenstr(){
/*code zum string generieren*/
return generated_string;
}

Thread1{
getgenstr(); /*aaaa*/
}

Thread2{
getgenstr(); /*aaab*/
}

und nicht so, oder so ähnlich.. (würde mit mehreren Threads ja nicht funktionieren..)

generatestr(){
do {
/*code zum string generieren...*/
1. aaaa
2. aaab
3. aaac
}loop(generatestr())
}

Es wäre toll, wenn ihr mir eure Ideen mitteilen könntet oder Vorschläge um diese zu verwirklichen

Sie wollen hacken ?
Ihren Ausweis bitte !

Kann mir denn keiner bei diesem Problem helfen?

Edit:
Ich möchte mir ein Programm schreiben, dass mit mehreren Threads und einem Bruteforcer-Algorithmus eine MD5 LookUpDatenbank erstellt...

Ich generiere also jede erdenkliche Kombination und errechne daraus den MD5 Hash und speicher den ab, sodass man via php ein kleines lookup script machen kann.

warum so umständlich mit threads

feigling

Dir ist aber schon klar, dass "jede erdenkliche Kombination" etwas länger dauern wird? Warum nimmst du keine Lookup Tabellen aus dem Inet? Da gibts mit Sicherheit ein paar.

wenn du keine 2 prozessoren hast, kannst du hier eigentlich auf threads pfeifen, den im endeffekt arbeiten die threads dann nicht nebeneinander sondern strenggenommen nacheinander (übrigens: theoretisch könntest du auch 100 threads verwenden und es sollte bei der richtigen implementierung trotzdem klappen), wie wenn du in einer schleife einfach alles durchprobierst. dort kannst dir dann sicher sein, dass alles genau nacheinander durchprobiert wird und es dürfte auch mehr performance bringen. und für "jede erdenkliche kombination" ist natürlich wichtig zu wissen welche zeichen vorkommen dürfen. wenn alle vorkommen können (inklusive '\0' und steuerzeichen) dürfte es glaube ich so klappen: die letzten 2 oder 3 zeichen in einen unsigned int einlesen und eins addieren. dannach wieder zurückschreiben.

Der C-Standard kennt keine Threads. Wenn du also unbedingt Threads verwenden willst, sollten wir wissen für welches System du da brauchst.

Ich möchte mit einem Freund, der PHP kann, selber ein solches Projekt mit einem MD5 Lookup Script machen..

@Tim, ich möchte CreateThread() und DWORD WINAPI ThreadFunktion() { } verwenden.

Ich hatte mir das irgendwie so vorgestellt:

char string[33];
char chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
int currentchar;
int pos;
int len;

int get_next_string() {
string[pos] = chars[currentchar];
pos++;
/*Und dann noch mit If-Abfragen alles kontrollieren*/
if(currentchar == strlen(chars)) pos --;
return 0;
}

Das ist natürlich nur ein Dummy, um zu zeigen, was ich mir vorgestellt habe..
Man müsste halt logische If-Abfragen benutzen, die dafür sorgen, dass nach dem ersten Aufruf die Variable string wie folgt aussieht: aaaa
beim zweiten: aaab
dritten: aaac
...
aaay
aaaz

aaba
aabc
aabd
...
aabz

aaca
aacb

Dann soll, wenn man bis z durch ist, der linke Character sich um eins ändern, und dann wieder der rechte bis zu z.
Dann soll der linke wieder inkrementiert werden, dann wieder der rechte bis z

bf schrieb:

Das ist natürlich nur ein Dummy, um zu zeigen, was ich mir vorgestellt habe..
Man müsste halt logische If-Abfragen benutzen, die dafür sorgen, dass nach dem ersten Aufruf die Variable string wie folgt aussieht: aaaa
beim zweiten: aaab
dritten: aaac
...
aaay
aaaz

aaba
aabc
aabd
...
aabz

aaca
aacb

Dann soll, wenn man bis z durch ist, der linke Character sich um eins ändern, und dann wieder der rechte bis zu z.
Dann soll der linke wieder inkrementiert werden, dann wieder der rechte bis z

Die Betonung liegt auf natürlich ?

int main()
{
	char abc[5] = "aaaaa";
	abc[5] = '\0';

	for ( abc[0] = 'a'; abc[0] < 'z'; abc[0]++ )
	for ( abc[1] = 'a'; abc[1] < 'z'; abc[1]++ )
	for ( abc[2] = 'a'; abc[2] < 'z'; abc[2]++ )
	for ( abc[3] = 'a'; abc[3] < 'z'; abc[3]++ )
	for ( abc[4] = 'a'; abc[4] < 'z'; abc[4]++ )
	{
		printf("%s\n", abc );
		// make_md5( abc );
	}
}

cool danke, nur leider sind da auch Schleifen drinnen.
Also läuft es stetig durch.

Der String soll aber nur weiter gehen, wenn die man funktion aufruft..

char a[5];
a = getgeneratedstring();
printf("%s", a); /*aaaaa*/
a = getgeneratedstring();
printf("%s", a); /*aaaab*/

Oje, um diese Zeit wahrscheinlich etwas quer gedacht...

#include <cstring>

bool changeString(char* string);

int main()
{
	char a[] = "aaaa";
	printf("%s", a);

	while(changeString(a))
		printf("%s", a);

	return 0;	
}

bool changeString(char* string)
{
	int length = 0; 
	if(string != NULL)
	{
		length = strlen(string);
		--length;

		while(string[length] == 'z' && length >= 0)
			length--;

		if(length >= 0)
		{
			string[length]++;
			return true;
		}
		else	
			return false;
	}
	return false;	
}

Sieht schon nett aus, danke

Aber dein Ouput lautet so:

aaab
aaac
aaad
aaae
aaaf
aaag
aaah
aaai
aaaj
aaak
aaal
aaam
aaan
aaao
aaap
aaaq
aaar
aaas
aaat
aaau
aaav
aaaw
aaax
aaay
aaaz
aabz
aacz
aadz
aaez
aafz
aagz
aahz
aaiz
aajz
aakz
aalz
aamz
aanz
aaoz
aapz
aaqz
aarz
aasz
aatz
aauz
aavz
aawz
aaxz
aayz
aazz
abzz
aczz
adzz
aezz
afzz
agzz
ahzz
aizz
ajzz
akzz
alzz
amzz
anzz
aozz
apzz
aqzz
arzz
aszz
atzz
auzz
avzz
awzz
axzz
ayzz
azzz
bzzz
czzz
dzzz
ezzz
fzzz
gzzz
hzzz
izzz
jzzz
kzzz
lzzz
mzzz
nzzz
ozzz
pzzz
qzzz
rzzz
szzz
tzzz
uzzz
vzzz
wzzz
xzzz
yzzz
zzzz

Er sollte aber so aussehen:

aaaa
aaab
aaac
aaad
aaae
aaaf
aaag
aaah
aaai
aaaj
aaak
aaal
aaam
aaan
aaao
aaap
aaaq
aaar
aaas
aaat
aaau
aaav
aaaw
aaax
aaay
aaaz
aabz
aaba
aabb
aabc
aabd
aabe
aabf
aabg
aabh
aabi
aabj
aabk
aabl
aabm
aabn
aabo
aabp
aabq
aabr
aabs
aabt
aabu
aabv
aabw
aabx
aaby
aabz
aacz
aaca
aacb
aacc
aacd
aace
aacf
aacg
aach
aaci
aacj
aack
aacl
aacm
aacn
aaco
aacp
aacq
aacr
aacs
aact
aacu
aacv
aacw
aacx
aacy
aacz
aadz
aada
aadb
aadc
aadd
aade
aadf
aadg
aadh
aadi
aadj
aadk
aadl
aadm
aadn
aado
aadp
aadq
aadr
aads
aadt
aadu
aadv
aadw
aadx
aady
aadz
aaez
aaea
aaeb
aaec
aaed
aaee
aaef
aaeg
aaeh
aaei
aaej
aaek
aael
aaem
aaen
aaeo
aaep
aaeq
aaer
aaes
aaet
aaeu
aaev
aaew
aaex
aaey
aaez
aafz
aafa
aafb
aafc
aafd
aafe
aaff
aafg
aafh
aafi
aafj
aafk
aafl
aafm
aafn
aafo
aafp
aafq
aafr
aafs
aaft
aafu
aafv
aafw
aafx
aafy
aafz
aagz
aaga
aagb
aagc
aagd
aage
aagf
aagg
aagh
aagi
aagj
aagk
aagl
aagm
aagn
aago
aagp
aagq
aagr
aags
aagt
aagu
aagv
aagw
aagx
aagy
aagz
aahz
aaha
aahb
aahc
aahd
aahe
aahf
aahg
aahh
aahi
aahj
aahk
aahl
aahm
aahn
aaho
aahp
aahq
aahr
aahs
aaht
aahu
aahv
aahw
aahx
aahy
aahz
aaiz
aaia
aaib
aaic
aaid
aaie
aaif
aaig
aaih
aaii
aaij
aaik
aail
aaim
aain
aaio
aaip
aaiq
aair
aais
aait
aaiu
aaiv
aaiw
aaix
aaiy
aaiz
aajz
aaja
aajb
aajc
aajd
aaje
aajf
aajg
aajh
aaji
aajj
aajk
aajl
aajm
aajn
aajo
aajp
aajq
aajr
aajs
aajt
aaju
aajv
aajw
aajx
aajy
aajz
aakz
aaka
aakb
aakc
aakd
aake
aakf
aakg
aakh
aaki
aakj
aakk
aakl
aakm
aakn
aako
aakp
aakq
aakr
aaks
aakt
aaku
aakv
aakw
aakx
aaky
aakz
aalz
aala
aalb
aalc
aald
aale
aalf
aalg
aalh
aali
aalj
aalk
aall
aalm
aaln
aalo
aalp
aalq
aalr
aals
aalt
aalu
aalv
aalw
aalx
aaly
aalz
aamz
aama
aamb
aamc
aamd
aame
aamf
aamg
aamh
aami
aamj
aamk
aaml
aamm
aamn
aamo
aamp
aamq
aamr
aams
aamt
aamu
aamv
aamw
aamx
aamy
aamz
aanz
aana
aanb
aanc
aand
aane
aanf
aang
aanh
aani
aanj
aank
aanl
aanm
aann
aano
aanp
aanq
aanr
aans
aant
aanu
aanv
aanw
aanx
aany
aanz
aaoz
aaoa
aaob
aaoc
aaod
aaoe
aaof
aaog
aaoh
aaoi
aaoj
aaok
aaol
aaom
aaon
aaoo
aaop
aaoq
aaor
aaos
aaot
aaou
aaov
aaow
aaox
aaoy
aaoz
aapz
aapa
aapb
aapc
aapd
aape
aapf
aapg
aaph
aapi
aapj
aapk
aapl
aapm
aapn
aapo
aapp
aapq
aapr
aaps
aapt
aapu
aapv
aapw
aapx
aapy
aapz
aaqz
aaqa
aaqb
aaqc
aaqd
aaqe
aaqf
aaqg
aaqh
aaqi
aaqj
aaqk
aaql
aaqm
aaqn
aaqo
aaqp
aaqq
aaqr
aaqs
aaqt
aaqu
aaqv
aaqw
aaqx
aaqy
aaqz
aarz
aara
aarb
aarc
aard
aare
aarf
aarg
aarh
aari
aarj
aark
aarl
aarm
aarn
aaro
aarp
aarq
aarr
aars
aart
aaru
aarv
aarw
aarx
aary
aarz
aasz
aasa
aasb
aasc
aasd
aase
aasf
aasg
aash
aasi
aasj
aask
aasl
aasm
aasn
aaso
aasp
aasq
aasr
aass
aast
aasu
aasv
aasw
aasx
aasy
aasz
aatz
aata
aatb
aatc
aatd
aate
aatf
aatg
aath
aati
aatj
aatk
aatl
aatm
aatn
aato
aatp
aatq
aatr
aats
aatt
aatu
aatv
aatw
aatx
aaty
aatz
aauz
aaua
aaub
aauc
aaud
aaue
aauf
aaug
aauh
aaui
aauj
aauk
aaul
aaum
aaun
aauo
aaup
aauq
aaur
aaus
aaut
aauu
aauv
aauw
aaux
aauy
aauz
aavz
aava
aavb
aavc
aavd
aave
aavf
aavg
aavh
aavi
aavj
aavk
aavl
aavm
aavn
aavo
aavp
aavq
aavr
aavs
aavt
aavu
aavv
aavw
aavx
aavy
aavz
aawz
aawa
aawb
aawc
aawd
aawe
aawf
aawg
aawh
aawi
aawj
aawk
aawl
aawm
aawn
aawo
aawp
aawq
aawr
aaws
aawt
aawu
aawv
aaww
aawx
aawy
aawz
aaxz
aaxa
aaxb
aaxc
aaxd
aaxe
aaxf
aaxg
aaxh
aaxi
aaxj
aaxk
aaxl
aaxm
aaxn
aaxo
aaxp
aaxq
aaxr
aaxs
aaxt
aaxu
aaxv
aaxw
aaxx
aaxy
aaxz
aayz
aaya
aayb
aayc
aayd
aaye
aayf
aayg
aayh
aayi
aayj
aayk
aayl
aaym
aayn
aayo
aayp
aayq
aayr
aays
aayt
aayu
aayv
aayw
aayx
aayy
aayz
aazz
aaza
aazb
aazc
aazd
aaze
aazf
aazg
aazh
aazi
aazj
aazk
aazl
aazm
aazn
aazo
aazp
aazq
aazr
aazs
aazt
aazu
aazv
aazw
aazx
aazy
aazz
abzz
abaz
abaa
abab
abac
abad
abae
abaf
abag
abah
abai
abaj
abak
abal
abam
aban
abao
abap
abaq
abar
abas
abat
abau
abav
abaw
abax
abay
abaz
abbz
abba
abbb
abbc
abbd
abbe
abbf
abbg
abbh
abbi
abbj
abbk
abbl
abbm
abbn
abbo
abbp
abbq
abbr
abbs
abbt
abbu
abbv
abbw
abbx
abby
abbz
abcz
abca
abcb
abcc
abcd
abce
abcf
abcg
abch
abci
abcj
abck
abcl
abcm
abcn
abco
abcp
abcq
abcr
abcs
abct
abcu
abcv
abcw
abcx
abcy
abcz
abdz
abda
abdb
abdc
abdd
abde
abdf
abdg
abdh
abdi
abdj
abdk
abdl
abdm
abdn
abdo
abdp
abdq
abdr
abds
abdt
abdu
abdv
abdw
abdx
abdy
abdz
abez
abea
abeb
abec
abed
abee
abef
abeg
abeh
abei
abej
abek
abel
abem
aben
abeo
abep
abeq
aber
abes
abet
abeu
abev
abew
abex
abey
abez
abfz
abfa
abfb
abfc
abfd
abfe
abff
abfg
abfh
abfi
abfj
abfk
abfl
abfm
abfn
abfo
abfp
abfq
abfr
abfs
abft
abfu
abfv
abfw
abfx
abfy
abfz
abgz
abga
abgb
abgc
abgd
....

pale dog

zeigerzeiger schrieb:

#include <cstring>
...

cstring

...oder so vielleicht

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

void changeString (char* string)
{
    if ((*string)++ != 'z')
        return;
    *string = 'a';
    changeString (string-1);
}

int main()
{
    char a[] = "aaaa";
    for (;;)
    {
        printf("%s\n", a);
        changeString(a+3);
    }
}

@bf Hast du das printf for der Schleife gemacht?
@pale dog: Hast recht... war auf c++ headerdateien...

Gruß
zeigerzeiger

pale dog

zeigerzeiger schrieb:

@pale dog: Hast recht... war auf c++ headerdateien...

in c++ geht sowas bestimmt mit nur einem einzigen befehl, irgendwas aus <algorithm>, boost oder so...

es ist alles gesagt.

@pale dog: Auch da gebe ich dir recht, nur hab ich ANSI C gesehen und ein Cpp Testprojekt offen gehabt und dann gemischt und außerdem war es spät und ...

@ ich finde: du hast rect

Wow, pale dog...
Ganz Genau hab ich mir den Output von deinem Code nicht angeguckt, sieht aber echt super aus!!
Ich wünschte ich könnte so schön schematisch und logisch nachdenken

Super... vielen Dank!
Danke euch allen

pale dog, könntest du mir vielleicht noch kurz sagen, wie du darauf gekommen bist?

pale dog

bf schrieb:

pale dog, könntest du mir vielleicht noch kurz sagen, wie du darauf gekommen bist?

hmmm? gute frage. das ist mir einfach so eingefallen, nachdem ich den etwas umständlichen code darüber gesehen habe.
in wirklichkeit versuche ich eigentlich immer rekursion zu vermeiden...