[ Parce-que XOR le vaut bien ]

[shirocen]

Bonjour,

Deux petites fonctions pour crypter et décrypter à l'aide de la porte logique XOR :

fonctions.c :

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

void XORcrypt(const char *message, char *ENCmessage) {

	int i = 0;

	for(;i<strlen(message);i++) {

		ENCmessage[i] = message[i] ^ 0xff;
	}

	ENCmessage[i] = '\0';

}

void XORdcrypt(const char *ENCmessage, char *DECmessage) {

	int i = 0;

	for(;i<strlen(ENCmessage);i++) {
		
		DECmessage[i] = ENCmessage[i] ^ 0xff;
	}

	DECmessage[i] = '\0';

}

main.c :

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "fonctions.h"

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

	char *message = "Be or not te be";

	char *ENCmessage = malloc(strlen(message) * sizeof(char));

	char *DECmessage = malloc(strlen(message) * sizeof(char));
	
	XORcrypt(message,ENCmessage);	

	printf("\n\n cipher : %s \n\n",ENCmessage);

	XORdcrypt(ENCmessage,DECmessage);

	printf("\n\n decipher : %s \n\n",DECmessage);

	free(ENCmessage);
	free(DECmessage);
		
	return 0;
}

Bon c'est vraiment pas grand chose mais j'espère améliorer le code et SURTOUT le cryptage..

J'aurais besoin de votre aide pour ajouter des méthodes de chiffrements simples et symétriques pour le moment, n'hésitez

pas non plus si vous avez des remarques à faire au niveau du code .

[fred]

Bon c'est vraiment pas grand chose mais j'espère améliorer le code et SURTOUT le cryptage..

Le XOR n'est pas une opération de bit à bit ? Je ne vois pas cette opération...

Pour moi le XOR c'est une fonction (exemple avec python) simple de comparaison bit à bit

def xor(a, b):
    """a et b représentent un bit 1 ou 0"""
    if a != b:
        return 1
    return 0

Ce qui veut dire que pour un caractère d'une chaîne, il faut avoir sa représentation binaire

def charTobin(char):
    c = ord(char) # équivalent à la valeur du type char en C
    if c in range(256):
        binary = bin(c)
        b = binary.split('b') # car en python, il y a un caractère b qui nous embête
        return ''.join(b)# résultat du binaire d'un caractère

Exemple pour le caractère a

01100001

Ensuite, autre question, ne faut-il pas une clé lorsqu'on fait de la cryptographie symétrique ?

Voilà je suis pas certains de tout comprendre... Merci d'avance pour les explications, et pour tes éclaircissement en crypto, car pour le reste je pense m'en sortir

[Anonyme77]

Fred, je pense que son & fera l'opération bit à bit avec la valeur hexa qu'il a donnée. Ça sortira donc une nouvelle valeur entière qui peut être interpretée comme un char.
En fait implicitement sa clef symétrique est 0xff.
De là viens mon point de vue qui est que grâce au code que tu viens de nous donner, je peux décrypter tous les messages que tu as crypté avec.
Ne devrais donc tu pas ajouter la clef comme un paramètre à tes fonctions ?

[fred]

En fait implicitement sa clef symétrique est 0xff

Justement, ne devrait-elle pas être choisie aléatoirement ?

Fred, je pense que son & fera l'opération bit à bit avec la valeur hexa qu'il a donnée.

Ok c'est dommage qu'il manque cette petite partie algorithmique

[shirocen]

Merci pour vos réponses !

Au début je pensais simplement à de l'obfuscation et pas vraiment à du cryptage avec une clé etc..

On pourrait améliorer ce code en y ajoutant une clé comme l'a mentionné Anon, mais là, si l'on veut un niveau correct de cryptage

il va falloir trouver une clé un peu plus longue que 8 bits

Je vais réfléchir à la chose, n'hésitez pas à proposer vos idées.

