3 Antworten in diesem Thema

[corkscrew]

Moin,
Ich hab ein Tool gecoded, welches die Möglichkeit bietet Schlüssel aus Zahlen unterschiedlicher Länge mit unterschiedlichem Aufbau zu erzeugen. Das ganze soll dann beispielsweise Standart-WLAN-Keys in eine Wordlist schreiben.
Angefangen hab ich das ganze unter Kali, und da lief und läuft es wunderbar. Dann wollte ich das ganze nochmal unter Windows zum laufen brignen, und die Probleme gingen los.
Soweit ist alles gelöst, bis auf ein Problem:
Um die Wordlist nicht viel zu groß anzulegen werden eine Startzahl und eine Endzahl als Array erzeugt und in einen unsigned long long int geschrieben. Unter Linux funktioniert das, Windows hat scheinbar eine Rechenschwäche, die Startzahl und die Endzahl fallen immer ein ganz kleines bisschen zu klein aus -.- (weniger als 20) Das ist zwar nicht übermäßig tragisch, aber es soll ja so funktionieren, wie geplant.
Hab mich schon mit dem Debugger rumgeschlagen, aber entweder ist Windows einfach zu blöd oder ich bin es.

Hier mal der Code, so gut, wie es einem Noob möglich war dokumentiert

#include
#include
#include
#include

unsigned long long int arrayZuZahl(int, int, char[]);

char * zahlZuArray(int, int, char[]);

int kontrolle(char*, int, int);

char * zahlZuArray(int m, int d, char zahl[]) {
int i = 0;
int hilfe=0;
char arr[m];
for(i=0; i<=m; i++) {
if(i<=d) {
arr[i]='0';
}
else {
arr[i]=zahl[hilfe];
hilfe++;
}
}
strcpy(zahl, arr);
return zahl;
}

int kontrolle(char *x, int m, int n) {
//Überprüfen wie oft jede Ziffer in der aktuellen Zahl vorkommt
int null0=0, eins=0, zwei=0, drei=0, vier=0, fuenf=0, sechs=0, sieben=0, acht=0, neun=0;
int ergebnis=1;
int i=0;
for(i=0; i<=m; i++) {
switch(*(x+i)) { {
case '0':
null0++;
break;
case '1':
eins++;
break;
case '2':
zwei++;
break;
case '3':
drei++;
break;
case '4':
vier++;
break;
case '5':
fuenf++;
break;
case '6':
sechs++;
break;
case '7':
sieben++;
break;
case '8':
acht++;
break;
case '9':
neun++;
break;
}
}
//Überprüfen ob die aktuelle Zahl dem Parameter n entspricht
if(null0 > n|| eins > n || zwei > n || drei > n || vier > n || fuenf > n || sechs > n || sieben > n || acht > n || neun > n) {
ergebnis=0;
} }
return ergebnis;
}

unsigned long long int arrayZuZahl(int help, int m, char nullzahlfunkt[]) {
int o = 0;
unsigned long long int temp = 0;
for(o = 0; o <= m; o++) {
temp += (unsigned long long int) nullzahlfunkt[help]*(unsigned long long int) pow(10, (double) o);
help--;
}
return temp;
}

