Ajout du code

tevrard
Showing 11 changed files with 615 additions and 0 deletions Show diff stats
Melodico
TheoEvrard_CR_TIM.pdf
imposteurs.ppm
inc/automatos.h
inc/stegano.h
inc/vigenere.h
makefile
src/automatos.c
src/main.c
src/stegano.c
src/vigenere.c
+++ a/inc/automatos.h
@@ -0,0 +1,7 @@
+int Parity_check(Image **I, int algo_tab[], int i, int j);
+void Parity_encode(Image **I, unsigned char *msg);
+void Parity_decode(Image **I, unsigned char *msg);
+void Change_LSB(unsigned char *x);
+void GetOneChar(unsigned char x, unsigned char *a, int i);
+void bit_in_tab(unsigned char *byte, int tab[]);
+uint8_t Get_msg_size(Image **I);
 \ No newline at end of file
+++ a/inc/stegano.h
@@ -0,0 +1,27 @@
+/* Structures permettant le stockage de l'image */
+typedef struct Pix_rgb
+{
+	unsigned char red;
+	unsigned char green;
+	unsigned char blue;
+} Pix_rgb;
+
+typedef struct Image
+{
+	int width;
+	int height;
+	Pix_rgb** Mat_data;
+} Image;
+
+
+
+/* Prototypes */ 
+void NouvelleImage(int width, int height, Image** I);
+void free_image(Image** I);
+void read_header(FILE * im_file, int *width, int *height);
+int sauvegarde_ppm(char* fichier, Image** I);
+int chargement_ppm(char *image_name, Image** I);
+void GetPartChar(unsigned char x, unsigned char *a, int i);
+void SetPartChar(unsigned char *x, unsigned char a, int i);
+void LSB_hide(Image **I, unsigned char *msg, int encode, int vigenere, unsigned char *cle);
+void Next_pixel(Image **I, int *current_pos, int *i, int *j, int vigenere, unsigned char *cle);
 \ No newline at end of file
