Sichere Verschüsselung auf Basis des One-Time-Pads
In cryptography, the one-time pad (OTP) is a type of encryption that is impossible to crack if used correctly. (Wikipedia 2013)Alles was für ein One-Time-Pad, die perfekte Verschlüsselung, gebraucht wird, ist ein Zufallsgenerator, quasi ohne Wiederholungen durch einmaliges Passwort.
Ein sehr einfacher Zufallsgenerator ist ARC4, auch RC4 oder Arcfour genannt. Die Wahl eines einmaligen (garantiert durch eine fortlaufende Nummer #num), zufälligen, hinreichend langen Passworts, ist zum Beispiel mit einer Hashfunktion wie SHA-1 (Linux: sha1sum) möglich. Zusammen mit ARC4 ist das Verfahren entsprechend bekannter Analysen sicher. Es gibt quasi beliebig viele Möglichkeiten noch Details an ARC4 zu variieren, wodurch die Sicherheit keinesfalls negativ beeinflusst wird. Bei Geheimhaltung der im Einzelfall benutzen Variante, ist das Verfahren extrem sicher.
Einmalige Passwort - berechnet mit SHA-1
Passwort#num = hash( Passwort + num )ubuntu@ubuntu:~$ echo "pwxABC_1" | sha1sum 4ef9dda1d4774b342b9af84d1ae2df8054e5d214 - ubuntu@ubuntu:~$ echo "pwxABC_2" | sha1sum 9334971f1dd7fff2e7152816d206ee60fb0c5d45 - ubuntu@ubuntu:~$ echo "pwxABC_3" | sha1sum 12b0c2a2e263cfcd5ded13eba15a92bcb20fc363 -
Wie funktioniert RC4?
WWWCrypt 2.0 basiert auf einer Variante des Algorithmus ARC4 mit Rückkopplung der verschlüsselten Daten auf die Zufallsfolge und wiederholter Anwendung der Initialisierung sowie Auslassung der ersten Werte der Zufallsfolge. Das grundlegende Prinzip des Verfahren wird mit der folgenden Abbildung von Matt Crypto aus Wikipedia erläutert. Unter "work" (Arbeit) ist die Abbildung zu verstehen. K bezeichnet den Zufalls- oder Schüsselwert (engl. key) der mit der Nachricht verknüpft wird. Ein Vertauschung (mathematisch Permutation) oder Substitution (S-Box) der 256 Bytewerte und zwei Zeiger i,j sind Grundlage zur Berechnung des Schlüssels (K für englisch Key). K ist ein Wert der Zufallsfolge, die im OTP-Verfahren zur Anwendung kommt.
Figure 1: This work has been released into the public domain by its author, Matt Crypto. This applies worldwide. In some countries this may not be legally possible; if so: Matt Crypto grants anyone the right to use this work for any purpose, without any conditions, unless such conditions are required by law.
Datensicherheit durch Verschlüsselung mit Kennwort
Daten, das heißt Texte, Bilder und beliebige Dokumente und Dateien können durch ein Verschlüsselungsverfahren gegen unberechtigtes Lesen und Kopieren und zugleich gegen Manipulationen zuverlässig geschützt werden. Die Daten werden dabei mittels eines Kennworts in eine nicht lesbare Form konvertiert, also verschlüsselt. Entschlüsselt, also wieder lesbar gemacht werden können die Dokumente nur bei Kenntnis des Kennworts. Die einzige Möglichkeit die Dokumente zu lesen, ohne Kenntnis des Kennworts, ist dieses zu erraten. Bei einem hinreichend langem zufälligem Kennwort ist dies praktisch unmöglich.
Durch Verschlüsselung können die Daten im Internet preiswert und einfach gespeichert werden ohne die Datensicherheit zu gefährden, obgleich die von vermeintlichen Experten oft in Abrede gestellt wird. Die Festplatte des Rechners wird damit gar nicht mehr zwingend benötigt. Der flüchtige Arbeitsspeicher, der beim Ausschalten des Rechners automatisch gelöscht wird, reicht vollkommen aus. Ideal sind Linux-Systeme (Ubuntu oder Knoppix), die von der nicht beschreibaren CD oder DVD gestartet werden.
Es wird häufig bezweifelt, dass es wirklich sichere Verschlüsselung möglich sei und besondere Spezialprogramme erfordere. Eindeutig Unsinn - das Einmalblock- oder One-Time-Pad-Verfahren ist absolut sicher. Bei diesem Verfahren wird ein einmaliger und rein zufälliger geheimer Schlüssel ebenso lang wie die Nachricht verwendet. Dieser lange Schlüssel, eine Zufallsfolge, kann aus einem wesentlich kürzeren Kennwort berechnet werden. Zur Berechnung der Zufallsfolge können relativ einfache Verfahren wie Arcfour benutzt werden. Wird das Kennwort nur einmalig benutzt ist ein solches Verfahren praktisch sicher.
Rückwirkung der Nachricht auf die Zufallsfolge
Eine wesentliche Verbesserung und Vereinfachung wird erreicht, wenn die Nachricht auch in die Berechnung der Zufallsfolge mit einfließt. In diesem Fall kann das gleiche Kennwort mehrfach genutzt werden und eine Prüfsumme ist nicht zwingend erforderlich. Durch die Abhänigkeit der Zufallsfolge von den Daten werden auch Manipulationen am Text weitgehend ausgeschlossen, die sonst möglich wären. Mit höchster Sicherheit werden Manipulationen ausgeschlossen, wenn die Daten mit einer Software wie gzip vor der Verschlüsselung komprimiert werden, da dabei immer auch eine Prüfsumme berechnet wird. Mit der Software tar können die Daten aus einem ganzen Verzeichnis in einer Datei zusammengefasst werden, die mit gzip komprimiert und anschließend verschlüsselt werden kann.Beispielhafte Implementierung einer Arcfour-Variante
Im Vergleich zum Standard-Arcfour wird die Initialisierung mehrfach (11 mal) durchlaufen. Die Zustands-Variablen i,j starten mit dem Wert 7, statt 0. Die ersten 1023 Zufallswerte werden übersprungen. Die zufällig besetzte Variable j wird um das verschlüsselte Byte erhöht.
Trotz seiner Einfachheit kann das Programm kaum wesentlich verbessert werden. Die Berechnung ist extrem schnell, wesentlich schneller als die Datenübertragung. Da die Zufallswerte von der Nachricht abhängen, könnte ein Kennwort mehrfach verwendet werden. Maximale Sicherheit wird mit einem individuellen, in wenigen Details modifizierten, Programm erreicht, wenn diese Details geheim bleiben. Auf welchem Server im Netz die verschlüsselten Daten liegen und wie sie übertragen werden spielt keine Rolle. Mit dieser Software kann eine Ende-zu-Ende-Verschlüsselung mit maximaler Sicherheit erreicht werden und das zu geringen Kosten.
Das Programm kann mit praktisch jeden C-Compiler auf praktisch jedem Rechner, insbesondere mit dem GNU C-Comiler gcc unter Linux, übersetzt werden. Das Programm basiert auf Wikipedia.
/*
* compile: gcc rc4.c
* encrypt: cat data.dat | ./a.out secretX > data.crypt
* decrypt: cat data.crypt | ./a.out secretX D > data.copy
*/
#include <stdio.h>
#include <string.h>
unsigned 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) {
int nrepeat;
for (nrepeat=0; nrepeat<11; nrepeat++){
for (i = j = 0; i < 256; i++) {
j = (j + key[i % key_length] + S[i]) & 255;
swap(S, i, j);
}
}
}
/* 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];
}
int main(int narg, char **argv) {
int c, k;
int out;
unsigned char key[] = "Secret1234X"; // key hardcoded to "Secret"
for (i = 0; i < 256; i++)
S[i] = i;
if (narg == 1){
rc4_init(key, 6 + 5); // length of key is 6 in this case
} else {
rc4_init("Pass1", strlen("Pass1"));
rc4_init(argv[1], strlen(argv[1]));
rc4_init("Pass2", strlen("Pass2"));
}
i = j = 7;
/* skip 1023 bytes */
for(k=0; k < 1023; k++) rc4_output();
while ( (c = fgetc(stdin)) != -1) {
out = c ^ rc4_output();
printf("%c", out);
if (narg > 2){
j = (j + out) % 256;
}
if (narg == 2){
j = (j + c) % 256;
}
}
}
Es folgt eine weitere Varainte von Arcfour. Hier wird zweifach verschlüsselt, zusätzlich mit der Originalversion von Arcfour. Als
Schlüssel wird hier die S-Box aus der ersten Variante benutzt.
/*
* compile: gcc arc4.c
* encrypt: cat data.dat | ./a.out secretX > data.crypt
* decrypt: cat data.crypt | ./a.out secretX D > data.copy
*/
#include <stdio.h>
#include <string.h>
unsigned char S[256];
unsigned int i, j;
unsigned char S_00[256];
unsigned int i_00, j_00;
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) {
int nrepeat;
for (nrepeat=0; nrepeat<11; nrepeat++){
for (i = j = 0; i < 256; i++) {
j = (j + key[i % key_length] + S[i]) & 255;
swap(S, i, j);
}
}
i = j = 7;
}
/* KSA */
void rc4_init_00(unsigned char *key, unsigned int key_length) {
int nrepeat;
for (i_00=0; i_00<256 ; (i_00)++)
S_00[i_00] = i_00;
for (i_00 = j_00 = 0; i_00 < 256; (i_00)++) {
j_00 = (j_00 + key[i_00 % key_length] + S_00[i_00]) & 255;
swap(S_00, i_00, j_00);
}
i_00 = j_00 = 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];
}
/* PRGA */
unsigned char rc4_output_00() {
i_00 = (i_00 + 1) & 255;
j_00 = (j_00 + S[i_00]) & 255;
swap(S_00, i_00, j_00);
return S_00[(S_00[i_00] + S_00[j_00]) & 255];
}
int main(int narg, char **argv) {
int c, k;
int out;
unsigned char key[] = "Secret1234X"; // key hardcoded to "Secret"
for (i = 0; i < 256; i++)
S[i] = i;
if (narg == 1){
rc4_init(key, 6 + 5); // length of key is 6 in this case
} else {
rc4_init("Pass1", strlen("Pass1"));
rc4_init(argv[1], strlen(argv[1]));
rc4_init("Pass2", strlen("Pass2"));
}
/* skip 1023 bytes */
rc4_init_00(S, 256);
for(k=0; k < 1023; k++) rc4_output();
while ( (c = fgetc(stdin)) != -1) {
out = c ^ rc4_output() ^ rc4_output_00();
printf("%c", out);
if (narg > 2){
j = (j + out) % 256;
}
if (narg == 2){
j = (j + c) % 256;
}
}
}
Download rc4.c
Eine Variante kann hier heruntergeladen werden: arc4.cubuntu@ubuntu:~$ sha1sum rc4.c aa4e0edec3ad925cd5c75be71ffb8f6d025b350c arc4.c ubuntu@ubuntu:~$ gcc rc4.c ubuntu@ubuntu:~$ cat rc4.c | ./a.out pw123 > r ubuntu@ubuntu:~$ cat r | ./a.out pw123 D > rc4.copy ubuntu@ubuntu:~$ diff rc4.c rc4.copy ubuntu@ubuntu:~$ gzip rc4.copy ubuntu@ubuntu:~$ ls -l arc4.c* -rw-r--r-- 1 ubuntu ubuntu 1590 2011-03-15 15:53 rc4.c -rw-r--r-- 1 ubuntu ubuntu 692 2011-03-17 17:58 rc4.copy.gz ubuntu@ubuntu:~$ gzip r ubuntu@ubuntu:~$ ls -l r.gz -rw-r--r-- 1 ubuntu ubuntu 1615 2011-03-17 17:58 r.gz
Externer Link
Externer Link (Javascript)
Iaktueller.de übernimmt keine Haftung für externe Links. Franz Scheerer, Fritz-Philippi-Straße 34, 65195 Wiesbaden, Tel. 0611 168 93 98, scheerer.software@gmail.com