int main()
{
int d; //Beinhaltet die Menge der Nullen, welche vorangestellt werden müssen, um n zu erfüllen
int i; //Schleifenvariable
int m = 1; //Länge der generierten Zahl, maximal 19, Bei Veränderung Wunschlänge-1, da das Array bei [0] beginnt
int a = 0; //Wird benötigt um nullzahlarr[] und endzahlarr[] zu erzeugen
int zahl = 0; //Wird zur Erzeugung von nullzahlarr[] und endzahlarr[] benötigt
int n = 1; //Häufigkeit, mit der eine einzelne Ziffer vorkommen darf (Ziffer = 0 - 9)
unsigned long long int druckerzahl, startzahl, endzahl, differenz, e; //Variablen, die zu hochzählen der aktuellen Zahl und Ausgabe dieser genutzt werden (druckerzahl => Ausgabe)
char *p; //Pointer, mit dem die aktuelle druckerzahl als Array zu finden ist
int legal; //Beinhaltet 0 oder 1 aus der "kontrolle"-Funktion, erlaubt die Ausgabe der Zahl, wenn sie n entspricht
char datei[50]; //Array, das den Pfad zur Datei beinhaltet
int stream; //Wird benötigt, um die Datei zu schreiben (siehe Z. 160)

printf("Bitte die Anzahl der Stellen des Keys angeben (maximal 18): ");
scanf("%d", &m);

if(m > 18 || m < 1) {
printf("Die Zahl muss zwischen 1 und 18 liegen!\n");
return 0;
}

m = m-1;
printf("\nBitte die Häufigkeit angeben, mit der eine Ziffer (Zahl von 0 bis 9) vorkommen darf: ");
scanf("%d", &n);

if(n < 1 || (n*10) printf("Die Zahl muss mindestens 1 sein und groß genug, damit der Key auch gefüllt werden kann ((zahl*10)>=Stellen)!\n");
return 0;
}

printf("\nBitte das Verzeichnis und Dateinamen angeben, in dem die generierten Keys angelegt werden sollen (Format: /pfad/zur/datei.endung): ");
scanf("%s", &datei);

char nullzahlarr[m]; //Array, dass die Niedrigste mit den gegebenen Parametern (m, n) mögliche Zahl beinhaltet
char momentanZahl[m]; //Array, dass beim Hochzählen die aktuelle Zahl (druckerzahl) als Array beinhaltet und auf die Einhaltung von n überprüft wird
char endzahlarr[m]; // Array, dass die Höhste mit den gegebenen Parametern (m, n) mögliche Zahl beinhaltet

//Mit dieser for-Schleife wird die niedrigste mögliche Zahlenkombination erzeugt, welche m Stellen hat und n erfüllt
for(i = 0; i <= m; i++) {
nullzahlarr[i] = zahl;
a++;
if(a==n) {
zahl++;
a=0;
}
}

//Umdefinition von zahl und zurücksetzen von a um die höchstmögliche Zahl zu erzeugen, welche m und n entspricht
zahl=9;
a=0;

for(i=0; i<=m; i++) {
endzahlarr[i] = zahl;
a++;
if(a==n) {
zahl--;
a=0;
}
}

//Umwandlung des Arrays nullzahllarr[] zu einem 'unsigned long long int', der später zum Hochzählen benötigt wird
startzahl = arrayZuZahl(m, m, nullzahlarr);

//Umwandlung des Arrays endzahl[] zu einem 'unsigned long long int', der die Maximalgrenze der Generierung der Keys bildet
endzahl = arrayZuZahl(m, m, endzahlarr);

//Differenz der beiden Zahlen zur Regulierung, wie oft die 'Generierungs-for-Schleife' durchlaufen muss
differenz = endzahl-startzahl;

printf("%llu\n", startzahl);
printf("%llu\n", endzahl);

druckerzahl = startzahl;

stream = open(datei, O_WRONLY|O_CREAT|O_APPEND);

//'Generierungs-for-Schleife', generiert den aktuellen Key, und gibt ihn aus
for(e=0; e<=differenz; e++){
//Überprüfen, wie viele Ziffern druckerzahl enthält um die Menge an Nullen, welche vorangestellt werden müssen zu generieren
d = (druckerzahl == 0 ? 1 : (int)(log10(druckerzahl)+1));
d = m-d;

//Schreiben der druckerzahl in ein Array, welches
sprintf(momentanZahl, "%llu", druckerzahl);

//Schreiben der momentanzahl in einen int-Pointer
p = zahlZuArray(m, d, momentanZahl);

//Überprüfung, ob die Zahl ausgegeben werden darf, also n erfüllt
legal = kontrolle(p, m, n);
if(legal==1){
if(d>=0) {
//Auffüllen der ersten Stellen mit Nullen
for(i=0; i<=d; i++){
// printf("0");
}
}
//Möchte man die Zahlen sehen, welche grad geschrieben werden kann man die nächsten 2 Zeilen nutzen, dies verlangsamt das Programm jedoch enorm!
// printf("%llu", druckerzahl);
// printf("\n");

if(write(stream, momentanZahl, (sizeof(momentanZahl)+1)) == -1 || write(stream, "\r\n", 2) == -1) {
printf("Fehler beim Schreiben in die Datei\n");
return 0;

}
}
druckerzahl++;
}
close(stream);
return 0;
}

Mal sehen, ob einer was findet und woran es lag

[Cube]

Compiler?
Rennt das Tool an oder kommt ein Error/Fehlermeldung?

An deiner Stelle würd ich sowas "komplexes" bei www.coderz.cc posten.
Da geht es deutlicher zügiger voran, bei deiner Hilfestellung

Grüße

[corkscrew]

Compiler ist der von Code::Blocks, VS bietet iwie keine Kompiliermöglichkeiten an .png' class='bbc_emoticon' alt='xD' />
Läuft wunderbar, schreibt die Arrays halt nur falsch als Zahl...
Die Idee mit coderz is gut, die sind sogar mal online

[pdr0]

Kannst du vielleicht noch mal beschreiben was du genau machen willst? Willst du eine Zahlenreihe haben in der die Zahlen 1-9 bis zu 18 mal vorkommen?

z.B. 11111111122222222

Es gibt Funktionen mit denen man Buchstaben (char) in Zahlen umwandeln kann(

Please Login HERE or Register HERE to see this link!

) und umgekehrt (

Please Login HERE or Register HERE to see this link!

). Das geht auch für 64Bit Zahlen die deinen Bedarf abdecken sollten.


Ich hab mal ein paar Funktionen gekürzt. Wenn sie nicht mehr ganz stimmen, kommt hoffentlich die idee rüber :

int kontrolle(char *x)
{
  //es gibt doch nur 10 Zahlen warum keine Speicher reservieren?
  int erg[]={0,0,0,0,0,0,0,0,0,0};
  //loop über zeichenkette
  while(*x++)
  {
    //ist es eine zahl?
    if(*x<='9'&&*x>='0')
    {
	  //char-wert der Zahl als Zahl umwandeln und an der passenden Stelle inkrementieren
	  int c = (char)*x;
	  c=c-'0';
	  erg[c]+=1;
	 }
  }
  /* zum überprüfen
  int i;
  for(i=0;i<10;i++)
  printf("Zahl %d kam %d mal vorn",i,erg[i]);
  return 0;*/
}

char * zahlZuArray(int m, int d, char zahl[])
{
   //dynamische Speicheranforderung
   char *result=(char*)malloc(sizeof(char*)*m);
   //Speicher auf '0'
   memset(result,'0',m);
   //zeiger auf speicher + offset
   char *p = result+d;
   //kopieren an die addresse des Speichers von Zahl mit ( Länge von Zahl)-offset
   strncpy(p,zahl,strlen(zahl)-d);
   return result;
}

Bearbeitet von pdr0, 20 July 2014 - 15:25 Uhr.