La grande question ici est de savoir comment faire la simulation dans cooja du chiffrement ECC et
RSA en intégrant des fonctions d’mbedTLS dans Contiki ?
Pour réaliser une simulation dans Cooja en intégrant des fonctions de MbedTLS pour le chiffrement
avec ECC (Elliptic Curve Cryptography) et RSA, tu vas combiner plusieurs étapes. Le processus global
implique de modifier une application Contiki pour utiliser les fonctions de chiffrement fournies par
MbedTLS, puis de simuler cette application dans Cooja.
Étapes principales pour la simulation de chiffrement avec ECC et RSA dans Cooja
1. Installer Contiki et Cooja
2. Configurer MbedTLS pour Contiki
3. Implémenter le chiffrement RSA et ECC dans l’application Contiki
4. Simuler dans Cooja
5. Capturer et analyser le trafic sécurisé
Prenons un exemple d'application de communication UDP (client-serveur) pour envoyer des
messages chiffrés avec ECC. Le client chiffrera les messages et les enverra au serveur, et le serveur les
déchiffrera.
1. Client UDP (chiffrement ECC/RSA) : Le client va chiffrer les messages avec ECC/RSA avant de
les envoyer au serveur.
2. Serveur UDP (déchiffrement ECC/RSA) : Le serveur va recevoir ces messages et les
déchiffrer.
1. Configurer MbedTLS pour Contiki
Pour utiliser MbedTLS dans Contiki, il faut inclure MbedTLS dans ton projet Contiki et configurer les
fichiers Makefile afin d’ajouter les bonnes dépendances pour RSA et ECC.
a. Télécharger et installer MbedTLS
Si MbedTLS n’est pas encore intégré dans Contiki, commence par le cloner et l’ajouter à ton projet :
git clone [Link]
cd mbedtls
make
b. Modifier le fichier Makefile dans ton projet Contiki
Dans le Makefile de ton projet (par exemple, celui d'une application Contiki), ajoute les chemins vers
les fichiers d'en-tête et les bibliothèques MbedTLS.
CFLAGS += -I/path/to/mbedtls/include
LDFLAGS += -L/path/to/mbedtls/library -lmbedtls -lmbedcrypto -lmbedx509
Cela permet d’intégrer les bibliothèques nécessaires pour utiliser RSA et ECC dans MbedTLS.
2. Implémenter le chiffrement RSA et ECC dans l’application Contiki
Une fois MbedTLS configuré dans Contiki, tu peux implémenter les fonctions de chiffrement RSA et
ECC dans ton application Contiki. Voici comment tu peux ajouter des fonctions de chiffrement dans le
code d'une application client-serveur basée sur UDP ou TCP.
a. Exemple de chiffrement RSA dans une application Contiki
Dans cet exemple, un message est chiffré à l’aide de RSA dans l’application client (udp-client.c), et
déchiffré sur le serveur (udp-server.c).
Chiffrement RSA dans udp-client.c :
#include "mbedtls/rsa.h"
#include "mbedtls/entropy.h"
#include "mbedtls/ctr_drbg.h"
static void rsa_encrypt_message(const unsigned char *input, size_t input_len,
unsigned char *output, size_t *output_len) {
mbedtls_rsa_context rsa;
mbedtls_entropy_context entropy;
mbedtls_ctr_drbg_context ctr_drbg;
const char *pers = "rsa_encrypt";
// Initialiser le générateur de nombres aléatoires et RSA
mbedtls_entropy_init(&entropy);
mbedtls_ctr_drbg_init(&ctr_drbg);
mbedtls_rsa_init(&rsa, MBEDTLS_RSA_PKCS_V15, 0);
// Générer une paire de clés RSA
mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, (const unsigned char *)pers,
strlen(pers));
mbedtls_rsa_gen_key(&rsa, mbedtls_ctr_drbg_random, &ctr_drbg, 2048, 65537);
// Chiffrement
mbedtls_rsa_rsaes_pkcs1_v15_encrypt(&rsa, mbedtls_ctr_drbg_random, &ctr_drbg,
MBEDTLS_RSA_PUBLIC, input_len, input, output);
*output_len = [Link];
// Libérer les ressources
mbedtls_rsa_free(&rsa);
mbedtls_ctr_drbg_free(&ctr_drbg);
mbedtls_entropy_free(&entropy);
static void udp_client_send(void) {
char message[] = "Hello, this is a test message!";
unsigned char encrypted_message[256];
size_t encrypted_message_len;
rsa_encrypt_message((unsigned char *)message, strlen(message), encrypted_message,
&encrypted_message_len);
// Envoyer le message chiffré via UDP
uip_udp_packet_sendto(client_conn, encrypted_message, encrypted_message_len,
&server_ipaddr, UIP_HTONS(UDP_SERVER_PORT));
Déchiffrement RSA dans udp-server.c :
#include "mbedtls/rsa.h"
#include "mbedtls/entropy.h"
#include "mbedtls/ctr_drbg.h"
static void rsa_decrypt_message(const unsigned char *input, size_t input_len,
unsigned char *output, size_t *output_len) {
mbedtls_rsa_context rsa;
mbedtls_entropy_context entropy;
mbedtls_ctr_drbg_context ctr_drbg;
size_t olen;
const char *pers = "rsa_decrypt";
// Initialiser RSA
mbedtls_rsa_init(&rsa, MBEDTLS_RSA_PKCS_V15, 0);
mbedtls_entropy_init(&entropy);
mbedtls_ctr_drbg_init(&ctr_drbg);
// Générer une paire de clés RSA
mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, (const unsigned char *)pers,
strlen(pers));
mbedtls_rsa_gen_key(&rsa, mbedtls_ctr_drbg_random, &ctr_drbg, 2048, 65537);
// Déchiffrement
mbedtls_rsa_rsaes_pkcs1_v15_decrypt(&rsa, mbedtls_ctr_drbg_random, &ctr_drbg,
MBEDTLS_RSA_PRIVATE, &olen, input, output, input_len);
*output_len = olen;
// Libérer les ressources
mbedtls_rsa_free(&rsa);
mbedtls_ctr_drbg_free(&ctr_drbg);
mbedtls_entropy_free(&entropy);
static void udp_server_receive(struct simple_udp_connection *c,
const uip_ipaddr_t *sender_addr,
uint16_t sender_port,
const uip_ipaddr_t *receiver_addr,
uint16_t receiver_port,
const uint8_t *data, uint16_t datalen) {
unsigned char decrypted_message[256];
size_t decrypted_message_len;
rsa_decrypt_message(data, datalen, decrypted_message, &decrypted_message_len);
printf("Message déchiffré : %s\n", decrypted_message);
b. Exemple de chiffrement ECC dans une application Contiki
Le processus de chiffrement et de déchiffrement avec ECC dans une application Contiki est similaire,
mais avec l’utilisation de fonctions ECC de MbedTLS.
Chiffrement ECC dans udp-client.c :
#include "mbedtls/ecp.h"
#include "mbedtls/ctr_drbg.h"
#include "mbedtls/entropy.h"
static void ecc_encrypt_message(const unsigned char *input, size_t input_len,
unsigned char *output, size_t *output_len) {
mbedtls_ecp_group grp;
mbedtls_ecp_point Q;
mbedtls_mpi d;
mbedtls_ctr_drbg_context ctr_drbg;
mbedtls_entropy_context entropy;
const char *pers = "ecc_encrypt";
// Initialisation
mbedtls_ecp_group_init(&grp);
mbedtls_ecp_point_init(&Q);
mbedtls_mpi_init(&d);
mbedtls_ctr_drbg_init(&ctr_drbg);
mbedtls_entropy_init(&entropy);
// Générer une clé publique ECC
mbedtls_ecp_group_load(&grp, MBEDTLS_ECP_DP_SECP256R1);
mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, (const unsigned char *)pers,
strlen(pers));
mbedtls_ecp_gen_keypair(&grp, &d, &Q, mbedtls_ctr_drbg_random, &ctr_drbg);
// Chiffrement avec ECC
mbedtls_ecp_point_write_binary(&grp, &Q, MBEDTLS_ECP_PF_UNCOMPRESSED, output_len,
output, input_len);
// Nettoyage
mbedtls_ecp_group_free(&grp);
mbedtls_ecp_point_free(&Q);
mbedtls_mpi_free(&d);
mbedtls_ctr_drbg_free(&ctr_drbg);
mbedtls_entropy_free(&entropy);
Déchiffrement ECC dans udp-server.c
Le serveur va recevoir le message chiffré et utiliser ECC pour le déchiffrer. Voici un exemple de code
pour déchiffrer le message reçu via ECC.
Déchiffrement ECC dans udp-server.c :
#include "mbedtls/ecp.h"
#include "mbedtls/ctr_drbg.h"
#include "mbedtls/entropy.h"
static void ecc_decrypt_message(const unsigned char *input, size_t input_len,
unsigned char *output, size_t *output_len) {
mbedtls_ecp_group grp;
mbedtls_ecp_point Q;
mbedtls_mpi d, r;
mbedtls_ctr_drbg_context ctr_drbg;
mbedtls_entropy_context entropy;
const char *pers = "ecc_decrypt";
// Initialiser les composants
mbedtls_ecp_group_init(&grp);
mbedtls_ecp_point_init(&Q);
mbedtls_mpi_init(&d);
mbedtls_mpi_init(&r);
mbedtls_ctr_drbg_init(&ctr_drbg);
mbedtls_entropy_init(&entropy);
// Charger la courbe elliptique (ex: secp256r1)
mbedtls_ecp_group_load(&grp, MBEDTLS_ECP_DP_SECP256R1);
mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, (const unsigned char *)pers,
strlen(pers));
// Initialiser la clé publique
mbedtls_ecp_point_read_binary(&grp, &Q, input, input_len);
// Générer une clé privée pour déchiffrer (ceci est un exemple simplifié)
mbedtls_ecp_gen_keypair(&grp, &d, &Q, mbedtls_ctr_drbg_random, &ctr_drbg);
// Déchiffrement : Calculer r = d * Q (opération elliptique)
mbedtls_ecp_mul(&grp, &r, &d, &Q, mbedtls_ctr_drbg_random, &ctr_drbg);
// Convertir le résultat en format binaire pour l'affichage
mbedtls_mpi_write_binary(&r, output, *output_len);
// Nettoyage
mbedtls_ecp_group_free(&grp);
mbedtls_ecp_point_free(&Q);
mbedtls_mpi_free(&d);
mbedtls_mpi_free(&r);
mbedtls_ctr_drbg_free(&ctr_drbg);
mbedtls_entropy_free(&entropy);
static void udp_server_receive(struct simple_udp_connection *c,
const uip_ipaddr_t *sender_addr,
uint16_t sender_port,
const uip_ipaddr_t *receiver_addr,
uint16_t receiver_port,
const uint8_t *data, uint16_t datalen) {
unsigned char decrypted_message[128];
size_t decrypted_message_len = sizeof(decrypted_message);
// Déchiffrer le message reçu avec ECC
ecc_decrypt_message(data, datalen, decrypted_message, &decrypted_message_len);
printf("Message déchiffré : %s\n", decrypted_message);