Cryptage de fichier avec la fonction xor sur n bits

Soyez le premier à donner votre avis sur cette source.

Snippet vu 12 679 fois - Téléchargée 30 fois

Contenu du snippet

Ce code sert a crypter un fichier donné vers un autre fichier cible donné et avec une clef de la longueur que vous voulez(16 à inf bits).
exemple : $cdxor source.txt crypter.txt key
Comme il s'agit d'un cryptage xor, il suffit de faire l'inverse pour decrypter.
exemple : $cdxor crypter.txt source.txt key

Ce cryptage est incassable si la clef est aussi longue (ou plus longue mais seul une partie sera utilisée) que le message (fichier) à coder (cas parfait) et est très dur à casser si la clef est tres longue (se repete le moins possible, car un caractere de la clef code la taille d'un caractere de la source, donc la clef est réutilisée comme ecrite sur un anneau).

Cependant il est possible (mais tres dur) de cracker une clef si on connait le type de fichier (structure identique pour tout les mp3 par exemple), alors evitez de mettre l'extention du fichier source au fichier crypté pour plus de sécurité.

Je n'ai pas géré les erreurs comme celle d'ouverture de fichier car je l'ai codé assez vite...
Mais je vous laisses le faire ;-)

Voila, je suis ouvert a tout commentaires ou toutes questions.
Cryptez bien! :-)

Source / Exemple :


#include <fstream>
#include <iostream>

using namespace std;

void edxor(char*scrfile,char*codfile,char cKey[])
{
	int cpt=0,curs=0,length,pos=0;
	char * buffer;
	bool go=true;

	//j'ouvre les deux fichiers source et destination
	fstream In(scrfile,ios::in|ios::binary);
	fstream Out(codfile,ios::out|ios::binary);

	//je recupere la taille du fichier source
	In.seekg (0, ios::end);
	length = In.tellg();
	In.seekg (0, ios::beg);

	//gestion affichage
	if(length<40)go=false;

	//j'alloue la memoire de la taille du fichier
	buffer = new char [length];

	//je met tout le fichier dans le buffer
	In.read (buffer,length);
	In.close();

	//gestion affichage
	cout<<"0%                50%               100%\n";

	//boucle qui va effectuer sur chaque caractere le xor
	//avec le caractere correspondant de la clef
	while(cpt<length)
	{
		buffer[cpt++]^=cKey[curs++];
		if(curs>=strlen(cKey))
			curs=0;

		//gestion affichage
		pos++;
		if(go)if(pos>=(length/40))
		{
			cout<<"#";
			pos=0;
		}
	}

	//gestion affichage
	if(!go)cout<<"#########################################";

	//j'ecrit le buffer qui a subit le xor dans le fichier de destination
	Out.write (buffer,length);
	Out.close();
} 

//$>cdxor infile outfile key
int main(int argv,char ** argc)
{
	//test des arguments
	if(argv!=4)
		cout<<"$>cdxor infile outfile key";
	else
	{
		cout<<"       Cryptage xor par B.RENEL\n";
		edxor(argc[1],argc[2],argc[3]);
	}
	return 0;
}

Conclusion :


Le code se compile avec n'importe quel compilo C++ comme g++ par exemple.

A voir également

Ajouter un commentaire

Commentaires

Messages postés
3006
Date d'inscription
dimanche 14 avril 2002
Statut
Membre
Dernière intervention
31 décembre 2008

Oui, en effet coucou, merci pr la rectification tt à fait pertinente.
Messages postés
12303
Date d'inscription
mardi 10 février 2004
Statut
Modérateur
Dernière intervention
30 juillet 2012
35
un cryptage basé sur le caractère secret d'un algo, ça ne tient pas la route. les allemands en ont fait les frais pendant la seconde guerre mondiale avec enigma...

pour kirua, je suposes que tu dois le savoir, mais ton message tend au kiproko...

un cryptage symétrique n'est pas un cryptage qui a le même algorythme pour crypter et décrypter, mais un cryptage qui utilises la même clef pour crypter et décrypter...

EX : pour DES et AES, pour crypter et décrypter, on fait les mêmes choses, mais pas dans le même ordre, donc les algos sont diférents, mais les clefs sont les mêmes, donc symétrique...

pour RSA, les clefs sont diférentes, mais l'algo est le même :
pour un couple de clefs (a,b) (RSA c'est deux clefs)
on a messagecode=message exposant a modulo de b...

que ce soit pour crypter ou pour décrypter...

car pour crypter, on utilises (d,n) et pour décrypter (e, n)

enfin, je suis hors sujet par raport à la source...



ce que tu peux faire pour modifier XOR :

pour une clef de 128 :
tu mets les huit premiers bits de coté, ils te donne un nombre entre 0 et 8 (si tu fais une adition, on peut inverser les bits, ça ne changer rien, alors que si tu les prends dans l'ordre, pour celui qui trouve la taille de la clef, c'est cassable), ça te donne combien de bits de clefs tu peux utiliser avant de prendre encore huit bits de clefs pour refaire la même chose... je n'ai fais aucun calculs sur le sujet, mais utiliser certaines parties de la clef comme ceci rendraient le cassage soit plus simple (eh oui, je ne suis pas expert en math... je peux me tromper (et me trompe souvent)... ) , soit réduit à un simple bruteforce (qui serait alors bcp plus long...)
Messages postés
12
Date d'inscription
vendredi 27 décembre 2002
Statut
Membre
Dernière intervention
30 mars 2005

merci kirua
et desolé, je navais pas compris ce que tu voulais exactement.

TeLeTUbIz : oui c vrai que pour les gros fichier ça pose probleme...

mais bon, à ce stade, si quelqu'un est inspiré pour nous montrez comment craquer un fichier crypter ainsi avec une clef entre 15 et 20 caracteres (> a 256 bits si je ne me trompe) on verrais deja qu'il faut du beaucoup de code et surtout ... du temps!!!
Messages postés
3006
Date d'inscription
dimanche 14 avril 2002
Statut
Membre
Dernière intervention
31 décembre 2008

bah le xor est symétrique, c'est le même algo pr rypter et décrypter.
Messages postés
31
Date d'inscription
jeudi 19 février 2004
Statut
Membre
Dernière intervention
29 mai 2005

Ça serait bien un décrypteur :)
Afficher les 10 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.