Eigene Variante der XOR-Verschlüsselung - sicher?

lagalopex

sothis_ schrieb:

CodeOriginator schrieb:

lagalopex schrieb:

Sehr unsicher, da der Schlüssel gerademal 8bit sind. Wobei der ja sogar das letzte byte in der datei ist.

Warum ist das sehr unsicher? Die jeweiligen Schlüssel sind zwar nur 8 Bit breit, aber dafür enthält eine Datei so viele Schlüssel, wie diese in Bytes groß ist.
Und warum ist der Key nur das letzte Byte der Datei? Ich denke, Du hast da einen kleinen Denkfehler reingebracht.

würdest du darauf geld verwetten? kann ich in diesem fall bitte mal eine beispieldatei haben?

hehe, hab jetzt iwie das "SCNR" vermisst
Aber schon fies... ist ja nur unkenntlich gemacht. ansich ist das ja nichtmal ne verschlüsselung ^

Aber man kann ja das letzte Byte auch noch mal mit xor mit einen key verschlüsseln. Man sollte auch das ganze auf 64 oder noch besser mehr bit grosse Blöcke umbauen.

sothis_

lagalopex schrieb:

hehe, hab jetzt iwie das "SCNR" vermisst

eigentlich war das ernst gemeint

CodeOriginator

filmor schrieb:

Mit diesem Schlüssel bekommst du alle "Schlüssel" auch heraus.

Ja, das stimmt... nur woher soll ein fremder wissen, dass jedes Byte einen Schlüssel darstellt?

Wenn du mal ein paar Varianten ausprobieren willst, dann verschlüssel einfach mal die Bilddaten in nem Bitmap (also ohne Header), wenn du dann immer noch so ungefähr erkennen kannst, was es darstellt, dann ist es nicht wirklich sicher.

Eine wirklich gute Idee. Werde ich probieren.

würdest du darauf geld verwetten? kann ich in diesem fall bitte mal eine beispieldatei haben?

Ich würde darauf keinen einzigen Cent verwetten, da es sich nicht um eine Verschlüsselung für dein praktischen Einsatz handelt, sondern reine Interesse daran. Aber das mit der Beispieldatei lasse ich mir natürlich nicht zweimal sagen:

hex:

2D 0C 16 16 0B 4E 73 32 15 0E 5A 57 1E 05

ASCII:

-Ns2ZW

Viel Spaß beim Entschlüsseln. (Mit lagalopex' Code verschlüsselt)

lagalopex

CodeOriginator schrieb:

Aber das mit der Beispieldatei lasse ich mir natürlich nicht zweimal sagen:

hex:
2D 0C 16 16 0B 4E 73 32 15 0E 5A 57 1E 05
ASCII:
-Ns2ZW
Viel Spaß beim Entschlüsseln. (Mit lagalopex' Code verschlüsselt)

Also würde dir 05 bleiben, und 05 xor 1e ist 1b... usw usf
28 05 09 1f 09 02 4c 3f 0d 18 16 4c 1b 05

Und wie gesagt, unkenntlich ja, verschlüsselt nein (dazu fehlt der geheime schlüssel).

Algo muss bekannt sein, alles andere ist sinnfrei, akzeptier es.

http://de.wikipedia.org/wiki/Kryptographie schrieb:

So formulierte Auguste Kerckhoffs von Nieuwenhof mit Kerckhoffs’ Prinzip einen Grundsatz der Kryptographie, nachdem die Sicherheit eines kryptographischen Verfahrens allein auf der Geheimhaltung des Schlüssels basieren soll – das Verfahren selbst muss also nicht geheim gehalten werden; im Gegenteil: es kann veröffentlicht und von vielen Experten untersucht werden.

char txt[] = {0x2D, 0x0C, 0x16, 0x16, 0x0B, 0x4E, 0x73, 0x32, 0x15, 0x0E, 0x5A, 0x57, 0x1E, 0x05, 0x0 };

	for(int c = 1; c<256;c++){
		int len = 14;
		char txt2[15];
		memcpy(txt2,txt,len+1);
		txt2[len-1]=c;
		bool o=true;
		for (int j = len-1; j >= 0; --j) {
			txt2[j] ^= txt2[j + 1]; 
			if(txt2[j]<20 || txt2[j]>180) o=false;
		}
		if(o)std::cout<<txt2;
		std::cout<<"\n";
	}

"Diesen Satz wi"

und den Rest hast du nicht gepostet

CodeOriginator

Algo muss bekannt sein, alles andere ist sinnfrei, akzeptier es.

Ich akzeptiere es doch, was stellst Du Dich so an? Ich wollte lediglich Meinungen und Erklärungen haben.

hingeschmiert schrieb:

"Diesen Satz wi"

Deine "Entschlüsselung" erfolgte letztendlich auf visueller Basis, indem du dir die entschlüsselten Fragmente angeguckt, und diese als entschlüsselt deklariert hast. Aber wie würde die Entschlüsselung auf maschineller Basis aussehen, sodass also der Computer feststellt, ob der Text entschlüsselt ist?

Nochmal zur Klarstellung, ich verteidige hier keinesfalls die Idee mit der XOR-Verschlüsselung, und mir ist durchaus bewusst, dass es sich lediglich um eine "Unkenntlichmachung" handelt. Ich möchte lediglich in Erfahrung bringen, ob und wie die mit diesem Verfahren verschlüsselten Daten entschlüsselt werden können.

.filmor

Indem man den Algorithmus kennt

Zur Not macht man's wie oben irgendwo erwähnt, man reverse-engineert (gibt's dazu ein deutsches Wort? Rückentwickelt?) deinen Dekoder.
Klar, simple Knackmethoden funktionieren nicht (also auf Buchstabenhäufigkeit oder Struktur schauen (zumindest nach meinem Wissensstand, der hierfür aber doch sehr begrenzt ist)).

Was du da machst ist eher ein Prüfsummenverfahren.

CodeOriginator schrieb:

hingeschmiert schrieb:

"Diesen Satz wi"

Deine "Entschlüsselung" erfolgte letztendlich auf visueller Basis, indem du dir die entschlüsselten Fragmente angeguckt, und diese als entschlüsselt deklariert hast. Aber wie würde die Entschlüsselung auf maschineller Basis aussehen, sodass also der Computer feststellt, ob der Text entschlüsselt ist?

Nochmal zur Klarstellung, ich verteidige hier keinesfalls die Idee mit der XOR-Verschlüsselung, und mir ist durchaus bewusst, dass es sich lediglich um eine "Unkenntlichmachung" handelt. Ich möchte lediglich in Erfahrung bringen, ob und wie die mit diesem Verfahren verschlüsselten Daten entschlüsselt werden können.

XOR Verschlüsselung ist gut und eine richtige Verschlüsselung, wenn man einen langen Schlüssel nimmt, nur bei einer Methode gibt es nur 256 Möglichkeiten und die kann man sich schnell mal anschauen.
Wikipedia: Kryptoanalyse

sothis_

CodeOriginator schrieb:

Deine "Entschlüsselung" erfolgte letztendlich auf visueller Basis, indem du dir die entschlüsselten Fragmente angeguckt, und diese als entschlüsselt deklariert hast. Aber wie würde die Entschlüsselung auf maschineller Basis aussehen, sodass also der Computer feststellt, ob der Text entschlüsselt ist?

wie der vorposter schon erwähnt hat, ist der erste schritt den algorithmus, wenn er nicht bekannt ist, herauszufinden. dies funktioniert am einfachsten wenn man einen gültigen schlüssel, einen damit verschlüsselten ciphertext und den dazugehörigen plaintext besitzt, welches immer der fall ist wenn die verschlüsselung öffentlich gemacht wird (die software also vertrieben wird). dann benötigt man mit einem disassembler in der regel nicht lange den algortihmus zu rekonstruieren. das wohl bekannteste beispiel ist der CSS algorithmus mit dem video-dvd daten verschlüsselt werden. dieser algorithmus wurde auch geheim gehalten, hat aber auch nichts genützt ;). nichtzdestotrotz, an dieser stelle angelangt, geht es dann los die schwächen des algorithmus zu analysieren oder ggf mit brute-force (wie im obigen beispiel) den eigentlichen angriff zu starten

