Sicherheit einer einfachen XOR Verschlüsselung

[st0rmy_w4ters]

Also ich habe vor kurzem begonnen mich in den Verschiedenen Verschlüsselungs möglichkeiten einzulesen und mich zu informieren.

Ich habe folgendes Programm geschrieben:

#include <string>
#include <iostream>
#include <stdio.h>
using namespace std;


int main()
{int encrypted[400];
char a[4000],b[400000],c[400000];


int i;



cout<<"Bitte zu Verschlüsselnden Text eingeben"<<endl;

  cin.getline (a,256);

cout<<"Bitte key eingeben"<<endl;
  cin.getline (b,256);
strcat(c,b);

for(i=strlen(b);i<strlen(a);i=strlen(b))
{


strcat(b,c);// Wi gesagt hatte das prog nur schnell geschrieben , Buffer Overflow schutz ist nicht gemacht...

}
printf(" ----------------------\n The Key is : %s \n-----------------------",b);

printf("\n\n\nDEC plain:\n\n\n");
for(int i=0;i<strlen(a);i++)
{
  encrypted[i] = a[i] ; 

printf("%i ",encrypted[i]);
}

printf("\n\n\nVerschlüsselt\n\n\n");

for(int i=0;i<strlen(b);i++)
{
  encrypted[i] = a[i]^b[i] ; 
printf("%i ",encrypted[i]);
}//encryptet bekommt den Wert von

printf("\n");

printf("Decimal Plain decryptet: ");
for(int i=0;i<strlen(a);i++)
{int newd[4000];
 
newd[i] = encrypted[i] ^ b[i] ; 
  
printf("%d ",newd[i]);
}



return 0;
}

Das Programm verknüpft die Bits des Keys mit XOR mit den Bits des Textes.

Meine Frage ist nun wie sicher dieser enfache Xor ist .
Hält das Programm der Krytoanalyse stand oder ist es wegen der aneinandereihung der Keys möglich Häufigkeiten zu analysieren?

Danke

PS:Kennt jemand ein Kryptographie Forum ?

 

[Grafix]

Original von st0rmy_w4ters
Hält das Programm der Krytoanalyse stand oder ist es wegen der aneinandereihung der Keys möglich Häufigkeiten zu analysieren?

Wenn der Schlüssel genau so groß ist wie der Klartext (OneTimePad), ist es AFAIK sicher.
Ansonsten sinkt die Sicherheit damit, dass der gleiche Key linear mehrmals benutzt wird.
Bei einem sehr kleinen Schlüssel im Vergleich zum Klartext lässt sich die Länge des Schlüssels statistisch ermitteln und u.U. der Schlüssel selbst. Dies hängt wiederum stark vom Klartext ab, was Häufigkeiten und teilweise bekannte Geheimnisse angeht.
Wenn Schlüssel und Klartext absolut zufällig sind, reicht auch 1 Byte für den Schlüssel (Wobei ein zufälliger Klartext wohl nicht schützenswert ist).

PS: Wenn du dich von der Sicherheit des Verfahrens selbst überzeugen möchtest, kann ich dir CryptTool empfehlen. Es bietet programmgestützte Cryptoanalyse.

 

[st0rmy_w4ters]

Danke für deine Antwort .:

Bei einem sehr kleinen Schlüssel im Vergleich zum Klartext lässt sich die Länge des Schlüssels statistisch ermitteln und u.U. der Schlüssel selbst. Dies hängt wiederum stark vom Klartext ab, was Häufigkeiten und teilweise bekannte Geheimnisse angeht.

Was ist deiner Meinung nach sehr klein?
1:25,1:100,1:1000?

Nehmen wir einen typischen deutschen Text und sagen wir man weiß auch das er mit
"Sehr geehrter" anfängt dann wäre es doch schon möglich das passwort auszulesen wenn es kürzer als "Sehr geehrter" ist , oder?

Danke


EDIT:\\
Was ich jetzt noch wissen wollte: wieviel Text man braucht um dieses lineare aneinanderhängen der Strings zu erkennen und einen erfolgreichen Angriff durchzuführen?

OK das mit dem "Sehr geehrter" kann man wirklich "Knacken":

#include <string>
#include <iostream>
#include <stdio.h>
using namespace std;


int main()
{

int verschluesselt[4000]={39,0,27,6,75,2,28,17,13,1,0,14,23,89,60,0,1,6,75,12,11,19,0,29,16,28,4,10,84,1,18,7,75,12,10,0,69,22,29,5,69,27,7,21,83,0,14,29,13,84,31,6,25,75,14,23,21,6,24,17,5,69,15,27,11,83,44,36,55,121};
int schluessel[4000];
int worte[4000]={83,101,104,114,32,103,101,101,104,114,116,101,114};

long i;


char key[4000];







for(long i=0;i<13;i++)
{
schluessel[i]=verschluesselt[i]^worte[i];
key[i]=schluessel[i];
cout<<key[i];
}
cout<<"\n"<<endl;




return 0;
}