+++ a/inc/vigenere.h
@@ -0,0 +1,3 @@
+#define TAILLE_MAX 10000
+
+void vigenere(unsigned char *message, unsigned char *cle, int tailleCle, int encode);
+++ a/makefile
@@ -0,0 +1,13 @@
+SOURCES = ./src/main.c ./src/automatos.c ./src/vigenere.c ./src/stegano.c
+OBJETS = $(SOURCES:.c=.o)
+EXECUTABLE = Melodico
+CFLAGS += -Wall -Wextra 
+
+all: $(EXECUTABLE)
+
+$(EXECUTABLE): $(OBJETS)
+	$(CC) -o $@ $^ #$(BIBLIOTHEQUES)
+	rm -rf ./src/*.o
+
+clean:
+	rm -rf $(EXECUTABLE) ./src/*.o
+++ a/src/automatos.c
@@ -0,0 +1,169 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include "../inc/stegano.h"
+#include "../inc/automatos.h"
+
+
+/* Inverse le LSB d'un unsigne char *x passé en paramètre
+   ex : 01001011 -> 01001010 */
+void Change_LSB(unsigned char *x) {
+
+	unsigned char mask = 0x01;		   //0b00000001
+    unsigned char tmp;
+
+    tmp = *x & mask;
+    tmp = ~tmp & 0x01;
+    *x = (*x & 0xFE) | tmp;
+}
+
+
+/* Copie le LSB de x pour le stocker à la ie position de a */
+void GetOneChar(unsigned char x, unsigned char *a, int i) {
+
+	unsigned char mask = 0x01;			//0b00000001
+    *a += (x & mask) << (7-i);
+}
+
+
+/* Determine la parité du voisinage d'un pixel (de coordonnées int i, int j)
+   La règle à utiliser est passée en paramètre via int algo_tab[] */
+int Parity_check(Image **I, int algo_tab[], int i, int j) {
+
+	/* Pixels à considérer pour la parité */
+	int vois[9][2] = { { i   , j   } , { i   , j+1 } , { i+1 , j+1 },
+					   { i+1 , j   } , { i+1 , j-1 } , { i   , j-1 },
+					   { i-1 , j-1 } , { i-1 , j   } , { i-1 , j+1 } };
+	int parity = 0;
+	int h = (*I)->height;
+	int w = (*I)->width;
+
+	/* Evaluation et stockage de la parité de chaque pixel voisin */
+	for (int k=0; k < 8; k++) {
+
+		/* Considère ou non le voisin en fonction de l'algorithme de parité à appliquer */
+		if (algo_tab[k] == 1) {
+			/* Verifie les dépassements de tableau */
+			if (vois[k+1][0] >= 0 && vois[k+1][0] < h && vois[k+1][1] >= 0 && vois[k+1][1] < w) {
+				// Recupère le LSB du voisin (soit 1 si impair, soit 0 si pair)
+				parity += ((*I)->Mat_data[vois[k+1][0]][vois[k+1][1]].blue) % 2; }
+		}
+	}
+	// Ajoute la parité du pixel central lui même
+	parity += (*I)->Mat_data[i][j].blue % 2;
+	// Determine la parité globale du voisinage (0 si pair, 1 si impair)
+	return (parity % 2);
+}
+
+
+/* Stocke les valeurs des 8 bits d'un octets 'byte' dans un int[8] passé en paramètre*/
+void bit_in_tab(unsigned char *byte, int tab[]) {
+	for(int k=7; k>=0; k--) {    
+		tab[k] = *byte % 2;    
+		*byte = *byte / 2;    
+	}	  
+}
+
+
+/* Cache un message de N bit, bit à bit, dans N pixel, en modifiant ou non la parité du voisinage de chaque pixel
+   Au terme de la fonction, le voisinage d'un pixel est impair lorsqu'un 1 est caché
+						    le voisinage d'un pixel est pair lorsqu'un 0 est caché   */
+void Parity_encode(Image **I, unsigned char *msg) {
+
+	/* Determination de l'algorithme de parité */
+	int algo_tab[8];
+	unsigned char algo_byte = (*I)->Mat_data[4][4].red;
+	bit_in_tab(&algo_byte, algo_tab);
+
+	/* variables concernant le message à cacher */
+	uint8_t current_byte = 0;
+	int hide_byte[8];
+	int bit = 0;
+	bit_in_tab(&msg[current_byte], hide_byte);
+
+	/* Parcours de la matrice */
+	int h = (*I)->height;
+	int w = (*I)->width;
+	int parity = 0;
+	int breaking = 0;
+
+	for (int i = 0; i < h; i+=2) {
+		for (int j = 0; j < w; j+=2) {
+
+			/* Calcul de la parité des voisins*/
+			parity = Parity_check(I, algo_tab, i, j);
+
+			/* Dissimulation du message en fonction de la parité */
+			if ((parity == 1) && (hide_byte[bit] == 0)) {
+				Change_LSB(&((*I)->Mat_data[i][j].blue));
+			}
+			else if ((parity == 0) && (hide_byte[bit] == 1)) {
+				Change_LSB(&((*I)->Mat_data[i][j].blue));
+			}
+			bit += 1;
+
+			// Fin de message
+			if (bit == 8 && breaking == 1) return;
+
+			// Fin de caractère
+			if (bit == 8) {
+				current_byte ++;
+				if (msg[current_byte] == '\0') breaking = 1; //Dernier caractère
+				bit_in_tab(&msg[current_byte], hide_byte);   //Chargement des 8 bits d'un caractère (msg[current_byte]) au sein d'un int[8] (hide_byte)
+				bit = 0;
+			}
+		}
+	}
+	return;
+}
+
+
+/*
+Table de verité pour l'encodage :
+H = bit à cacher
+R = bit de poids faible du pixel central
+Paire et impaire = parités des voisins du pixel central(dépend de l'algo)
+
+|        |   H =  0   |   H = 1    |
+|----------------------------------|
+| Impaire|  change R  |  Nochange R|
+|----------------------------------|
+| Paire  | Nochange R |  change R  |
+
+*/
+
+
+/* Extrait un potentiel message caché au sein d'une image ppm (stockée préalablement dans une matrice 2D) */
+void Parity_decode(Image **I, unsigned char *msg) {
+
+	/* Determination de l'algorithme de parité */
+	int algo_tab[8];
+	unsigned char algo_byte = (*I)->Mat_data[4][4].red;
+	bit_in_tab(&algo_byte, algo_tab);
+
+	uint8_t l = 0;
+	int bit = 0;
+
+	/* Parcours de la matrice */
+	int h = (*I)->height;
+	int w = (*I)->width;
+	int parity = 0;
+	for (int i = 0; i < h; i+=2) {
+		for (int j = 0; j < w; j+=2) {
+
+			// parity == 0 (pair) -> le caractère caché est un 0
+			// parity == 1 (impair) -> le caractère caché est un 1
+			parity = Parity_check(I, algo_tab, i, j);
+			GetOneChar(parity, &msg[l], bit);
+			bit ++;
+
+			//fin de caractère ou de message
+			if (bit == 8) { 
+				if (msg[l] == '\0') return;
+				l ++;
+				bit = 0;
+			}
+		}
+	}
+}
+++ a/src/main.c
@@ -0,0 +1,132 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include "../inc/stegano.h"
+#include "../inc/automatos.h"
+#include "../inc/vigenere.h"
+
+
+void help() {
+
+	printf("\nHow to use this program :\n");
+	printf("Hide message into img :\n");
+	printf("	./tp_tim -e -lsb <image.ppm> \n");
+	printf("	            -par <image.ppm> \n");
+	printf("You can crypt your message with -Vigenere at the end of the command\n\n");
+
+	printf("Recover message into img :\n");
+	printf("	./tp_tim -d -lsb <image.ppm> \n");
+	printf("	            -par <image.ppm> \n");
+	printf("You must specify -Vigenere at the end of the command if a cypher text is hiding into the image\n\n");
+
+	printf("\nEXAMPLES : \n");
+	printf("./tp_tim -e -lsb chaton.ppm -Vigenere\n");
+	printf("./tp_tim -d -lsb chaton_enc.ppm -Vigenere\n");
+
+	printf("\nNOTES :\n");
+	printf("Lors de la dissimulation d'un message, l'image qui en résulte sera sauvegardee sous le nom de 'encrypt.ppm'\n");
+
+}
+
+/* Permet de vider le buffer */
+void clean_stdin(void) {
+
+	int c;
+	do {
+		c = getchar();
+	} while (c != '\n');
+}
+
+int main(int argc, char *argv[])
+{
+	int vig = 0;
+	unsigned char *cle = NULL;
+	if (argc > 3) {
+
+		Image *I;
+		if (chargement_ppm(argv[3], &I) == -1) return -1;
+		printf("Chargement OK\n");
+		uint8_t max_size = (((I->width)/2) * ((I->height)/2) / 8);
+
+
+		/* ENCODE */
+		if(strcmp(argv[1], "-e") == 0) {
+
+			/* Recuperation du message à cacher */ 
+			unsigned char *msg_s = malloc(max_size);
+			printf("Message a cacher (taille max = %d): ", max_size);
+    		fgets((char * restrict)msg_s, max_size, stdin);
+    		
+    		/* Vidage du buffer si msg > max_size */
+    		if (strlen((const char *)msg_s) >= max_size-1.0) clean_stdin();
+
+    		/* CHIFFREMENT AVEC VIGENERE */
+    		if (argc == 5) {
+    			vig = 1;
+    			printf("plaintext : %s\n", msg_s);
+
+    			cle = malloc(max_size);
+    			memset( cle, 0, max_size);
+				printf("Cle vigenere : ");
+    			fgets((char * restrict)cle, max_size, stdin);
+    			vigenere(msg_s, cle, strlen((const char *)cle), 1);
+
+    			printf("cypher : %s\n", msg_s);
+    		} 
+
+			/* LSB Methode ou PARITÉ Methode ou ERREUR */
+			if(strcmp(argv[2], "-lsb") == 0) LSB_hide(&I, msg_s, 1, vig, cle);
+			else if (strcmp(argv[2], "-par") == 0) Parity_encode(&I, msg_s);
+			else {
+				printf("wrong option [ MUST BE -par OR -lsb ]\n");
+			}
+
+			sauvegarde_ppm("encrypt.ppm", &I);
+
+			free(msg_s);
+			if (argc == 5) free(cle);
+		}
+
+
+		/* DECODE */
+		else if(strcmp(argv[1], "-d") == 0) {
+
+			unsigned char *buff = malloc(max_size);
+			memset( buff, 0, max_size);
+
+			/* CHIFFREMENT AVEC VIGENERE */
+    		if (argc == 5) {
+    			vig = 1;
+    			cle = malloc(max_size);
+    			memset( cle, 0, max_size);
+				printf("Cle vigenere : ");
+    			fgets((char * restrict)cle, max_size, stdin);
+    			if (strlen((const char *)cle) <= 1) return -1;
+    		} 
+
+    		/* LSB Methode ou PARITÉ Methode ou ERREUR */
+			if(strcmp(argv[2], "-lsb") == 0) LSB_hide(&I, buff, 0, vig, cle);
+			else if (strcmp(argv[2], "-par") == 0) Parity_decode(&I, buff);
+			else {
+				printf("wrong option [ MUST BE -par OR -lsb ]\n");
+			}
+
+			if (argc == 5) {
+				printf("Cypher : %s\n", buff);
+				vigenere(buff, cle, strlen((const char *)cle), 0);
+				printf("out\n");
+				free(cle);
+			}
+
+    		printf("plaintext : %s\n", buff);
+			free(buff);
+		}
+		else help();
+		free_image(&I);
+	}
+	else {
+		help();
+	}
+	return 0;
+}
 \ No newline at end of file
