Annonce

**shirocen** · 09 mai 2016, 20h32

L'int à son apogée :

fonctions.c :

Code:

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

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

	int i = 0,j = 0;

	char p[1024];

	sprintf(p, "%lld", key);

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

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

	ENCmessage[i] = '\0';

}

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

	int i = 0,j = 0;

	char p[1024];

	sprintf(p, "%lld", key);

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

	DECmessage[i] = '\0';

}

main.c :

Code:

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

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

	long long int cle = 0xdeadbeefabcdabcd;

	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 :

Code:

[email protected]:~/Bureau/XOR$ gcc -Wall fonctions.c main.c 
[email protected]:~/Bureau/XOR$ ./a.out 


^UEQ[[email protected] DT]DWFUZP_WDUEU_HXQAY[[email protected]UQ[@



 decipher : le lapin est dans la taniere je repete le lapin est dans la taniere 

[email protected]:~/Bureau/XOR$

Voili voilou

Une clé sur 64 bit !

2^64 --> 1.845 * 10 ^ 19 clés possibles.

Va falloir trouver quelque chose de mieux !

**shirocen** · 15 mai 2016, 10h02

Dans notre code précédent la taille de la clé était trop faible, 64 bit, j'ai donc décidé d'utiliser un "tableau de clé" pour améliorer un peu plus le chiffrement /

fonctions.c :

Code:

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

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

	int i = 0,j = 0;

	char p[1024];

	sprintf(p, "%lld%lld%lld", key[0],key[1],key[2]);

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

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

	ENCmessage[i] = '\0';

}

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

	int i = 0,j = 0;

	char p[1024];

	sprintf(p, "%lld%lld%lld", key[0],key[1],key[2]);

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

	DECmessage[i] = '\0';

}

main.c :

Code:

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

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

	long long int cle[] = {0xdeadbeefabcdabcd,0xdedeabcdffacabae,0xddeeffffabccccab};

	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;
}

Le prochain objectif serait d'avoir une clé ainsi qu'un message passés en paramètres, le programme ferait le reste !

N'hésitez pas à modifier le code ou même me faire part de vos remarques, je répondrais avec grand plaisir

Le but final étant de proposer un outil simple, rapide, efficace pour crypter toutes sortes de contenus à l'aide d'une clé au format décimal ou hexadécimal :

./Programme <clé> <fichier>

./Programme de5622aabc223ba565dac document.txt

./Programme 561465189416518541587458946459487149114623056198498948 document.txt ...

**rodrigue daniel** · 15 mai 2016, 19h53

Salut

Ma petite proposition dans la fonction main:

Code:

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

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

        int i;
        long long int cle;
        char message[];
        if(argc != 3){
                printf("Usage : %s cle message\n", argv[0]);
                exit(EXIT_FAILURE);
        }

	cle = argv[1];
	message = argv[2];

	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;
}

**shirocen** · 15 mai 2016, 20h02

Merci rodrigue..

**rodrigue daniel** · 16 mai 2016, 02h22

Salut

La dernière fois je n'avais pas vu qu'il s'agissait d'un fichier que l'on prenait en deuxième paramètre.
Bon voici ma deuxième proposition :

Code:

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

int getNbreCaracteresFichier(FILE*);
void setContenuMessage(char *, FILE *);

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

        FILE* fichierMessage = NULL;
        char *message = NULL;
        char* cle;

        if(argc != 3){
                printf("Usage : %s cle fichier\n", argv[0]);
                exit(EXIT_FAILURE);
        }

 	cle = argv[1];
	fichierMessage = fopen(argv[2], "r");

        if(fichierMessage != NULL){

               message = (char *)malloc(getNbreCaracteresFichier(fichierMessage) * sizeof(char));
               setContenuMessage(message, fichierMessage);

        } else {
                printf("Impossible d'ouvrir le fichier %s\n", argv[2]);
                exit(EXIT_FAILURE);
        }
        
	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);
        free(message);
        fclose(fichierMessage);
		
	return 0;
}

Code:

// Fonction permettant de compter le nombre de caractères dans un fichier

int getNbreCaracteresFichier(FILE *fichier){

        int nbreCarac = 0;

        while(fgetc(fichier) != EOF)
                nbreCarac++;

        return  nbreCarac;
}

Code:

// Fonction permettant de sauvegarder le contenu du fichier dans un tableau de caractères

void setContenuMessage(char *message, FILE *fichier){

        long int compteur = 0;
        while(fgetc(fichier) != EOF){
                message[compteur] = fgetc(fichier);
                compteur++;
        }
        message[compteur] = '\0';

}

**fred** · 16 mai 2016, 08h30

Envoyé par rodrigue daniel Voir le message

Salut

Ma petite proposition dans la fonction main:

Code:

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

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

        int i;
        long long int cle;
        char message[];
        if(argc != 3){
                printf("Usage : %s cle message\n", argv[0]);
                exit(EXIT_FAILURE);
        }

	cle = argv[1];
	message = argv[2];

	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;
}