On aurait un truc dans le genre :

fonctions.c :

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

void XORcrypt(const char *message, char key, char *ENCmessage) {

	int i = 0;

	for(;i<strlen(message);i++) {

		ENCmessage[i] = message[i] ^ key;
	}

	ENCmessage[i] = '\0';

}

void XORdcrypt(const char *ENCmessage, char key, char *DECmessage) {

	int i = 0;

	for(;i<strlen(ENCmessage);i++) {
		
		DECmessage[i] = ENCmessage[i] ^ key;
	}

	DECmessage[i] = '\0';

}

main.c :

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "fonctions.h"

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

	char key = 0xda;

	char message[] = "Be or not te be";

	char *ENCmessage = malloc(strlen(message) * sizeof(char));

	char *DECmessage = malloc(strlen(message) * sizeof(char));
	
	XORcrypt(message,key,ENCmessage);	

	printf("\n\n cipher : %s \n\n",ENCmessage);

	XORdcrypt(ENCmessage,key,DECmessage);

	printf("\n\n decipher : %s \n\n",DECmessage);

	free(ENCmessage);
	free(DECmessage);
		
	return 0;
}

[Anonyme77]

Tu pourrais prendre une clef plus longue et xorer chacun des bits de ton message avec tout ceux de ta clef. Dans un ordre que tu définis toi même.
Genre le premier avec le premier puis tous les autres puis le deuxième avec tous les suivants aussi + le premier ,...
The Sky is the limit

Ou faire la même chose mais avec une technique proche de Vigenere.

[shirocen]

Je dois dire qu'avec une clé variable, sa commence à prendre de la gueule :

fonctions.c :

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

void XORcrypt(const char *message, char *key, char *ENCmessage) {

	int i = 0,j = 0;

	for(;i<strlen(message);i++,j++) {

		if(j == strlen(key))
			j = 0;
		ENCmessage[i] = message[i] ^ key[j];
	}

	ENCmessage[i] = '\0';

}

void XORdcrypt(const char *ENCmessage, char *key, char *DECmessage) {

	int i = 0,j = 0;

	for(;i<strlen(ENCmessage);i++,j++) {
		
		if(j == strlen(key))
			j = 0;
		DECmessage[i] = ENCmessage[i] ^ key[j];
	}

	DECmessage[i] = '\0';

}

main.c :

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "fonctions.h"

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

	char cle[] = "mais ou est donc or ny car";

	char message[] = "le lapin est dans la taniere je repete le lapin est dans la taniere";

	char *ENCmessage = malloc(strlen(message) * sizeof(char));

	char *DECmessage = malloc(strlen(message) * sizeof(char));
	
	XORcrypt(message,cle,ENCmessage);	

	printf("\n\n cipher : %s \n\n",ENCmessage);

	XORdcrypt(ENCmessage,cle,DECmessage);

	printf("\n\n decipher : %s \n\n",DECmessage);

	free(ENCmessage);
	free(DECmessage);
		
	return 0;
}

terminal :

[email protected]:~/Bureau/XOR$ ./a.out 

 cipher : IANETD
IEOE 



 decipher : le lapin est dans la taniere je repe

Le problème qu'on a est de gérer le le cas message[i] XOR key[j] = 0x00, du coup on a un message coupé comme ci-dessus parce-qu'en C

le 0 délimite la fin d'une chaîne de caractères.

Je fais un essai avec une clé que je caste en int(4octets)

[fred]

if(j == strlen(key))
		j = 0;

Utilises plutôt l'opérateur modulo (%)

[shirocen]

Utilises plutôt l'opérateur modulo (%)

Pas compris

[fred]

Le modulo évite le reset à j=0

>>> for i in range(10):
...     print(i%3)
... 
0
1
2
0
1
2
0
1
2
0

