From 3f56b8a4589999e99bb72e5badcef80c7b4141cb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Grome=C5=A1?= Date: Sat, 14 Jul 2018 11:09:09 +0200 Subject: [PATCH] RF69 - Added hardware AES support --- .../RF69_Receive_AES/RF69_Receive_AES.ino | 80 +++++++++++++++++++ .../RF69_Transmit_AES/RF69_Transmit_AES.ino | 74 +++++++++++++++++ keywords.txt | 3 + src/modules/RF69.cpp | 12 +++ src/modules/RF69.h | 5 ++ 5 files changed, 174 insertions(+) create mode 100644 examples/RF69_Receive_AES/RF69_Receive_AES.ino create mode 100644 examples/RF69_Transmit_AES/RF69_Transmit_AES.ino diff --git a/examples/RF69_Receive_AES/RF69_Receive_AES.ino b/examples/RF69_Receive_AES/RF69_Receive_AES.ino new file mode 100644 index 00000000..377a775d --- /dev/null +++ b/examples/RF69_Receive_AES/RF69_Receive_AES.ino @@ -0,0 +1,80 @@ +/* + * KiteLib RF69 Receive with AES Example + * + * This example receives packets using RF69 FSK radio module. + * Packets are decrypted using hardware AES. + * NOTE: When using address filtering, the address byte is NOT encrypted! + */ + +// include the library +#include + +// RF69 module is in slot A on the shield +RF69 rf = Kite.ModuleA; + +void setup() { + Serial.begin(9600); + + // initialize RF69 with default settings + Serial.print(F("[RF69] Initializing ... ")); + // carrier frequency: 434.0 MHz + // bit rate: 48.0 kbps + // Rx bandwidth: 125.0 kHz + // frequency deviation: 50.0 kHz + // output power: 13 dBm + // sync word: 0x2D 0x01 + byte state = rf.begin(); + if(state == ERR_NONE) { + Serial.println(F("success!")); + } else { + Serial.print(F("failed, code 0x")); + Serial.println(state, HEX); + while(true); + } + + // set AES key that will be used to decrypt the packet + // NOTE: the key must be exactly 16 bytes long! + uint8_t key[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F}; + rf.setAESKey(key); + + // enable AES encryption + rf.enableAES(); + + // AES encryption can also be disabled + /* + rf.disableAES(); + */ +} + +void loop() { + Serial.print(F("[RF69] Waiting for incoming transmission ... ")); + + // you can receive data as an Arduino String + String str; + byte state = rf.receive(str); + + // you can also receive data as byte array + /* + byte byteArr[8]; + byte state = rf.receive(byteArr, 8); + */ + + if(state == ERR_NONE) { + // packet was successfully received + Serial.println(F("success!")); + + // print the data of the packet + Serial.print(F("[RF69] Data:\t\t")); + Serial.println(str); + + } else if(state == ERR_RX_TIMEOUT) { + // timeout occurred while waiting for a packet + Serial.println(F("timeout!")); + + } else if(state == ERR_CRC_MISMATCH) { + // packet was received, but is malformed + Serial.println(F("CRC error!")); + + } +} diff --git a/examples/RF69_Transmit_AES/RF69_Transmit_AES.ino b/examples/RF69_Transmit_AES/RF69_Transmit_AES.ino new file mode 100644 index 00000000..779cc1ad --- /dev/null +++ b/examples/RF69_Transmit_AES/RF69_Transmit_AES.ino @@ -0,0 +1,74 @@ +/* + * KiteLib RF69 Transmit with AES Example + * + * This example transmits packets using RF69 FSK radio module. + * Packets are encrypted using hardware AES. + * NOTE: When using address filtering, the address byte is NOT encrypted! + */ + +// include the library +#include + +// RF69 module is in slot A on the shield +RF69 rf = Kite.ModuleA; + +void setup() { + Serial.begin(9600); + + // initialize RF69 with default settings + Serial.print(F("[RF69] Initializing ... ")); + // carrier frequency: 434.0 MHz + // bit rate: 48.0 kbps + // Rx bandwidth: 125.0 kHz + // frequency deviation: 50.0 kHz + // output power: 13 dBm + // sync word: 0x2D 0x01 + byte state = rf.begin(); + if(state == ERR_NONE) { + Serial.println(F("success!")); + } else { + Serial.print(F("failed, code 0x")); + Serial.println(state, HEX); + while(true); + } + + // set AES key to encrypt the packet + // NOTE: the key must be exactly 16 bytes long! + uint8_t key[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F}; + rf.setAESKey(key); + + // enable AES encryption + rf.enableAES(); + + // AES encryption can also be disabled + /* + rf.disableAES(); + */ +} + +void loop() { + Serial.print(F("[RF69] Transmitting packet ... ")); + + // you can transmit C-string or Arduino string up to 64 characters long + byte state = rf.transmit("Hello World!"); + + // you can also transmit byte array up to 64 bytes long + /* + byte byteArr[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}; + byte state = rf.transmit(byteArr, 8); + */ + + if(state == ERR_NONE) { + // the packet was successfully transmitted + Serial.println(" success!"); + + } else if(state == ERR_PACKET_TOO_LONG) { + // the supplied packet was longer than 256 bytes + Serial.println(" too long!"); + + } + + // wait for a second before transmitting again + delay(1000); +} diff --git a/keywords.txt b/keywords.txt index 35172581..7aa52717 100644 --- a/keywords.txt +++ b/keywords.txt @@ -56,6 +56,9 @@ setFrequencyDeviation KEYWORD2 setNodeAddress KEYWORD2 setBroadcastAddress KEYWORD2 disableAddressFiltering KEYWORD2 +setAESKey KEYWORD2 +enableAES KEYWORD2 +disableAES KEYWORD2 # ESP8266 join KEYWORD2 diff --git a/src/modules/RF69.cpp b/src/modules/RF69.cpp index 067e1473..849658ff 100644 --- a/src/modules/RF69.cpp +++ b/src/modules/RF69.cpp @@ -207,6 +207,18 @@ uint8_t RF69::standby() { return(setMode(RF69_STANDBY)); } +void RF69::setAESKey(uint8_t* key) { + _mod->SPIwriteRegisterBurst(RF69_REG_AES_KEY_1, key, 16); +} + +uint8_t RF69::enableAES() { + return(_mod->SPIsetRegValue(RF69_REG_PACKET_CONFIG_2, RF69_AES_ON, 0, 0)); +} + +uint8_t RF69::disableAES() { + return(_mod->SPIsetRegValue(RF69_REG_PACKET_CONFIG_2, RF69_AES_OFF, 0, 0)); +} + uint8_t RF69::setFrequency(float freq) { // check allowed frequency range if(!((freq > 290.0) && (freq < 340.0) || diff --git a/src/modules/RF69.h b/src/modules/RF69.h index 2c784db1..db73c395 100644 --- a/src/modules/RF69.h +++ b/src/modules/RF69.h @@ -427,6 +427,11 @@ class RF69 { uint8_t sleep(); uint8_t standby(); + // hardware AES support + void setAESKey(uint8_t* key); + uint8_t enableAES(); + uint8_t disableAES(); + // configuration methods uint8_t setFrequency(float freq); uint8_t setBitRate(float br);