Peux-tu essayer de compiler ce code ? Si tu n'as pas de problème, alors c'est que ton compilo est mal réglé...

Dans ce petit morceau de code qui représente une petite partie de ta fonction main, j'ai déjà 2 erreurs et 3 Warnings, ce qui est peu dire !

Code:

#include <stdio.h>

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

        long long int cle;
        char message[];

	cle = argv[1];
	message = argv[2];


	return 0;
}

En faisant cela correctement, voici la marche à suivre

Code:

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

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

    if (argc != 3)
        exit(EXIT_FAILURE);

    long long int cle = 0;
    char *message = NULL;
    int ret = 0;

	ret = sscanf(argv[1], "%lld", &cle);
	message = argv[2];

    if (message != NULL)
        printf("%s\n", message);

    if (ret > 0)
        printf("la clé est %lld \n", cle);

	return 0;
}

ou encore plus explicite sur ce qu'on fait

Code:

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

typedef struct{

    long long int cle;
    char *message;

} param;

param *init(char *c, char *s);

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

    if (argc != 3)
        exit(EXIT_FAILURE);

    param *value = init(argv[1], argv[2]);
    if (value == NULL) exit(EXIT_FAILURE);

    printf("ma cle est %lld et ma chaine est %s\n", value->cle, value->message);

    free(value);

    return 0;
}

param *init(char *c, char *s){

    int ret = 0;
    param *p = malloc(sizeof(param));

    if (c != NULL)
        ret = sscanf(c, "%lld", &(p->cle));

    if (ret <= 0 || s == NULL) return NULL;

    p->message = s;
    return p;
}

**rodrigue daniel** · 16 mai 2016, 11h21

Salut

C'était juste une erreur de saisie. Merci beaucoup pour la remarque Fred.
Je voulais plutôt faire

Code:

#include <stdio.h>

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

        char *cle;
        char *message;

        cle = argv[1];
        message = argv[2];
       
        return 0;
}

Merci Encore pour la remarque.

**fred** · 16 mai 2016, 15h34

Envoyé par rodrigue daniel Voir le message

Salut

C'était juste une erreur de saisie. Merci beaucoup pour la remarque Fred.
Je voulais plutôt faire

Code:

#include <stdio.h>

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

        char *cle;
        char *message;

        cle = argv[1];
        message = argv[2];
       
        return 0;
}

Merci Encore pour la remarque.

Dans ces cas là effectivement, il est inutile de transformer un type tableau de chars en long long int. Ce qui rend inutile aussi le type long long int dans le paramètre de la fonction XORcrypt ou XORdcrypt.

**rodrigue daniel** · 17 mai 2016, 11h57

Salut

Fred, c'est comme si on peut gérer le problème de long long int en utilisant plutôt ce code :

Code:

#include <stdio.h>

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

        char *message;
        long long int *cle;

        cle = (long long int *)argv[1];
        message = argv[2];


        return 0;
}

Tu ne trouves pas que c'est mieux ainsi. Bon peut être je me trompe.

MERCI

**shirocen** · 17 mai 2016, 17h21

Si je puis me permettre, je n'utiliserais pas le cast dans cette situation, même si cela paraît juste, je pense que l'utilisation

des fonctions sprintf ou sscanf est indispensable et que le cast d'un long long int et d'ailleurs le cast en général devrait être évité au maximum.

**fred** · 17 mai 2016, 18h49

Tout à fait shirocen !

Tu ne trouves pas que c'est mieux ainsi. Bon peut être je me trompe.

Eh bien maintenant oui, dans mon message précédent, je disais que conceptuellement parlant le fait de travailler directement avec les tableaux de chars était une bonne idée. Ce qui évite de travailler avec le type long long, dans la fonction XORcrypt ou XORdcrypt.

**rodrigue daniel** · 17 mai 2016, 19h49

Salut

Merci beaucoup les gars. J'ai vraiment appris quelque chose. Le fait d'éviter au maximun les opérations de cast.
En tout, si on conserve le type long long int alors Fred ton code est la meilleur (surtout celui avec sscanf). Mais
si on cherche à éviter ce type, alors il serait mieux de travailler avec les tableaux de char.

Merci encore les gars

**rodrigue daniel** · 17 mai 2016, 19h50

Salut

Merci beaucoup les gars. J'ai vraiment appris quelque chose. Le fait d'éviter au maximun les opérations de cast.
En tout, si on conserve le type long long int alors Fred ton code est la meilleur (surtout celui avec sscanf). Mais
si on cherche à éviter ce type, alors il serait mieux de travailler avec les tableaux de char.

Merci encore les gars

**shirocen** · 17 mai 2016, 20h03

Même si le C est un langange très libre, je pense qu'il est judicieux de privilégiez l'utilisation des librairies plutôt que faire des cast

qui peuvent overflow sur d'autres parties du code, les librairies proposent des fonctions pour gérer ces cas, et c'est plus propre.

Annonce

[ Parce-que XOR le vaut bien ]

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire

Commentaire