lagalopex

Achja... man kann einfach den algo durchlaufen lassen und dann den schlüssel wie mit einem statischen 1-byte-key suchen.

drakon

Für Cryptointeressierte, gibt es Cryptool

http://www.cryptool.org/content/view/5/30/lang,de/

Einfach laden und lernen.

Hab mal folgendes getestet

#include <vector>
#include <iostream>
#include <string>
#include <fstream>

int main(int argc, char** argv) {

	std::string filename("c:\\test.bmp");
	std::string filenameout("c:\\testout.bmp");
	std::string filenameout2("c:\\testout2.bmp");
	std::ifstream file(filename.c_str(), std::ios::in | std::ios::binary);
	file.seekg(0, std::ios::end);
	size_t size = file.tellg();
	file.seekg(0, std::ios::beg);
	std::vector<char> bytes(size);

	std::string pw("4378QWERTZXCDFÄÖÜÖ234äö!%&GBFdäöäö+~rwerqWEF€~weasd4tdfjkvn8734rwelhf!2²32@sadaFDgfUZ65%4325fdg*'_:;!§!§vBZ/8/$3§sdf$dsf&");

	size_t p=0;
	file.read(&bytes[0],size);
	for(size_t b=100; b<size; b++) {
		p++;
		p%=pw.length();
		bytes[b]^=pw[p];
	}

	std::ofstream outfile(filenameout.c_str(), std::ios::out | std::ios::binary);
	outfile.write(&bytes[0],size);

	std::string pw2("DFerhzER§$5ger§%werfweFWEF§$C§$&jbti834@wdre");
	size_t p2=0;
	file.read(&bytes[0],size);
	for(size_t b=100; b<size; b++) {
		p++;
		p%=pw.length();
		p2++;
		p2%=pw2.length();
		bytes[b]^=pw[p];
		bytes[b]^=pw2[p2];
		bytes[b]^=pw2[(p+p2)%pw2.length()];
		bytes[b]^=p+p2^b*p2^b>>p;
	}

	std::ofstream outfile2(filenameout2.c_str(), std::ios::out | std::ios::binary);
	outfile2.write(&bytes[0],size);

	return 0;
}

Das erste verschlüsselte Bild ist etwas verrauscht, aber man es kann man immer noch gut erkennen.
Das zweite ist nur noch buntes rauschen, wobei vorallem die letzte Zeile

bytes[b]^=p+p2^b*p2^b>>p;

alles unkenntlich macht. Warum? Und wäre das leicht zu analysieren und entschlüssen, wenn man das Passwort nicht kennt?

sothis_

diese variante ist eine etwas härtere nuss da du aber in 100-byte blöcken verschlüsselst und dies auch byte für byte unabhängig vom nachfolger im plaintext, lässt sich der schlüssel ggf. schon mit ein paar bekannten bytes des plaintextes rekonstruieren.
es kommt aber schon der one-time-pad verschlüsselung sehr nahe. wenn du deinen schlüssel mindestens genauso lang wie deinen plaintext wählst, und dieser entprechend zufällig ist, bräuchtest du noch nicht einmal diese zusätzlichen crippling funktionen und kannst auch sehlenruhig byte für byte abarbeiten