+++ a/src/stegano.c
@@ -0,0 +1,193 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include "../inc/stegano.h"
+
+
+/* Génère une matrice 2D dynamique */
+void NouvelleImage(int width, int height, Image** I)
+{
+	*I = malloc(sizeof(Image));
+	(*I)->width = width;
+	(*I)->height = height;
+
+	/* Tableau de pointeur de tableau */
+	(*I)->Mat_data = (Pix_rgb **)malloc(height * sizeof(Pix_rgb *));
+	/* Allocation de mémoire pour chaque tableau */
+	for (int i = 0; i < height; ++i) {
+      (*I)->Mat_data[i] = (Pix_rgb *)malloc(width * sizeof(Pix_rgb));
+	}
+
+	return;
+}
+
+
+/* Libere l'espace mémoire alloué à la structure Image */
+void free_image(Image** I) {
+
+	for (int i = 0; i < (*I)->height; ++i)
+	    free((*I)->Mat_data[i]);
+
+    free((*I)->Mat_data);
+    free(*I);
+}
+
+
+/* Lit l'entete d'un fichier ppm pour extraire la taille */
+void read_header(FILE * im_file, int *width, int *height) {
+
+	char * buff = malloc(10*sizeof(char));
+	char * line = NULL;
+    size_t len = 0;
+    int nb_line = 0;
+
+    /* Ignore les commentaire jusqu'à la ligne contenant la taille */
+    while (nb_line != 2) {
+		getline(&line, &len, im_file);
+        if (strncmp(line, "#", 1) != 0) {
+ 			nb_line ++;
+ 		}
+ 	}
+
+ 	/* Recupere la taille */
+ 	strcpy(buff, strtok(line, " "));
+	*width = atoi(buff);
+	strcpy(buff, strtok(NULL, " "));
+	*height = atoi(buff);
+
+    getline(&line, &len, im_file);
+    free(buff);
+}
+
+
+/* Charge l'image au sein d'une matrice */ 
+int chargement_ppm(char *image_name, Image** I) {
+
+	/* Ouverture du fichier image .ppm */
+	FILE* im_file = NULL;
+	if((im_file = fopen(image_name,"r")) == NULL) return -1;
+
+	int width, height;
+
+	read_header(im_file, &width, &height);
+	printf("SIZE : %d %d\n", width, height);
+
+	/* RECUPERATION ET STOCKAGE DES PIXELS */
+	NouvelleImage(width,height, I);
+	for (int i=0; i < (*I)->height; i++) {
+		for (int j=0; j < (*I)->width ; j++) {
+
+			fscanf(im_file, "%c", &((*I)->Mat_data[i][j].red));
+			fscanf(im_file, "%c", &((*I)->Mat_data[i][j].green));
+			fscanf(im_file, "%c", &((*I)->Mat_data[i][j].blue));
+		}
+	}
+	fclose(im_file);
+	return 0;
+}
+
+
+/* Crée une nouvelle image .ppm à partir d'une structure Image */
+int sauvegarde_ppm(char* image_name, Image** I) {
+
+  FILE* out = fopen(image_name, "w");
+  if(!out) return -1;
+
+  fprintf(out, "P6\n%d %d\n255\n", (*I)->width, (*I)->height);
+
+	for (int i=0; i < (*I)->height; i++) {
+		for (int j=0; j < (*I)->width ; j++) {
+
+			fprintf(out, "%c", (*I)->Mat_data[i][j].red);
+			fprintf(out, "%c", (*I)->Mat_data[i][j].green);
+			fprintf(out, "%c", (*I)->Mat_data[i][j].blue);
+		}
+	}
+	fclose(out);
+	printf("saveOK\n");
+	return 0;
+}
+
+
+/* Copie les 2 bits de poids faible de x pour les stocker dans le 1eme quart de a */
+void GetPartChar(unsigned char x, unsigned char *a, int i) {
+
+	unsigned char mask = 0x03;			//0b00000011
+    *a += (x & mask) << (i-1)*2;
+}
+
+
+/* Copie le ieme quart de a pour les stocker dans les 2 bits de poids faible de x */
+void SetPartChar(unsigned char *x, unsigned char a, int i) {
+    
+    unsigned char mask = 0x03;			//0b00000011
+    unsigned char tmp;
+
+    tmp = a & (mask << (i-1)*2);		//Decale mask pour obtenir un masque sur le ieme quart 
+    *x = (*x & 0xFC) | (tmp >> (i-1)*2);//Place les 2 bits au niveau du poids faible de x
+}
+
+
+/* Determine dans quel pixels l'information est/sera dissimulée
+   L'utilisation d'un chiffrement vigenere (int vigenere == 1) et donc d'une clé (unsigned char *cle)
+   influe sur la détermination des pixels */
+void Next_pixel(Image **I, int *current_pos, int *i, int *j, int vigenere, unsigned char *cle) {
+
+	int h = (*I)->height;
+	int w = (*I)->width;
+	int im_size = h * w;
+
+	*current_pos += ((*I)->Mat_data[(*i)][(*j)].red & (*I)->Mat_data[(*i)][(*j)].green) / 5;
+	*current_pos += 1;
+
+	if (vigenere) {
+		int icle = *current_pos % strlen((const char *)cle);
+		*current_pos += (*current_pos & cle[icle]) / 5;
+	}
+	int tmp_pos = *current_pos;
+
+	if (tmp_pos % 2 == 0) tmp_pos = im_size - tmp_pos;
+	//tmp_pos = tmp_pos % (w*h);
+	//printf("pos %d\n", tmp_pos);
+	*i = tmp_pos / w;
+	*j = tmp_pos % w;
+}
+
+
+/* Cache ou extrait un unsigned char *msg au sein de la matrice Image **I 
+   int encode = 1 -> cache le message
+   			  = 0 -> extrait le message
+   int vigenere   -> permet de savoir si un chiffrement vigenere a été ou doit être effectué (utile pour Next_pixel)
+   unsigned char *clef -> utilisé en cas de chiffrement avec vigenere */
+void LSB_hide(Image **I, unsigned char *msg, int encode, int vigenere, unsigned char *cle) {
+
+	uint8_t k = 0;
+	int quart = 1;
+
+	int h = (*I)->height;
+	int w = (*I)->width;
+	int i = 0;
+	int j = 0;
+	int current_pos = i*h + j;
+	
+	/* dissimulation ou extraction message */
+	while(1) {
+		Next_pixel(I, &current_pos, &i, &j, vigenere, cle);
+		if (encode == 1) SetPartChar(&((*I)->Mat_data[i][j].blue), msg[k], quart);
+		else GetPartChar((*I)->Mat_data[i][j].blue, &msg[k], quart);
+		quart += 1;
+		if (quart == 5) {
+			quart = 1;
+			if ( msg[k] == '\0') return;
+			k ++;
+		}
+		if (current_pos >= h*w) return;
+	}
+}
+
+
+
+/* TODO 
+1- vidage du buffer
+*/
 \ No newline at end of file
