Version 1.1

README.md

@@ -1,3 +1,6 @@
 # Passerelle
 
-Programme passerelle dans le cadre du projet Prosecco
+Programme passerelle dans le cadre du projet Prosecco
+
+v 1.1 : Avec le chiffrement dit "Playfair"
+

src/Makefile

@@ -1,7 +1,14 @@
-pass : pass.c pass.h
-	cc -Wall -D_REENTRANT -o pass pass.c -pthread
+# Makefile pour tester la librairie
+pass : pass.o  chiffrePF.o
+	cc -o pass pass.o chiffrePF.o -pthread
 
-clean:
-	rm -f pass 
+pass.o : pass.c pass.h chiffrePF.h
+	cc -c -Wall -D_REENTRANT pass.c
+
+chiffrePF.o : chiffrePF.c chiffrePF.h
+	cc -c -Wall -D_REENTRANT chiffrePF.c
+
+clean :
+	rm -f pass *.o
 
 

src/chiffrePF.c

@@ -0,0 +1,179 @@
+/* systeme simple de chiffrement d'octets inspire de la methode PlayFair */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include "chiffrePF.h" /* pour verifier la coherence a la compilation */
+
+/* ATTENTION : Ce no de version sert aux utilisateurs a bien verifier
+ qu'ils echangent avec LA MEME VERSION !!
+ Donc, si vous faites des modifications il faut changer ce no
+*******************************************************/
+#define VERSION "E2l 1.1"
+
+/* ATTENTION : le resultat etant ecrit sur la sortie standard (stdout),
+   les messages de DEBUG sont tous diriges vers la sortie erreur  (stderr)!!
+*********************************************************************/
+
+#define NBO 256 /* nb d'octets */
+#define LCM  16 /* Longueur du cote de la matrice */
+static char buf[NBO]; /* table des octets a chiffrer */
+static char buf2[NBO]; /* table pour noter le remplissage des octets */
+
+static void coordCar(char C, int *l, int * c)
+{
+int i;
+  for (i=0; i< NBO; i++) if (buf[i]==C) break;
+  *c = i%LCM;
+  *l = i/LCM;
+}
+
+static char carLC(int l, int c) /*fct qui retourne le car. de la ligne l col. c*/
+{
+   return(buf[(l*LCM)+c]);
+}
+
+#ifdef DEBUGPF
+static void Trace(void) /* affiche buf */
+{
+int i,j;
+unsigned char c;
+  for (i=0;i<LCM;i++) {
+      for (j=0;j<LCM;j++) {
+         c = (unsigned char)buf[(i*LCM)+j];
+         if ((c >= ' ') && (c <= '~')) fprintf(stderr," %c ",c);
+         else fprintf(stderr,"%.2x ",c);
+      }
+      fprintf(stderr,"\n");
+  }
+}
+#endif
+
+/* fonction qui chiffre directement dans le buffer des donnees a chiffrer */
+void PF_chiffreD(char *B, int T) /* B adresse du buf, T le nb d'octets */
+{
+int i,l1,c1,l2,c2;
+   for (i=0; i<T; i+=2) {
+     if (i==T-1) { /* cas particulier du dernier octet */
+       coordCar(B[i],&l1,&c1);
+       l1+=2; /* on descend de 2 ligne */
+       if (l1 >=LCM) l1-=LCM;
+       B[i] = carLC(l1,c1);
+     } else { /* cas du couple */
+       coordCar(B[i],&l1,&c1);
+       coordCar(B[i+1],&l2,&c2);
+       if (l1 == l2) { /* sur la meme ligne */
+          /* on decale vers le haut */
+          l1--;
+          if (l1 < 0) l1+=LCM;
+          B[i] = carLC(l1,c1);
+          B[i+1] = carLC(l1,c2);
+       } else {
+          if (c1 == c2) { /* sur la meme colonne */
+             /* on decale vers la droite */
+             c1++;
+             if (c1 >=LCM) c1-=LCM;
+             B[i] = carLC(l1,c1);
+             B[i+1] = carLC(l2,c1);
+          } else { /* on a un rectangle */
+/* schema
+        c1        c2
+
+l1      x         b
+
+
+l2      a         y
+
+On fait la permutation x,y => a,b
+**************************************/
+             B[i] = carLC(l2,c1);
+             B[i+1] = carLC(l1,c2);
+          }
+       }
+     }
+   }
+}
+
+void PF_dechiffreD(char *B, int T) /* B adresse du buf, T le nb d'octets */
+{
+int i,l1,c1,l2,c2;
+   for (i=0; i<T; i+=2) {
+     if (i==T-1) { /* cas particulier du dernier octet */
+       coordCar(B[i],&l1,&c1);
+       l1-=2; /* on monte de 2 ligne */
+       if (l1 < 0) l1+=LCM;
+       B[i] = carLC(l1,c1);
+     } else { /* cas du couple */
+       coordCar(B[i],&l1,&c1);
+       coordCar(B[i+1],&l2,&c2);
+       if (l1 == l2) { /* sur la meme ligne */
+          /* on decale vers le bas */
+          l1++;
+          if (l1 >= LCM) l1-=LCM;
+          B[i] = carLC(l1,c1);
+          B[i+1] = carLC(l1,c2);
+       } else {
+          if (c1 == c2) { /* sur la meme colonne */
+             /* on decale vers la gauche */
+             c1--;
+             if (c1 < 0) c1+=LCM;
+             B[i] = carLC(l1,c1);
+             B[i+1] = carLC(l2,c1);
+          } else { /* on a un rectangle */
+/* schema
+        c1        c2
+
+l1      x         b
+
+
+l2      a         y
+
+On fait la permutation x,y => a,b
+**************************************/
+             B[i] = carLC(l2,c1);
+             B[i+1] = carLC(l1,c2);
+          }
+       }
+     }
+   }
+}
+
+#define SAUT 29 /* valeur du saut pour remplir le reste de la table */
+void PF_init(char * cle) /* on passe la cle en parametre */
+{
+/* initialisation de la table */
+int i,I=0,j;
+char c;
+  for (i=0; i<strlen(cle); i++) {
+      c = cle[i];
+      if (buf2[(int)c]) continue;
+      buf[I++] = c;
+      buf2[(int)c] = 1;
+  }
+/*
+  for (i=0; i<NBO; i++) {
+      if (buf2[i]) continue;
+      buf[I++] = (char)i;
+      buf2[i] = 1;
+  }
+*/
+  for (j=0;j<SAUT;j++) {
+    for (i=j; i<NBO; i+=SAUT) {
+      if (buf2[i]) continue;
+      buf[I++] = i;
+      buf2[i] = 1;
+    }
+  }
+#ifdef DEBUG
+  for (i=0; i<NBO; i++) {
+      if (buf2[i]) continue;
+      fprintf(stderr,"Valeur %d non affectee !!\n",i);
+  }
+#endif
+}
+
+

