OlbersD -
03.12.09 15:54
/** Aus en.wikipedia.org char S[256];unsigned int i, j; void swap(unsigned char *s, unsigned int i, unsigned int j) { unsigned char temp = s[i]; s[i] = s[j]; s[j] = temp;} /* KSA */void rc4_init(unsigned char *key, unsigned int key_length) { for (i = 0; i < 256; i++) S[i] = i; for (i = j = 0; i < 256; i++) { j = (j + key[i % key_length] + S[i]) & 255; swap(S, i, j); } i = j = 0;} /* PRGA */unsigned char rc4_output() { i = (i + 1) & 255; j = (j + S[i]) & 255; swap(S, i, j); return S[(S[i] + S[j]) & 255];} #include <stdio.h>#include <string.h>#include <stdlib.h> #define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0])) int main() { int cnt=0; int k,cin;/* unsigned char *test_vectors[][2] = { {"Key", "Plaintext"}, {"Wiki", "pedia"}, {"Secret", "Attack at dawn"} }; int x; for (x = 0; x < ARRAY_SIZE(test_vectors); x++) { int y; rc4_init(test_vectors[x][0], strlen((char*)test_vectors[x][0])); for (y = 0; y < strlen((char*)test_vectors[x][1]); y++) printf("%02X", test_vectors[x][1][y] ^ rc4_output()); printf("\n"); } return 0;}*//********** Hier Passwort eintragen und als Datei rc4.c speichern Compilieren: gcc rc4.c Verschluesseln der Datei fileX: cat fileX | ./a.out > fileX.rc4 Wiederherstellung: cat fileX.rc4 | ./a.out > fileX */rc4_init("geheim", strlen("geheim"));for (k=0;k<3072;k++) rc4_output();while(!feof(stdin)){ cin = fgetc(stdin); if (!feof(stdin)) { cnt++; printf("%c", (unsigned char) ((unsigned char)cin ^ rc4_output())); } }}
- An Datein verschlüsseln mit Ubuntu Linux Twitter senden
- Mit Datein verschlüsseln mit Ubuntu Linux Facebook empfehlen
Jetzt können mit dem Programm beliebige Dateien ver- oder entschlüsselt werden. Weil die XOR-Verknüpfung selbstinvers ist, wird zum ver- oder entschlüsseln das gleiche Programm aufgerufen.
Compile:
ubuntu@ubuntu:~$ gcc rc4.c
Verschlüsseln in Datei aubuntu@ubuntu:~$ cat rc4.c | ./a.out > a
Entschlüsseln von Datei a:
ubuntu@ubuntu:~$ cat a | ./a.out > b
Die Datei b enthält jetzt eine Kopie der Datei rc4.c.
Mit "tar" kann ein ganzes Verzeichnis in eine Datei gepackt werden und enventuell mit gzip komprimiert werden. Die gepackte Datei kann auf einem Server kopiert werden und dort vor unberechtigtem Zugriff sicher. Sie könnte höchsten gelöscht werden. Aber lesen kann sie niemand.
Der Download im Internet
en.wikipedia.org
übernommen. Zum Testen hatte ich den counter cnt eingeführt. Der wird nicht mehr benutzt und könnte daher auch entfernt werden. Ob das Programm besonders schön geschrieben ist, mag bezweifelt werden, aber es läuft. Auch könnte es noch performanter geschrieben werden. Das ist aber alles ziemlich wurscht, weil es auch so sehr schnell ist. Es benötigt im Vergleich zu einer Festplatte und selbst zu einer altmodischen 3,5''-Diskette kaum Speicher. Mit Linux gibt es immer den C-Compiler gcc.
Das Programm verschlüsselt einfach die Standardeingabe (stdin) in die Standardausgabe stdout. Mit dem cat unter Unix/Linux kann der Inhalt jeder Datei auf der Standardausgabe ausgegeben werden. Dies ernöglicht das Verschlüsseln beliebiger Dateien. Die Größe kann auch mehrere Giabyte betragen. Das Tool ist daher ideal zur Verschlüsselung einer gepackten Backup-Datei geeignet.
iuser@icp:~$ sha1sum x.c0374f931ed43d3926de199ccdac4e9feef267037 x.c
iuser@icp:~$ sha1sum x.c0374f931ed43d3926de199ccdac4e9feef267037 x.c
Doch es gibt sichere Verschlüsselung, nämlich das One-Time-Pad. Beliebige Informationen lassen sich immer binär mit nur zwei Zeichen etwa 0 und 1 darstellen. Beim One-Time-Pad wird Zeichen für Zeichen verschlüsselt, wo ein zufälliges Schlüsselzeichen 0 oder 1 benutzt wird. Ist das Schlüsselzeichen 1 wird das Zeichen der Nachricht invertiert (0 und 1 vertauscht) beim Schlüsselzeichen 0 bleibt das Zeichen der Nachricht unverändert. So funktioniert die XOR-Verknüpfung. Ist genau die Hälfte der
zufälligen Schlüsselzeichen 1 ist die Wahrscheinlichkeit für jedes mögliche Zeichen der Nachricht auch genau 50 Prozent.
Ist die Folge der Schlüsselzeichen wirklich zufällig, nicht vorhersagbar und statistisch gleich verteilt gibt es keinen Ansatzpunkt zum Entschlüsseln.
Bei einem Verschlüsselungsverfahren wie RC4 sind die Schlüsselzeichen nicht wirklich zufällig, sondern werden aus einem Kennwort berechnet. Wichtig ist hierbei vor allem, dass sich die Folge der Schlüsselwerte nicht wiederholt und statistisch gleich verteilt ist. Bei RC4 ist eine zufällige Wiederholung praktisch ausgeschlossen. Ein Schwäche des Verfahrens gibt es nur, wenn ähnliche Passworte etwa durch einfaches Anhängen einer fortlaufenden Zahl gebildet werden. Dieses Problem wird aber
durch das Auslassen der ersten 3072 Zufallszeichen weitgehend ausgeschlossen.
RC4 ist extrem schnell. Es ist daher kein Problem wenn nicht jedes Zufallszeichen sondern etwa nur jedes siebte zum Verschlüsseln benutzt wird. Neben RC4 gibt es weitere so genannte Stromchiffren, die ebenfalls sehr sicher sind. Bemerkenswert an RC4 ist, dass es extrem einfach und damit auch leicht überprüfbar und trotzdem sehr sicher ist.
NEUSTART VON RC4
Noch einmal getestet - läuft super!
Es ist echt der Wahnsinn wie einfach das geht. Ich habe das Programm hier, was ich ja selbst mal hier reingestellt habe per Cut & Paste in eine Datei rc4.c gesteckt, mit gcc rc4.c übersetzt und schon läuft die Sache:
rc4.c: In Funktion »main«:
rc4.c:73: Warnung: Zeigerziele bei Übergabe des Arguments 1 von »rc4_init« unterscheiden sich im Vorzeichenbesitz
iuser@icp:~$ cat a.out | ./a,out > a
bash: ./a,out: No such file or directory
iuser@icp:~$ cat a.out | ./a.out > a
iuser@icp:~$ cat a | ./a.out > b
iuser@icp:~$ diff a b
Binärdateien a and b sind verschieden.
iuser@icp:~$ diff a a.out
Binärdateien a and a.out sind verschieden.
iuser@icp:~$ diff b a.out
Die Warnung kann man irnorieren oder ein Kleinigkeit ändern.
rc4_init((unsigned char *)"geheim", strlen("geheim"));
iuser@icp:~$ vi rc4.c
iuser@icp:~$ gcc rc4.c
iuser@icp:~$ cat a.out | ./a.out > aa
iuser@icp:~$ diff aa a
No, news is goog news - alte Unix-Weisheit.
Mit der Hilfe von Google und den Stichworten "rc4" und "yigg" habe ich das Programm hier auch gleich wiedergefunden. Wahnsinn, wie reibungslos das alles funktioniert. Das Programm kann weitgehend auch bei Wikipedia wiedergefunden werden (unbekannter Autor).
Auf eine Hashfunktion wie sha1 kann auch verzichtet werden und statt dessen der Inhalt vorher mit gzip gepackt werden. Die gepackte Datei enthält auch eine Prüfsumme (crc32), die verschlüsselte Datei kann damit nicht unbemerkt manipuliert werden.
Die höchste Sicherheit gibt es mit Linux und einer sogenannten Live CD. Da braucht auf der Festplatte gar nichts gespeichert werden. Ja sogar ein Rechner ganz ohne Festplatte ist durchaus brauchbar, weil der RAM-Speicher bei modernen Compurtern voll ausreicht.
Ja, was uns die Experten alles über starke Kryptographie und den Public Key erzählt haben, dass könnt ihr vergessen. Der RC4-Algorithmus hier ist bestimmt nicht der Weisheit letzter Schluss, aber trotzdem praktisch nicht zu knacken. Es gibt aber praktisch unendlich viele Variationen dieses Verfahrens, die bestimmt nicht unsicherer sind. Das Grundprinzip, eine Zufallsfolge erzeugt aus einem geheimen Wert (Schlüssel, Passwort oder wie immer man das nennen mag) und zeichweise XOR- oder sonstige
"Addition" der Nachricht, die mit einer "Subtraktion" (hier XOR-Verknüpfung) des "Schlüssels" umgekehrt werden kann. Ein solche Zufallsfolge kann zum Beispiel leicht mit einer Hashfunktion h(key, counter) realisiert werden. Wenn das Verfahren nicht wie hier öffentlich gemacht wird, ist es natürlich noch sicherer.
Klar, ein geheimer Schlüssel muss vorher ausgetauscht werden. Dies funktioniert am besten durch Aufteilung des Schlüssel in mehrere Teilschlüssel. Der Gesamtschlüssel kann beispielsweise mit einer Hashfunktion (sha1, md5, ...) berechnet werden key_final = h (k1, k2, ..., kn). Die Teilschlüssel können zu unterschiedlichen Zeiten auf ganz unterschiedliche Weise übertragen werden. Es können natürlich beliebige Informationen genutzt werden, die nur Person X kennen kann, ohne dass die
Informationen ursprünglich zur Schlüsselübertragung gedacht waren. Diverse Nummern, die sich auf bestimmten Schreiben befinden, könnten hierzu herangezogen werden. Der Publc Key ist dagegen totaler Blödsinn. Weil nicht klar ist wer das geheime Gegenstück, den "Private Key" besitzt. Damit die Sache völlig witzlos und der Austausch von Zertifikaten erweist sich als mindestens so schwierig wie der Austausch gehemer Schlüssel und gelingt eigentlich nur, wenn es einen gemeinsames
"Geheimnis" gibt. Dann ist aber auch der Public Key nicht mehr erforderlich.
Die einzige echte Schwachstelle beim ist die Initialisierung:
/* KSA */
void rc4_init(unsigned char *key, unsigned int key_length) {
for (i = 0; i < 256; i++)
S[i] = i;
for (i = j = 0; i < 256; i++) {
j = (j + key[i % key_length] + S[i]) & 255;
swap(S, i, j);
}
i = j = 0;
}
Mit diesem modifizierten Code wird die Routine einfach 10 mal durchlaufen. Damit sind bereits alle bekannte "Angriffe" abgewehrt.
/* KSA */
void rc4_init(unsigned char *key, unsigned int key_length) {
int k;
for (i = 0; i < 256; i++)
S[i] = i;
for (k=0;k<10;k++) {
for (i = j = 0; i < 256; i++) {
j = (j + key[i % key_length] + S[i]) & 255;
swap(S, i, j);
}
} /* for k */
i = j = 0;
}
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
unsigned char S[256];
unsigned int i, j, k, r;
void swap(unsigned char *s, unsigned int i, unsigned int j) {
unsigned char temp = s[i];
s[i] = s[j];
s[j] = temp;
}
/* KSA modified */
void rc4_init(unsigned char *key, unsigned int key_length) {
for (i = 0; i < 256; i++)
S[i] = 256 - i;
for (r=0;r<11;r++){
for (i = j = 0; i < 256; i++) {
j = (j + key[i % key_length] + S[i]) & 255;
swap(S, i, j);
}
}
i = j = 7;
}
/* PRGA */
unsigned char rc4_output() {
i = (i + 3) & 255;
j = (j + S[i]) & 255;
swap(S, i, j);
return S[(S[i] + S[j]) & 255];
}
int main(int narg, char **argv) {
int cin;
/**********
* Passwort pword
* Compilieren:
* gcc r.c
* Verschluesseln der Datei fileX:
* cat fileX | ./a.out pword > fileX.r
* Wiederherstellung:
* cat fileX.r | ./a.out pword > fileX
*
*/
rc4_init((unsigned char *)argv[1], strlen(argv[1]));
for (k=0;k<5072;k++) rc4_output();
while(!feof(stdin)){
cin = fgetc(stdin);
if (!feof(stdin)) {
printf("%c", (unsigned char)cin ^ rc4_output() );
}
}
Die modifizierte Version ist natürlich mindestens ebenso sicher wie die Originalversion. Wird ein in ähnlicher Weise modifiziertes Programm benutzt, ohne die Details öffentlich zu machen, kann die Verschlüsselung als praktisch nicht zu knacken betrachtet werden. Einziges Problem der Schlüssel (Passwort) darf nur einmal verwendet werden.
Die Zufallsfolge hängt bei der RC4-Verschlüsselung allein vom Schlüsselwert ab. Würde eine Nachricht zweimal mit dem gleichen Schlüssel verschlüsselt und läge eine Nachricht samt zugehörende Chiffre vor, könnte damit der Schlüssel errechnet werden und weitere damit verschlüsselte Nachrichten könnten entschlüsselt werden. Der Algorithmus kann aber leicht abgewandelt werden, so dass die Zufallsfolge auch von der Nachricht abhängt. Höchste Sicherheit wird in jedem Fall erreicht, wenn eine
einmaliger Schlüssel benutzt wird wie etwa
key = sha-1(master_key + counter)
Was in der Presse verbreitet wurde, "starke Verschlüsselung", die auch von Experten nicht geknaclt werden könne, bedürfe besonders ausgeklügelter mathematischer Algorithmen, ist eindeutig Quatsch. Der RC4 ist im Grunde ziemlich banal und bestimmt nicht der Weisheit letzter Schluss, aber ziemlich sicher beim einmaliger Verwendung des Schlüssels. Weil er so einfach ist, ist er auch rasend schnell. Mit einem GHz Taktfrequenz wird etwa ein GBit/s erreicht. Der Rechner verschlüsselt also
schneller als eine schnelle Internetverbindung Daten übertragen kann. Im Gegenteil haben sich die meisten Algorithmen, mindestens die die ursprünglich verwendeten Public Key Verfahren, die in der hochgelobten Software PGP verwendet wurden, im Nachhinein als höchst unsicher erwiesen, jedenfalls für Geheimdienste. Natürlich ist ein Verfahren um so sicherer je weniger davon öffentlich bekannt ist. Ein private RC4-ähnliches Programm ist damit höchst sicher. Wenn alle nur PGP benutzen (weil das
angeblich total sich sei) ist dies weit unsicherer. Der Geheimdiest kann dann die meisten Chiffren knacken, indem schlicht unzählige Schlüssel durchprobiert werden, bis der richtige gefunden wurde. Ist das Verschlüsselungsprogramm nicht bekannt, funktioniert diese Methode nicht.
Eine private RC4-Variante: S[i] = (i + 7) % 256 statt S[i] = i, mehrfaches Durchlaufen von rc4_init(), nur jedes dritte berechnete Zufallsbyte wird zum Verschlüsseln benutzt, ... ist quasi sicher, wenn das Programm und der genaue Algorithmus nicht bekannt gemacht wird. Selbst wenn der genaue Algorithmus bekannt ist, ist eine Entschlüsselung mindestens sehr schwierig. Ist dieser nicht bekannt, ist auch mit Passwort eine Entschlüsselung schwierig. Ist beides unbekannt, ist die Entschlüsselung
nahezu hoffnungslos. Werden viele, viele leicht abgewandelte Algorithmen benutzt, lohnt sich für den Experten der Versuch einer Entschlüsselung kaum. Wenn nur ein Algorithmus geknackt werden kann, der eher selten benutzt wird, stehen die Kosten zum "Knacken" (sofern überhaupt möglich) in keinem Verhältnis zum Nutzen. Es ist daher Quatsch, wenn alle einen Algorithmus von einem vermeintlichen Cryptogenie benutzen, weil angeblich nur dieses Genie, solche Algorithmen entwerfen kann. Der
Schaden ist dann um so größer, wenn das Verfahren doch irgendwie geknackt werden kann.
Absoluter Schwachsinn ist dagegen die PGP-Signatur mit dem Public Key. Ist ein Dokument verschlüsselt und kann nur mittel eines Schlüsselwerts entschlüsselt werden, liefert dies auch den Beleg, dass die Nachricht von einer bestimmten Person verschlüsselt wurde. Darüber hinaus kann eine Signatur mit einer Hashfunktion wie SHA-1 (sha1sum unter Linux) erstellt werden (Sig = SHA-1( key, SHA-1(Message))). Dieser Wert Sig könnte zugleich als Session Key für die RC4-Verschlüsselung dienen.
Der Schlüssel kann von einem Server verteilt werden. Dies setzt natürlich voraus, dass der Server und dessen Betreiber vertrauenswürdig sind. Doch es ist eindeutig Illusion, dass Datensicherheit irgendwie funktionieren könnte, wenn es nichts und niemand gibt, dem wir vertrauen können.
Eine "elektronische Signatur" wird sinnvoller Weise aus einem geheimen Schlüssel key und der Nachricht message berechnet. Hier für kann eine kollisionsfreie Hashfunktion h wie SHA-1 benutzt werden (Sig = h ( key, h(message) ). Es ist sinnvoll die Signatur nicht unmittelbar aus der Nachricht, sondern aus dem Komprimat h(M) zu berechnen. Dies hat den Vorteil, dass die Nachricht zur Prüfung der Signatur gar nicht bekannt sein muss. Von einer Nachricht können beliebig viele Signaturen
erstellt werden. Dies weitgehend unabhängig von einander erfolgen. Bei mehreren Signaturen, kann die Unterschrift oder Signatur von mehreren unahhängigen Dienstleistern geprüft werden. Keiner dieser Dienstleister braucht die Nachricht zu kennen, da die Prüfung alleine mit dem Hashwert h (message) möglich ist.
de.wikipedia.org
Also ein Message Authentication Code kurz MAC, zum Beispiel HMAC, ist es, was für die elektronische Unterschrift wirklich benötigt wird. Es gibt tatsächlich fast beliebig viele Verfahren zur Auswahl, die alle von den mathemathischen Algorithmen her nicht mehr wirklich verbessert werden können. Der Public Key und RSA und das Signaturgesetz bringt dagegen überhaupt nichts.
Das fast perfekte Verschlüsselungsverfahren ist ein modifiziertes RC4-Verfahren mit NICHT veröffentlichtem Quellcode und Algorithmus. Entsprechend ist die fast perfekte elektronische Signatur ein MAC, etwa ein leicht modifiziertes HMAC-Verfahren mit NICHT veröffentlichtem Quellcode und Algorithmus.
Vielleicht sollte es nicht "das" sondern "ein" fast perfektes ... heißen.
Richtig ist, ein Verfahren sollte so entwickelt werden, dass nur die Geheimhaltung des Schlselwerts (PIN/Passwort) wirklich notwendig ist und auch bei vollstdiger Offenlegung des Verfahren nicht zu knacken ist. Vlig idiotisch ist es, dies bei einem praktisch eingesetzen Verfahren tatshlich offenzulegen. Je weniger ein Angreifer wei um so besser, daran gibt es nichts zu deuteln.
Tatsächlich ist die asymmetrische Verschlüsselung oder der Verschlüsslung mit öffentlichem Schlüssel totaler Quatsch und letztlich völlig nutzlos. Kein Verfahren zur elektronischen Unterschrift kann funktionieren, wenn nicht zum Beispiel die Identität einer Person durch Ausweiskontrolle durch vertrauenswürde Personen/Institutionen geprüft wird. Unter diesen Voraussetzung ist aber ein öffentlicher Schlüssel und X509-Zertifikat oder Ähnliches vollständig überflüssig. Als Signatur kann ein MAC
dienen. Der Schlüssel (Passwort) zur Erstellung muss von einer vertrauswürdigen Stelle sicher übermittelt werden. Zur Steigerung der Sicherheit können einfach mehrere "Signaturen" benutzt werden. Die vollständige Offenlegung des Verfahrens (ohne Schlüsselwert) ist theoretisch denkbar aber nicht sinnvoll. Das Verfahren kann auch modifiziert werden. Gibt es mehrere Verfahren, die geheim bleiben, bedeutet dies maximale Sicherheit.
Nochmal: Doch das absolut total unknackbare Verfahren gibt es, nämlich das One Time Pad. Dazu braucht man allerdings Zufallszeichen, genau so viele wie die Nachricht hat. Aber mit einem ziemlich banalen Verfahren wie RC4 ist dies gar kein Problem. Aus einem Kennwort kann eine solche Zufallsfolge im Null-Komma-Nichts von jedem Computer berechnet werden. Ok, dann es kein wirklich perfektes One Time Pad mehr, aber geknackt werden kann es trotzdem nicht. Wichtig ist nur: Kennwort nur einmal
benutzen!
Zufallsgeneratoren wie RC4 gibt es quasi unendlich viele und aus RC4 können quasi unendlich viele durch kleine Variationen gewonnen werden. Total sicher ist der Zufallsgenerator
i=0;
wiederhole
zufall(i) = hash ( kennwort + i )
Mit i = 0,1,2, ... sind die Argumente der Hashfunktion kennwort+0, kennwort+1, ... immer verschieden und die Zufallswerte damit auch. Mehr zum One Time Pad mit dem unten angegebenen Link (Datei OTP.pdf, Kennwort: LottoXY.
Unglaublich ist das verbreitete sinnlose Experten-Geschwätz aus den 90er Jahren des vergangenen Jahrhunderts. Es gibt tatsächlich gar keinen Sinn, wenn alle auf DIE Expertensoftware (PGP oder so was) statt ihre eigene Software benutzen. Ein OTP geht zur Not auch ganz ohne Software und Computer und ist total sicher. Richtig, ein Verfahren sollte sicher sein, auch wenn nur der Schlüssel und nicht das Verfahren geheim ist. Aber es macht trotzdem keinen Sinn alles zu veröffentlcihen. Je weniger
der Gegener weiß, um so besser. An dieser Binsenweisheit gibt es nichts zu deuteln. Wenn jeder sein eigenes Verfahren benutzt, lohnt sich der Aufwand es zu knacken für den Geheimdienst nicht. Wenn alle PGP benutzen kann es schon lohnen DIE zu knacken. Tatsächlich ist mindestens die Originalversion von PGP längst geknackt. Vielleicht kannte der Geheimdienst von Anfang an eine Hintertür.
Die Originalversion von PGP benutze RSA für die Public-Key-Verschlüsselung und MD5 als Fingerabdruckt für die Nachricht, der mit RSA verschlüsselt wurde. Diese Verfahren sind total kaputt. Bei den damals benutzten Schlüssellängen kann jedenfalls heute der Geheimdienst ohne weiteres den privaten Schlüssel berechnen. Damit ist bereits alles verloren. Nachrichten können entschlüsselt werden und auch mit falscher Unterschrift versehen werden. Auch der vermeintliche Fingerabdruck mit MD5
funktioniert nicht, weil der Geheimdienst manipulierte Dokumente mit dem gleichen Fingerabdruck erstellen kann.
Ich habe nichts gefunden, was mir echt Sorgen machen könnte. Werden die ersten 100 oder 1000 ersten Bytes des PRG verworfen und der KSA mehrfach durchlaufen sehe ich kein Problem. Am besten ist es die Nachricht auch in den PRG einfließen zu lassen. Dann sehe ich wirklich nicht den geringsten Angriffspunkt. Der modizierte RC4 ist damit kaum wesnetlich langsamer und schneller als DSL.
Starten mit einer beliebigen Permutation statt S[i] = i.
Beispiel:
for(i=0;i<256;i++){
y = (3*i + 11) % 256;
yy = (19*y+29) % 256;
yyy = (41*yy+6) % 256;
S[i] = yyy;
}
Es gibt quasi beliebig viele Möglichkeiten RC4 leicht zu variieren, so dass sich mindeestens auf den ersten Blick total unterschiedliche Chiffren ergeben. Es kann auch leicht überprüft werden, ob das Programm sicher ist. Dazu ist kann die Chiffre mit einem Programm wie gzip komprimiert werden. Wenn die Chiffre wirklich aus zufällig erscheinenden Zeichen besteht, ist es nicht möglich die Datei zu komprimieren und eine mit gzip komprimierte Datei enthält einige Bytes mehr als die unkomprimierte
Version. Ist dies nicht der Fall, liegt ein Fehler vor.
Ein zufällige S-Box (Vertauschung der Zahlen 0..255) ergibt sich, wenn der KSA mit irgend einem Passwort ausgeführt wird. Auf diese Weise kann eine zufällig S-Box gewählt werden. Der abgewandelte RC4-Algorithmus kann mit dieser S-BOX starten, statt mit S[i] = i. So ergeben sich unendlich viele RC4-Varianten, die sicherlich nicht unsicher als die Original-Version sind. Es gibt quasi unendlich viele, nämlich 256! = 33508506849329791176526651237548149420225840635917407025767798842862\
08799035732771005626138126763314259280802118502282445926550135522251\
85672769253319307041281108333032565932204170002979216625073425339051\
37544660457112403384627010340202629925813784231472766366436471553963\
05352541105541439434840109915068285430675068591638581980604162940383\
35658673919826878210492461407660579356286524198217620742862096977680\
31494674313868079724382476891586560000000000000000000000000000000000\
00000000000000000000000000000
Uups, Fehler das ist nur 255! Ihr müsst die Zahl noch mit 256 multiplizieren.
def fakultaet(x):
if x > 1:
return x * fakultaet(x - 1)
else:
return 1
>>> fakultaet(256)
85781777534284265411908227168123262515778152027948561985965565037726945255314758 93774402913604514084503758853423365843061571968346936964753222892884974260256796 37332563368786442675207626794560187968867971521143307702077526646451464709187326 10083287632570281898077367178145417025052301860849531906813825748107025281755945 94769870346657127381392862052347568082188607012036110831520935019474371091017269 68262861606263662435022840944191408424615936000000000000000000000000000000000000
000000000000000000000000000L
Sorry Leute, Python heißt die Programmiersprache.
Mit dem KSA in RC4 gibt es für jede vorgegebene S-Box mindestens einen Schlüsselwert (2048-Bit), bei der diese S-Box angenommen wird. Dies ist relativ einfach zu erkennen. Der j-Wert j +s[i] + key[i] kann jeden Wert annehmen, indem der Wert key[i] entsprechend gewählt wird. Damit kann auch erreicht werden, dass s[i] mit dem richtigen s[j] getauscht wird (auch i=j ist denkbar). Es gibt also wirklich fakultät(256) effektiv verschiedene Schlüsselwerte. Das zufällige Erraten der S-box ist damit
bei einem zufällig gewählten Schüssel ausreichender Länge quasi aussichtslos. Dies gilt auch bei mehrfachen durchlaufen des KSA.
Also - man kann die S-Box als effektiven Schlüssel ansehen. Die S-Box kann durch den Standard-KSA aus einem Kennwort berechnet werden. Dies ist aber eher nicht zu empfehlen, weil dieser Teil des RC4 unsicher ist und eventuell der Schlüssel (oder Teile davon) aus den ersten Bytes der Zufallsfolge ermittelt werden kann. Durch mehrfaches Durchlaufen des KSA - wie hier vorgeschlagen - und das Verwerfen der ersten paar hundert bis tausend Zufallsbytes umgeht diese Schwachstelle bereits.
Es wäre aber auch denkbar den KSA durch ein vollständig anderes Verfahren, das eine "zufällig" S-Box produziert zu ersetzen. Nachliegend ist ein Verfahren das "zufällig" zwei Zahlen (0-255) ermittelt und dann wie auch beim Standard-RC4 die Werte S[i] und S[j] vertauscht werden.
Ein solches Verfahren ist vielversprechend, da jede beliebige S-Box durch eine eher geringe Zahl solcher Vertauschungen aus der Identität (S[i] = i) hervorgeht. Dies wird deutlich an der Untersuchung des BubbleSorts. Hier wird umgekehr in wenigen Iterationsschritten eine beliebige Permutation in die "richtige" Reihenfolge gebracht.
Es gibt viele Zufallsgeneratoren, die sehr schnell Zufallszahlen generieren können. Mit der (mod 256) lassen sich damit leicht Zufallszahlen von 0-255 (Zufallsbytes) erzeugen. Eine Zufalls-S-Box könnte durch häufig wiederholtes Vertauschen von S[i] mit S[j] mit Zufallsbytes i,j erreicht werden.
In einer Sekunde könnten mehrere Millionen Vertauschungen durchgeführt werden.
Testprogramm zur Häufigkeitsverteilung h[i] mit Zufallsgenerator aus Wikipewdia:
#include<stdio.h>
unsigned int m_w = 7; /* must not be zero */
unsigned int m_z = 17; /* must not be zero */
unsigned int get_random()
{
m_z = 36969 * (m_z & 65535) + (m_z >> 16);
m_w = 18000 * (m_w & 65535) + (m_w >> 16);
return (m_z << 16) + m_w; /* 32-bit result */
}
main(){
int h[256],i;
for(i=0;i<256;i++) h[i]=0;
for (i = 0; i < 2000000; i++) {
h[(int)(get_random() % 256)] += 1;
}
for(i=1;i<256;i++){
printf("%d\n",h[i]);
}
}
Sorry, Wikipedia natürlich, siehe Link weiter oben.
de.wikipedia.org