Cryptage XOR avec XBEE

Bonjour,

Je suis actuellement entrain de travailler sur un projet de communication Zigbee.
D’un côté j’ai une arduino Uno qui fait tourner des moteurs avec un module Xbee S2 récepteur et de l’autre mon ordinateur ainsi qu’un Xbee S2 expéditeur
Je travaille ,du côté ordinateur, avec une libraire qui me permet la détection des touches du clavier et je suis en python.
J’aimerai crypter l’odre que j’envoie à mon Xbee récepteur avec un XOR et également envoyer cet ordre tant qu’une checksum n’a pas été vérifiée.
Je vous avoue que je suis complètement pommée car je n’ai jamais fais ça.

Mon code en python :

def XORcipher(text,key):
	output=""
	for i in text:
		for c in key:
			i=chr(ord(i)^ord(c))
		output += i
	print(output)
	return output




#Fonctions permettant la détection d'évènements au clavier
def onKeyPress(event):
	ser=0
	try:
		ser = serial.Serial(port, 9600)
	except serial.SerialException:
		print("Communication non possible")
		exit();
	print("Envoi au"+port+"à 9600 bauds\n")
	ser.write(XORcipher('off','foo'))

Mon code récepteur en C

void XORcipher(char *text,char key[],char *textCrypt)
{ 
   Serial.println("Ce programme va déchiffrer les données reçues");
  for(int i=0;i<strlen(text);i++) 
  { 
    for(int c=0;c<strlen(key);c++)
    { 
      textCrypt[i]=text[i]^key[c];
    }
    Serial.println("Le texte decrypte:"); 
    Serial.print(textCrypt); 
  }
}

void loop()
{ 
  if (Serial.available() > 0)
  {
    char *data; 
    data=(char*)malloc(6*sizeof(char));
    char *texteCrypt; 
    texteCrypt=(char*)malloc(1*sizeof(char));
  
    for( int i = 0; i < 7; i++) 
    {
      data[i] = Serial.read(); 
    }
    XORcipher(data,"foo",texteCrypt); 
  }
}

Evidemment ça ne marche pas et je ne sais pas comment faire la checksum côté python. Un conseil s’il vous plait ??

J’ai fait un peu évoluer mon code!!
Envoi côté python :

def XORcipher(texte):
	clef = ['A', 'B', 'C'] 
	texteCrypt = []
	for i in range(len(texte)):
		xor = ord(texte[i]) ^ ord(clef[i % len(clef)])
		texteCrypt.append(chr(xor))
	
	return ''.join(texteCrypt)

Réception côté arduino :

void XORcipher(char *texte, char *texteCrypt) {
  char clef[] ={'A', 'B', 'C'};
  int i;
  for(i = 0; i < strlen(texte); i++) {
    texteCrypt[i] = texte[i] ^ clef[i % (sizeof(clef)/sizeof(char))];
    Serial.println(texteCrypt);
  }
}

à la réception j’observe ça à la fin de ma boucle for dans ma fonction XORcipher:
offmoteurccABC. C’est peut être une histoire de fin de chaine pas détectée ??
Helpppppppppppppp s’il vous plait

fl8shhh:
C'est peut être une histoire de fin de chaine pas détectée ??

As-tu seulement vérifié que coté arduino texte se termine bien avec un 0?

Non effectivement ce n'est pas le cas. Je ne sais pas comment faire autrement pour récuperer ma chaine et l'afficher

Comment sais-tu que tu as bien reçu toute ta chaîne?
Il faudrait que ta routine de réception ajoute un \0 à la fin de la chaîne avant de la passer à XORcipher()

Je travaille avec le logiciel XCTU pour voir ce qu’il s’envoie entre mes deux XBEE. J’arrive dans ma boucle de décryptage côté C et là ma chaine se constitue bien, je vois apparaitre au fur et à mesure de la boucle “off…” sauf qu’il m’affiche également la clé, il ne s’arrête pas. Donc vous me proposez en C à la réception de rajouter le caractère \0 avant le décryptage c’est bien ça ??

