Alle Kombinationen

[Stefan A. (ripper121)]

wie bekomme ich alle Kombinationen von
0x00, 0x00, 0x00, 0x00, 0x00, 0x00 bis 0xff,0xff,0xff,0xff,0xff,0xff ?

so funktioniert es leider nicht:

uchar default[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
  for(int KeyA=0; KeyA < 16; KeyA++)
  {
    for(int CodeA=0; CodeA < 256; CodeA++)
    {
     default[KeyA]=CodeA;
    }
  }

[ich (Gast)]

Warum einmal bis 16 und einmal bis 256?
Für alle Kombinationen: beide Schleifen von 0..bis 255

Vergleich mit 256 wird auch nicht funktionieren (255 ist die größe 
8bit-Zahl).

[Stefan A. (ripper121)]

Sorry meinte so aber kommen trotzdem nicht alle Kombinationen raus
hier zählt er ja nur hoch :(

uchar default[5] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
  for(int KeyA=0; KeyA < 6; KeyA++)
  {
    for(int CodeA=0; CodeA < 255; CodeA++)
    {
     default[KeyA]=CodeA;
    }
  }

[radiostar (Gast)]

Du brauchst 6 ineinander veschachtelte Schleifen, jede kümmert sich um 
ein anderes Element im Array, alle schleifen laufen von 0..255. Aber Du 
möchtest so ein Programm nicht wirklich laufen lassen ;-)

Versuch's mal mit kleineren Werten, z.B. alle Kombinationen von 0, 0, 0, 
0 bis 4, 4, 4, 4 - dann kommt das Programm auch zu einem Ende.

[Stefan A. (ripper121)]

doch will ich ;) hast du das als code?

[Karl H. (kbuchegg)]

  for
  {
    default[0] = 
    for
    {
      default[1] = 
      for
      {
        default[2] = 
        for
        {
          default[3] = 
          for
          {
            default[4] = 
            for
            {
              default[5] = 
              mach was mit default
            }
          }
        }
      }
    }
  }

[B. S. (bestucki)]

default ist in C-Sprachen ein reservierter Begriff und kann nicht für 
Bezeichner verwendet werden.

ich schrieb:
> Vergleich mit 256 wird auch nicht funktionieren (255 ist die größe
> 8bit-Zahl).

int ist grösser als 8 Bit.


Ansonsten: Überleg mal was du tust:
default[0]=0;
default[0]=1;
default[0]=2;
default[0]=3;
.
.
.
default[1]=0;
default[1]=1;
default[1]=2;
default[1]=3;
.
.
.
usw.

[Ingo P. (Gast)]

@ich
Soviel Ahnung scheinst du aber auch nicht zu haben?

@Stefan:
Überlege dir doch mal, wie du dezimale Zahlen von 00 bis 99
zählen würdest. Wie ginge es von 000 bis 999?
(Stichwort: Übertrag, fange von hinten an)
(Oder 6 verschachtelte Schleifen, jede Schleife für eine Stelle,
wenn du dann aber mal 16 Stellen haben willst, brauchst 16 Schleifen...)
Wenn du 6 Zahlen in ein Array speichern willst,
dann bitte auch Platz für 6 Zahlen schaffen.

[Peter II (Gast)]

oder

uchar default[5] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

for(int64_t i = 0; i < 0xFFFFFFFFFFFF; ++i )
{
   Default[0] = i       & 0xFF;
   Default[1] = (i>> 8) & 0xFF;
   Default[2] = (i>>16) & 0xFF;
   Default[3] = (i>>24) & 0xFF;
   Default[4] = (i>>32) & 0xFF;
   Default[5] = (i>>40) & 0xFF;
}

[Stefan A. (ripper121)]

danke :)

[Udo S. (urschmitt)]

Stefan Anderson schrieb:
> doch will ich ;) hast du das als code?

Bevor du das als Code kriegst rechne aus wieviel 256 hoch 6 ist und wie 
lange das dauert wenn du in 0,1µs einen Wert schreibst.

[Karl H. (kbuchegg)]

Stefan Anderson schrieb:
> doch will ich ;) hast du das als code?

Das willst du garantiert nicht.

Rechne mal ein bischen.

es gibt 256^6 unterschiedliche Kombinationen (^ist 'hoch')

das sind 281474976710656 Stück.

Angenommen, nur mal angenommen, du könntest 1 Mio pro Sekunde 
durchspielen (was du höchst wahrscheinlich nicht kannst), wie lange 
dauert das?

281474976710656 / 1000000 = 281474976.7106 Sekunden

281474976 Sekunden sind 281474976/60 = 4691249.6 Minuten

4691249 Minuten sind 4691249/60 = 78187 Stunden

78187 Stunden sind 78187 / 24 = 3257 Tage

3257 Tage sind 3257 / 365 = 8.9 Jahre


Immer noch sicher, dass du das willst?

[Ingo P. (Gast)]

Ganz so schlimm ist es nicht. Ein nicht mehr ganz aktueller Rechner
braucht für Peters Variante für alle Kombinationen der 6 Bytes
knappe 12 Tage.

4 Bytes werden in etwa 15 Sekunden durch gezählt,
also etwa 300 Millionen pro Sekunde.

Wenn dann pro Kombination noch etwas gemacht werden soll,
dann wird die Zeit natürlich gleich viel länger...

[Karl H. (kbuchegg)]

Ingo P. schrieb:

> Wenn dann pro Kombination noch etwas gemacht werden soll,
> dann wird die Zeit natürlich gleich viel länger...


:-)

Warum nur musste ich bei den Variablennamen 'Key' und 'Code' an einen 
naiven COdeknacker denken, der einfach alle Kombinationen durchprobiert.

Jetzt weiss der TO auch, warum sowas in der Praxis nicht wirklich 
funktioniert.
Ganz abgesehen davon, dass jedes 'Schloss', das etwas auf sich hält, 
nach ein paar Fehlversuchen erst mal ein längeres Päuschen einlegen 
wird.

[Stefan A. (ripper121)]

Also habe es mit einer Mifar (NFC/RFID) Karte Probiert, diese macht 
keine Pause.

[Stefan A. (ripper121)]

Brauche für 1 Kombi ca 0.00278 sec

[Karl H. (kbuchegg)]

Stefan Anderson schrieb:
> Brauche für 1 Kombi ca 0.00278 sec

OK, also kannst du alle Zahlen mindestens mal 2000 nehmen.

Ich habe meine Zeitschätzung auf 1 Mio Versuche pro Sekunde basiert. Du 
schaffst aber keine 1 Mio. Du schaffst gerade mal 500.

D.h. du landest bei rund 17-tausend Jahren.