Brute_Force Algorithmus

lowbyte schrieb:

Ach ja sorry mit euch reden bringt ja nix.

bleib locker. volkard ist machmal ein kleiner spassvogel. das hat er bestimmt nicht böse gemeint.

volkard

lowbyte schrieb:

Und ja so gut bin ich auch wider um zu verstehen das er nur schwachsinn meint.
Pro Buchstaben ein Thread.. ja genau das werde ich machen ..
Verstehe einfach nicht warum man nicht normal disqutieren kann.
Ich Programmiere vieleicht 1-2 Jahre C... aber egal.

ähm.
für aaaaaaaa bis azzzzzzz ein thread, für baaaaaaa bis bzzzzzz noch einer und so weiter. sind die das jetzt zu viele oder zu wenige threads?

Hallo lowbyte!

Ich habe dein Problem nachvollzogen und bin zu dem Ergebnis gekommen, dass

du scheiße bist.

volkard

und die ganzen schleifen, da dachte ich eher an sowas wie

char chartable[]={"ABCDEFGHIJKLMNOPQRSTUVWXYZ "};

//dieser code ersetzt ungefähr 1000 zeilen
void PN(char* out,char* pw,char* chartable,int plen,int left)
{
	int r;
	for(r=0;r<plen;++r){
		*pw=chartable[r];
		*(pw+1)='\0';
		if(left==0)
			printf("%s\n",out);
		else
			PN(out,pw+1,chartable,plen,left-1);
	}
}

