Enkripsi Data LoRa dengan AESLib pada Node LoRa

Enkripsi

Enkripsi adalah menyamarkan data dengan menambah atau mencampur data dengan data data lain sehingga sulit di ketahui data nya tanpa ada nya key untuk membuka data itu. Data LoRa merupakan data publik jika dilihat cara kerja nya. Jika frequency nya berhasil kita dapatkan maka data LoRa yang ada bisa di baca jika tanpa menggunakan enkripsi.

Ada banyak logaritma enkripsi yang telah mendukung pada pemrograman Arduino. Mulai dari AES, AEAD algoritma, Hash, dan lain lain. Teman-teman bisa lihat list cryptographi Arduino pada web berikut ini.

Cara Membuat Alat Pengukur Nilai Resistor Menggunakan Arduino

Sensor Tekanan Air Dan Udara Dengan Arduino

Cryptography Arduino library

Jika menggunakan protokol LoRawan yang ada, sesungguh nya data-data nya sudah ter enkripsi, tapi bagai manakah cara enkripsi data LoRa jika menggunakan protokol sendiri nya nanti? Yuk kita coba.

Enkripsi Data Sensor DHT21

Pada contoh kali kita akan enkripsi data suhu dan kelebaban dari sensor DHT21 pada Lora node ESP32 kemudian di kirim ke LoRa penerima, kemudian data yang ter enkripsi akan di dekripsi kembali untuk melihat data asli yang di terima. Dengan cara ini maka pihak ketiga yang ingin membaca data LoRa kita hanya akan mendapatkan data yang ter enkripsi. Tapi tidak mendapatkan data asli.

Alat dan Bahan

Dua buah modul ESP32 Lora Custome, Pesan dengan click link ini
Library Arduino LoRa, download dengan click link ini
Library DHT, download dengan click link ini
Library AESLib.h dengan click link ini

Untuk Proses instalasi hardware dan penjelasan program bisa teman-teman lihat pada video di bawah ini,

ESP32 LoRa Node Custome Mikroavr Bisa di lihat di link di bawah ini
click Tombol di bawah ini

ESP32 Lora Node Custome

Program Pengirim

Pada modul Lora ini dia akan membaca sensor DHT21 kemudian data di enkripsi dan kirim penerima (gateway). Program nya sebagai berikut.

 
#include "DHT.h"
#define DHTTYPE DHT21
#define DHTPIN 4
DHT dht(DHTPIN, DHTTYPE);

#include "AESLib.h"
AESLib aesLib;
  
#include "SPI.h"
#include "LoRa.h"

const int csPin = 5;          // LoRa radio chip select
const int resetPin = 26;        // LoRa radio reset
const int irqPin = 13;          // change for your board; must be a hardware interrupt pin

char cleartext[256];
char ciphertext[512];
// AES Encryption Key
byte aes_key[] = { 0x15, 0x2B, 0x7E, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C };
// General initialization vector (you must use your own IV's in production for full security!!!)
byte aes_iv[N_BLOCK] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
// Generate IV (once)

float h,t;
String strDHT;

void aes_init() {
  aesLib.gen_iv(aes_iv);
  // workaround for incorrect B64 functionality on first run...
  encrypt("HELLO WORLD!", aes_iv);
}

String encrypt(char * msg, byte iv[]) {  
  int msgLen = strlen(msg);
  char encrypted[2 * msgLen];
  aesLib.encrypt64(msg, msgLen, encrypted, aes_key,sizeof(aes_key) ,iv);  
  return String(encrypted);
}

/*String decrypt(char * msg, byte iv[]) {
  unsigned long ms = micros();
  int msgLen = strlen(msg);
  char decrypted[msgLen]; // half may be enough
  aesLib.decrypt64(msg, msgLen, decrypted, aes_key,sizeof(aes_key) ,iv);  
  return String(decrypted);
}
*/
void setup() {
  Serial.begin(115200);
  dht.begin();
  while (!Serial);
  aes_init();
  Serial.println("LoRa Sender");
  LoRa.setPins(csPin, resetPin, irqPin);
  if (!LoRa.begin(915E6)) {
    Serial.println("Starting LoRa failed!");
    while (1);
  }
}

