Eigene Variante der XOR-Verschlüsselung - sicher?

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