+++ a/src/vigenere.c
@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include<stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include "../inc/vigenere.h"
+
+char * message;
+char * cle;
+int tailleCle;
+
+
+/* Fonction de chiffrement ou déchiffrement Vigenere
+   Chiffre/Dechifffe le char *message avec la char *cle de taille int tailleCle
+   Si int encode = 1 -> chiffrement, Si int encode = 0 -> dechiffre */
+void vigenere(unsigned char *message, unsigned char *cle, int tailleCle, int encode)
+{
+   int iCle = 0;
+
+   /* Parcours du message */
+   for (int iMsg = 0; message[iMsg] != '\0'; iMsg++) {
+
+      /* Si notre caractère est un caractère alphanumérique */
+      if(isalpha(message[iMsg])) {
+         char casse, lettreCle;
+
+         //casse = 'A' si 'A' < message[iMsg] < 'Z'
+         //casse = 'a' si 'a' < message[iMsg] < 'z'
+         casse = (isupper(message[iMsg])) ? 'A' : 'a';
+         lettreCle = tolower(cle[iCle]) - 'a';
+         iCle = (iCle + 1) % tailleCle;
+
+         /* On se ramène à des lettres codées dans [0:26] pour pouvoir appliqué les formules suivantes */
+         message[iMsg] -= casse;
+         if (encode) message[iMsg] = ((message[iMsg] + lettreCle) % 26+ 26) % 26; // CHIFFREMENT
+         else message[iMsg] = ((message[iMsg] - lettreCle) % 26 + 26) % 26;       // DECHIFFREMENT
+
+         /* On rétablie le code ascii (65 à 90 pour les majuscule, 97 à 122 pour les minuscules) */
+         message[iMsg] += casse;
+      }
+   }
+}
 \ No newline at end of file