Et sinon je voudrais travailler avec une checksum !! J’aimerais le message tant que côté C la checksum n’a pas été vérifiée.
Je pense du coup :

  • écrire une fonction checksum en python
  • calculer la checksum de mon message crypté
    -rajouter à l’envoie cette checksum non cryptée
  • gestion réception

Mais je vois pas trop comment faire la gestion côté réception… :confused:

fdufnews:
Comment sais-tu que tu as bien reçu toute ta chaîne?
Il faudrait que ta routine de réception ajoute un \0 à la fin de la chaîne avant de la passer à XORcipher()

Bonjour,

Attention avec cette méthode de cryptage tu peux te retrouver avec des 0 dans la chaine. Il faudrait passer la longueur.

Je vous montre mon code côté Arduino (que les parties utiles)
J’ai essayé de rajouté le /0 à mon tableau de caractères mais le décryptage ne marche toujours pas comme il faut. Par exemple quand j’essaye d’envoyer “inc” du côté émetteur il me retourne : inck[CDY\ côté récepteur

const byte N_BYTES = 1; //taille valeurs reçues
const byte N_VALEURS = 3; //nombre de valeurs reçues
byte data[N_BYTES*N_VALEURS];

const char DEPART = '@';
const char FIN = '*';

String stringZero = "off";
String stringOne = "inc";
String stringTwo = "dec";
String stringThree = "lef";
String stringFour = "rig";
String stringFive = "str";

char valeurs[N_VALEURS+1];
char finChaine[]="/0";
char * resultat;

const bool DEBUG = true;
bool depart = false;
int byteEntrant; //pour lire les données entrantes 

void setup()
{
  Serial.begin(9600);
}

void loop()
{ 
  char decrypted[strlen(valeurs)];
  if(Serial.available()>0)
  {
    if(!depart)
    {
      byteEntrant=Serial.read();
      if(byteEntrant == DEPART)
      {
        depart = true; 
        if(DEBUG) Serial.println("@");
      }
    }
    if(depart)
    {
      if(DEBUG) Serial.println("Depart");
      while(Serial.available() < N_BYTES*(N_VALEURS+1)){}
      if(DEBUG) Serial.println("Obtention des donnees");
      for(int i=0; i < N_BYTES*(N_VALEURS+1);i++)
      {
        data[i]= Serial.read();
      }
      if(data[N_BYTES*N_VALEURS] == FIN)
      {
        if(DEBUG) Serial.println("Enregistrement des donnees");
        for( int i = 0; i < N_VALEURS+1; i++) // On vide valeurs
        {
          valeurs[i] = 0;
          if(DEBUG) Serial.println("reset");
        }
        for( int i = 0; i < N_BYTES*N_VALEURS; i++)
        {
          valeurs[i/N_BYTES] |= ((char)data[i] << 8*(i%N_BYTES)); 
          if(DEBUG) Serial.println("decalage");
        }
        Serial.println("Texte recu chiffre : ");
        Serial.println(valeurs);
        resultat=malloc(strlen(valeurs)+1+strlen(finChaine)+1);
        strcpy(resultat,valeurs);
        strcat(resultat,finChaine);
        Serial.println(resultat);
        Serial.println("Dechiffrage : "); 
        XORcipher(resultat, decrypted);
        Serial.println(decrypted);

        [b].... actions liées à la valeur de decrypted[/b]
      }
      depart=false;
    }
  }
}



/*Fonction permettant de chiffrer/déchiffrer un message par la méthode XOR*/

void XORcipher(char *texte, char *texteCrypt) 
{
  char clef[] ={'A', 'B', 'C'};
  int i;
  for(i = 0; i < strlen(texte); i++)
  {
    texteCrypt[i] = texte[i] ^ clef[i % (sizeof(clef)/sizeof(char))];
    Serial.println(texteCrypt);
  }
}