Voilà mon code

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char * encrypt(const char * message, const char * key);

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

    const char * message = "le lapin est dans la taniere je repete le lapin est dans la taniere";
    const char * key = "mais ou est donc or ny car";

    char * crypt_message = encrypt(message, key);
    printf("%s\n", crypt_message);

    free(crypt_message);

    return 0;
}

char * encrypt(const char * message, const char * key) {

    int i;

    size_t len_message = strlen(message);
    size_t len_key = strlen(key);

    char * result = malloc(len_message + 1);

    for(i = 0; i < len_message; i++)
        result[i] = message[i] ^ key[i % len_key]; /* voilà le modulo */

    result[len_message] = '\0';

    return result;
}

[shirocen]

Eh bien fred', tu m'impressionneras toujours, très belle simplification, SUPERBE !

[fred]

Eh bien fred', tu m'impressionneras toujours, très belle simplification, SUPERBE !

Merci ! J'ai eu un doute sur le fait que tu souhaitais une fonction pour crypter, car au départ tu parles bien de cryptographie, mais dans ton code, tu ne donnais pas de clé... Et j'ai vu aussi chiffrement symétrique, qui impose une clé.

[shirocen]

Prochaines étapes, utiliser une clé sur 4 octets(int), compiler sans warnings -Wall

[fred]

Prochaines étapes, utiliser une clé sur 4 octets(int), compiler sans warnings

Pourquoi ? Le compilateur s'occupe d'optimiser ton code au maximum, si tu souhaite l'optimiser plus, tu peux utiliser gcc avec l'option -O3...

[shirocen]

J'entendais par là augmenter la robustesse de la clé qui n'est codé que sur 1 octet(char)

J'aimerais utiliser un int pour avoir un clé un peu plus "forte"

Un petit aperçu :

int key = 0xbeef;

char *p = &((char)key);

message[i] ^ p % 4;

p++;

...

Le code complet :

fonctions.c :

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

void XORcrypt(const char *message, int *key, char *ENCmessage) {

	int i = 0,j = 0;

	char *p = key;

	for(;i<strlen(message);i++,j++) {

		ENCmessage[i] = message[i] ^ p[j % 4];
	}

	ENCmessage[i] = '\0';

}

void XORdcrypt(const char *ENCmessage, int *key, char *DECmessage) {

	int i = 0,j = 0;

	char *p = key;

	for(;i<strlen(ENCmessage);i++,j++) {
		
		DECmessage[i] = ENCmessage[i] ^ p[j % 4];
	}

	DECmessage[i] = '\0';

}

main.c :

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "fonctions.h"

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

	int cle = 0xbeef;

	char message[] = "le lapin est dans la taniere je repete le lapin est dans la taniere";

	char *ENCmessage = malloc(strlen(message) * sizeof(char));

	char *DECmessage = malloc(strlen(message) * sizeof(char));
	
	XORcrypt(message,&cle,ENCmessage);	

	printf("\n\n cipher : %s \n\n",ENCmessage);

	XORdcrypt(ENCmessage,&cle,DECmessage);

	printf("\n\n decipher : %s \n\n",DECmessage);

	free(ENCmessage);
	free(DECmessage);
		
	return 0;
}

J'ai un warning à cause du pointeur de type char sur l'int donc on cast pour faire plaisir à GCC :

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

void XORcrypt(const char *message, int *key, char *ENCmessage) {

	int i = 0,j = 0;

	char *p = (char*)key;

	for(;i<strlen(message);i++,j++) {

		ENCmessage[i] = message[i] ^ p[j % 4];
	}

	ENCmessage[i] = '\0';

}

void XORdcrypt(const char *ENCmessage, int *key, char *DECmessage) {

	int i = 0,j = 0;

	char *p = (char *)key;

	for(;i<strlen(ENCmessage);i++,j++) {
		
		DECmessage[i] = ENCmessage[i] ^ p[j % 4];
	}

	DECmessage[i] = '\0';

}

Le C, c'est quand même vachement libre.