src/chiffrePF.h

@@ -0,0 +1,17 @@
+/* chiffrePF.h : header file pour le chiffrement Playfair */
+
+/* liste des fonctions utilisables */
+
+/* Fonction de chiffrement direct dans le buffer :
+   B adresse du buf, T le nb d'octets */
+extern void PF_chiffreD(char *B, int T);
+
+/* Fonction de dechiffrement direct dans le buffer :
+   B adresse du buf, T le nb d'octets */
+extern void PF_dechiffreD(char *B, int T);
+
+/* Fonction d'Initialisation : on passe la cle en parametre */
+extern void PF_init(char * cle);
+
+
+

src/pass.c

@@ -15,6 +15,7 @@
 #include <pthread.h>
 
 #include "pass.h"
+#include "chiffrePF.h"
 
 /* les variables globales */
 int RUN=1; /* Indice qui permet de stopper en le mettant a zero */
@@ -91,6 +92,13 @@ char *NFCLE="/tmp/clepass";
 #define LCLE 8192 /* 8 ko  => cle de 65536 bits !! */
 char BCLE[LCLE]; /* buffer contenant la cle */
 
+/* fchiffre3 utilise les fonction PF */
+void fchiffre3(char * b, int l, int ori) 
+{
+   if (ori) PF_chiffreD(b,l);
+   else PF_dechiffreD(b,l);
+}
+
 /* on suppose dans tout le code que la fct de chiffrement est telle que
 fchiffre(fchiffre(buf)) = buf !! autrement dit qu'elle est involutive ! */
 void fchiffre2(char * b, int l, int ori) /* travaille avec BCLE */
@@ -110,10 +118,13 @@ long long *d, *f, *c, *fc;
 
 int initCle(void)
 {
+   PF_init("Salut");
+/* si on utilise fchiffre2() !!
 int fd;
    if ((fd = open(NFCLE,O_RDONLY)) == -1) return -1;
    if (read(fd,BCLE, LCLE) != LCLE) return -1;
    close(fd);
+*******************/
    return 0;
 }
 
@@ -150,7 +161,16 @@ char buf[LBUF];
            else {
               n = (int)ntohs(lb);
               if (readNbc(SidLoc,buf,n) == -1) n=-1;
+/* on pourrait faire varier le chiffrement dans le code en faisant :
+#ifdef CHIF_V1
+              fchiffre(buf,n,0);
+#endif
+#ifdef CHIF_V2
               fchiffre2(buf,n,0);
+#endif
+ etc .... *************************************************/
+              /* on dechiffre */
+              fchiffre3(buf,n,0);
            }
         } else
            n=read(SidLoc,buf,LBUF);
@@ -160,7 +180,8 @@ char buf[LBUF];
 #ifdef TRACESP
               printf(" writeNbc %d octets !\n",n);
 #endif
-              fchiffre2(buf,n,0);
+              /* on chiffre */
+              fchiffre3(buf,n,1);
               lb = htons((uint16_t)n);
               write(SidDist,&lb,2); /* on envoie le nb d'octets du paquet */
            }
@@ -209,7 +230,8 @@ char buf[LBUF];
            else {
               n = (int)ntohs(lb);
               if (readNbc(sid,buf,n) == -1) n=-1;
-              fchiffre2(buf,n,0);
+              /* on dechiffre */
+              fchiffre3(buf,n,0);
            }
         } else n=read(sid,buf,LBUF);
         if (n > 0) {
@@ -217,7 +239,8 @@ char buf[LBUF];
 #ifdef TRACESP
               printf(" writeNbc %d octets !\n",n);
 #endif
-              fchiffre2(buf,n,1);
+              /* on chiffre */
+              fchiffre3(buf,n,1);
               lb = htons((uint16_t)n);
               write(fd,&lb,2); /* on envoie le nb d'octets du paquet */
            }

src/pass.h

@@ -1,6 +1,6 @@
 /* pass.h : parametres du programme pass.c */
 
-#define Version "1.00"
+#define Version "1.10"
 
 #define EOT '\04' /* caractere fin de transmission */