Brute_Force Algorithmus



  • Ich bin dein Vater, lowbyte.



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

    lowbyte



  • hi

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

    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



  • Hi

    Der Code wurde nun entsprechend ersetzt...

    lowbyte



  • Ich möchte halt was lehren von euch

    😕 😃



  • 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



  • waaaaas? schrieb:

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

    nichts. aber manche glauben, dass schöner code wichtiger ist, als geschwindigkeit usw.
    🙂



  • helo

    Da ich mit der Rekursiven Version nicht so zufrieden war wegen der Geschwindikeit .. schrieb ich meinen alten Code um..
    Mehr Geschwindikeit durch weniger Funktionsaufrufe ..
    Diese Version ist mit einem Thread pro breite Implem. ,doch das werde ich noch ändern.

    unsigned char chartable[]={"ABCDEFGHIJKLMNOPQRSTUVWXYZ "};
    
    int main(){
    
    ..
    ...
    
      for(f=0;(f<slen);f++) {
        ThreadH[f] = CreateThread(NULL ,0 ,&THREAD ,(LPVOID) (f+1) ,0 ,&ThreadID[f]);
      } 
    
    }
    
    DWORD WINAPI THREAD(r)
    {
    
    	BF_(r);
    	ExitThread(0);
    }
    
    int BF_(int width)
    {
    	int r[15]={0};
    	register int i ,f ,d;
    	register int p=0;
    
    	for(r[0]=0;(r[0]<stab);r[0]++) {
    	  for(r[1]=0;(r[1]<stab);r[1]++) {
    	      for(r[2]=0;(r[2]<stab);r[2]++) {
    		  for(r[3]=0;(r[3]<stab);r[3]++) {
    			for(r[4]=0;(r[4]<stab);r[4]++) {
    			  for(r[5]=0;(r[5]<stab);r[5]++) {
    				for(r[6]=0;(r[6]<stab);r[6]++) {
    				  for(r[7]=0;(r[7]<stab);r[7]++) {
    					for(r[8]=0;(r[8]<stab);r[8]++) {
    					  for(r[9]=0;(r[9]<stab);r[9]++) {
    						for(r[10]=0;(r[10]<stab);r[10]++) {
    						  for(r[11]=0;(r[11]<stab);r[11]++) {
    							for(r[12]=0;(r[12]<stab);r[12]++) {
    							  for(r[13]=0;(r[13]<stab);r[13]++) {
    								  for(r[14]=0;(r[14]<stab);r[14]++) {
    
    									for(f=0,d=14;(f<width);f++ ,d--){
    										tmpbuf[width-1][f]  =  chartable[r[d]];
    									}
    									tmpbuf[width-1][f]='\0';
    									(*HASH[modflag])(width-1);
    
    									if( ! memcmp(&hash_buf[0] ,&digesthex[width-1][0],SIZEH) ) {
    										_sleep(501);
    										TerminateThread(HStat,1);
    										printf("\n\nCracked Hash :%s - Password :%s\n\n" ,&output_hash[0] , &tmpbuf[width-1][0] );
    										for(i=0;i<15;i++) {
    											if(i!=(width-1)){
    							    				TerminateThread(ThreadH[i],0);
    											}	
    										}
    
    										return 0;
    									}
    
    									count++;
    
    								  }
    								  if(width==1)
    									return 0;
    								}
    								if(width==2)
    								  return 0;
    							  }
    							  if(width==3)
    							    return 0;
    						    }
    							if(width==4)
    							  return 0;
    					      }
    						  if(width==5)
    							return 0;
    				        }
    						if(width==6)
    						  return 0;
    			          }
    					  if(width==7)
    						return 0;
    				   }
    					if(width==8)
    					  return 0;
    				  }
    				  if(width==9)
    					return 0;
    				}
    				if(width==10)
    				  return 0;
                  }
    			  if(width==11)
    				return 0;
                }
    			if(width==12)
    			  return 0;
              }
    		  if(width==13)
    			return 0;
            }
    		if(width==14)
    		  return 0;
    	  }
    
    	return 0;
    }
    

    lowbyte


Anmelden zum Antworten