void loop() {
  
  baca_dht21();
  Serial.println(cleartext);
  // Encrypt
  //sprintf(cleartext, "data : %i \n", 5);  
  byte enc_iv[N_BLOCK] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; // iv_block gets written to, provide own fresh copy...
  String encrypted = encrypt(cleartext, enc_iv);
  sprintf(ciphertext, "%s", encrypted.c_str());
  Serial.print("Ciphertext: ");
  Serial.println(encrypted);
  
   // send packet
  LoRa.beginPacket();
  LoRa.print(encrypted);
  LoRa.endPacket();

  // Decrypt
  //byte dec_iv[N_BLOCK] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; // iv_block gets written to, provide own fresh copy...
  //String decrypted = decrypt(ciphertext, dec_iv);  
  //Serial.print("Cleartext: ");
  //Serial.println(decrypted);  
  delay(3000);
}

void baca_dht21(){
  h = dht.readHumidity();
  t = dht.readTemperature();
  strDHT = String(h) + "," + String(t) + "#";
  strDHT.toCharArray(cleartext, strDHT.length()+1);
}

Penjelasan Penting

 byte aes_key[] = { 0x15, 0x2B, 0x7E, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C };

point penting pada program di atas adalah aes_key[]. Ini adalah key untuk membuka data yang ter enkripsi. Untuk mengenkripsi data maka key pada pengirim harus sama dengan key sebagai penerima. Berbeda satu bit saja maka data tidak akan bisa di dekripsi, penulis coba merubah key di atas seperti di bawah ini,

 byte aes_key[] = { 0x15, 0x2B, 0x7E, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3D };

Dengan key yang cukup panjang di atas bisa di pastikan akan sangat sulit di dekripsi data Lora nya jika kita tidak tahu byte key si pengirim.

Program Penerima

Untuk Penerima LoRa kita menggunakan LoRa Gateway Custome. Sedikit berbeda dengan config pin pada Lora Node Custome. Untuk Program nya bisa dilihat di bawah ini.

#include "AESLib.h"
AESLib aesLib;
  
#include "SPI.h"
#include "LoRa.h"

const int csPin = 17;          // LoRa radio chip select
const int resetPin = 16;        // LoRa radio reset
const int irqPin = 27;          // change for your board; must be a hardware interrupt pin

char cleartext[256];
char ciphertext[512];
// AES Encryption Key
byte aes_key[] = { 0x15, 0x2B, 0x7E, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3D};
// General initialization vector (you must use your own IV's in production for full security!!!)
byte aes_iv[N_BLOCK] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
// Generate IV (once)

int loopcount = 0;
String get_lora, buf_lora;
String decrypted, buf_decrypted;

void aes_init() {
  aesLib.gen_iv(aes_iv);
  // workaround for incorrect B64 functionality on first run...
  //encrypt("HELLO WORLD!", aes_iv);
}

/*String encrypt(char * msg, byte iv[]) {  
  int msgLen = strlen(msg);
  char encrypted[2 * msgLen];
  aesLib.encrypt64(msg, msgLen, encrypted, aes_key,sizeof(aes_key) ,iv);  
  return String(encrypted);
}
*/String decrypt(char * msg, byte iv[]) {
  unsigned long ms = micros();
  int msgLen = strlen(msg);
  char decrypted[msgLen]; // half may be enough
  aesLib.decrypt64(msg, msgLen, decrypted, aes_key,sizeof(aes_key) ,iv);  
  return String(decrypted);
}



void setup() {
  Serial.begin(115200);
  while (!Serial);

  Serial.println("LoRa Receiver");
  LoRa.setPins(csPin, resetPin, irqPin);
  if (!LoRa.begin(915E6)) {
    Serial.println("Starting LoRa failed!");
    while (1);
  }
}

void loop() {
  // try to parse packet
  int packetSize = LoRa.parsePacket();
  if (packetSize) {
    // received a packet
    Serial.print("data encrypted: '");

    // read packet
    while (LoRa.available()) {
      //Serial.print((char)LoRa.read());
      buf_lora += String((char)LoRa.read());
    }
    get_lora = buf_lora;
    buf_lora = "";
    // print RSSI of packet
    Serial.print(get_lora);
    Serial.print("' with RSSI ");
    Serial.println(LoRa.packetRssi());

    
    // Decrypt
    get_lora.toCharArray(ciphertext, get_lora.length()+1);
    byte dec_iv[N_BLOCK] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; // iv_block gets written to, provide own fresh copy...
    decrypted = decrypt(ciphertext, dec_iv);  
    Serial.print("data Decrypted: ");
    Serial.println(decrypted);
  }
}

Untuk Hasil penerima bisa dilihat pada gambar di bawah ini.