int main()
{
	char pw[9];
	PN(pw,pw,chartable,sizeof(chartable),8);

wenn du dein programm erstmal vereinfacht hast, kannste dir so richtig gut ausdenken, wo du die spaltung in threads einbauen willst. zum beispiel

if(left==0)
			printf("%s\n",out);
		else if(left==6)
			threadPN(out,pw+1,chartable,plen,left-1);
		else
			PN(out,pw+1,chartable,plen,left-1);

startet für blöcke zu buchstabenanzahl hoch 6 einen thread. statt gleich zu starten, kannste jobs in eine warteschlange stopfen und thread pooling machen. da ist vieles möglich, aber zuerst mach alles hübscher.

lowbyte

hi problemscheisser

Wer bist du schon,um sagen zu können das ich scheisse bin.

lowbyte

Ich bin dein Vater, lowbyte.

lowbyte

ja ja ja... ich weis schon wer du bist.. nicht zu spät kommen morgen !!!!

lowbyte

lowbyte

hi

Ich komme von der sprache java ..also bitte ein bischen verständniss ..

lowbyte

lowbyte

hallo

Da ich noch nicht so geschickt bin in C kommt halt manchmal sehr langer code hinaus..
Ich möchte halt was lehren von euch, und nicht so minderwertige kommentare hören.
Der einzige war wider mal Volkard, er konnte mir wenigstens eine Lösung zeigen.
Wusste ja selber das der Code zu aufgeblät ist.Aber wusste einfach nicht wie ich dies bewerkstelligen konnte.Und so scheisse wie es da einer gesagt hat ist es auch nicht.Ist halt nur viel zu viel Code !Da es doch kürzer auch geht.Ich werde ihn daher umschreiben und dem Lösungsansatz von Volk. folgen..
Ich hoffe ich kann wenigstens mit dir(VOLKARD) auf einem anständigen Level schreiben. Da ich wie gesagt etwas Lehrnen möchte.

lowbyte

lowbyte

Hi

Der Code wurde nun entsprechend ersetzt...

lowbyte

Ich möchte halt was lehren von euch

volkard

lowbyte schrieb:

Meine Frage ist nun, würde sich eine Runde auf zwei Threads verteilt lohnen, abgesehen von dem Synchronisierungs aufwand (Semaphor).?

ja, auf jeden fall.
ich habe mit einem dualcore mit hyperthreading, was irgendwie vier parallele threads macht, ein wenig gemwessen. gemessen habe ich, wie schnell ein projekt durchcompiliert wird.
da waren zwei prozesse einfach doppelt so schnell wie einer. der dritte hat noch ein wenig speed gebracht. und der vierte auch. der fünfte hat noch ein ganz klein bißchen gebracht und der sechste auch. wohl, um eingabedelays abzufangen. weitere threads bis 50 brachten keine direkte änderung, aber eine leichte tendenz abwärts.

Hi

Problemmudda kannst du dich ncht mal beim namen nennen ?
Vieleicht solltest du halt einfach erwachsen werden.

Volkard danke für dein stat. werde mich mal dahintersetzen ,abends.

thx
lowbyte

Helo Volkard

Das war dein Code.

int main()
{
BFP(pw,pw,chartable,strlen(chartable),8);

...
}

int BFP(char* out,char* pw,char* chartable,int plen,int left)
{
int r;
for(r=0;r<plen;++r){
*pw=chartable[r];
*(pw+1)='\0';
if(left==0) {

(*HASH[modflag])();
count++;

if( ! memcmp(&hash_buf[0] ,&digesthex[0] ,SIZEH) ) {
_sleep(1000);
TerminateThread(HStat,1);
printf("\n\nCracked Hash :%s - Password :%s\n\n" ,&output_hash[0] , &out[0] );
getchar();
return 0;
}

} else {
BFP(out,pw+1,chartable,plen,left-1);
}
}

}

meine Zeilen unterscheiden sich zu deinen nur in 2 Sachen. Ich übergebe der Funktion beim aufruf nur die String-länge ohne wie bei dir mit \0 Terminierung. Dadurch erreiche ich ja das ich nur auf die breite berechne. Und sommit in einer forschleife jede breite einzeln aufrufen muss, um alle kombinationen zu erreichen.
Habe ein bisschen rumprobiert, und festgestellt das meine implement. um 30% schneller ist. Das liegt aber sicher daran das deine Idee
mit einem einzigen aufruf ,nach 10 outputs ein bad char erzeugt..und sommit mehr Zeichen als nötig erzeugt.zbp. breite 2 wären 110 combinationen.Doch bei dir ergibts 121.?
Doch ich bleibe bei meiner funktion. Eine Funktionsaufruf pro Breite .. da ich ja sowiso mit threads Arbeite will.
Und so siehts aus:

int main(){

   for(f=1;(f<=slen);f++) {
       BFP(pw,pw,chartable,strlen(chartable),f-1);
   }
..
..
}

int BFP(char* out,char* pw,char* chartable,int plen,int left)
{
    int r;
	int var=0;
    for(r=0;r<plen;r++){
        *pw=chartable[r];
        *(pw+1)='\0';
		if(left==0) {

			(*HASH[modflag])();
			count++;

			if( ! memcmp(&hash_buf[0] ,&digesthex[0] ,SIZEH) ) {
				_sleep(1000);
				TerminateThread(HStat,1);
				printf("\n\nCracked Hash :%s - Password :%s\n\n" ,&output_hash[0] , &out[0] );
				getchar();
				return 0;
			}

			} else {
		        BFP(out,pw+1,chartable,plen,left-1);
			}
    }

}

Jetz werde ich mal eine Version mit Threads erarbeiten.. und dan mal Posten ..dan bist du gefragt Volkard feinschliff oder ergänzung.

lowbyte

helo Volkard

Der aufruf bei deiner funktion war natürlich sizeof(chartable) und nicht strlen(chartable), so wie ich geschrieben habe.
Dass machts ja aus !...

lowbyte

lowbyte_ schrieb:

meine Zeilen unterscheiden sich zu deinen nur ...
for(f=1;(f<=slen);f++) { 
       BFP(pw,pw,chartable,strlen(chartable),f-1); 
   }

supi. mein code war nur als skizze gedacht, um dich in die richtung rekursion zu lenken. und klar mußt du mit so einer schliefe in die tiefe gehen, damit du zuerst die kurzen und später erst die langen machst.

lowbyte_ schrieb:

Jetz werde ich mal eine Version mit Threads erarbeiten.. und dan mal Posten ..dan bist du gefragt Volkard feinschliff oder ergänzung.

feinschliff werd ich kaum machen. ich konnte nur nicht widerstehen, weil dein code echt scheiße war.

volkard@work schrieb:

...um dich in die richtung rekursion zu lenken.

http://stanford.edu/~blp/writings/clc/recursion-vs-iteration.html

helo vol.

Ja das ist mir auch klar..obwol mein alter code. 100000 chars pro sek. Schneller war.. Denke das ist wegen den stack frames die immer erzeugt werden müssen für die var.s und rücksprung adresse.etc. Oder lieg ich da falsch?
Aber klar das es so wie jetz 100 x besser ist.

Lowbyte

für diesen zweck ist doch wohl eher die schnellere methode die bessere. was spricht denn gegen 15 bis 30 for-schleifen?

Also ich meinte natürlich bei meinem alten code mit 15 for schleifen.. der war schneller...Bei einer rekursiven Implementierung muss bei jedem Funktions aufruf immer der Stackframe erzeugt.. + alles gepusht werden..nach meinem wissen.

lowbyte