Cryptography.h

#if !defined(_RADIOLIB_CRYPTOGRAPHY_H)
#define _RADIOLIB_CRYPTOGRAPHY_H
 
#include "../TypeDef.h"
 
// AES-128 constants
#define RADIOLIB_AES128_BLOCK_SIZE                              (16)
#define RADIOLIB_AES128_KEY_SIZE                                (RADIOLIB_AES128_BLOCK_SIZE)
#define RADIOLIB_AES128_N_K                                     ((RADIOLIB_AES128_BLOCK_SIZE) / sizeof(uint32_t))
#define RADIOLIB_AES128_N_B                                     (4)
#define RADIOLIB_AES128_N_R                                     (10)
#define RADIOLIB_AES128_KEY_EXP_SIZE                            (176)
 
typedef struct {
  uint8_t X[RADIOLIB_AES128_BLOCK_SIZE];
  uint8_t buffer[RADIOLIB_AES128_BLOCK_SIZE];
  size_t buffer_len;
  uint8_t k1[RADIOLIB_AES128_BLOCK_SIZE];
  uint8_t k2[RADIOLIB_AES128_BLOCK_SIZE];
  bool subkeys_generated;
} RadioLibCmacState;
 
// helper type
typedef uint8_t state_t[4][4];
 
class RadioLibAES128 {
  public:
    RadioLibAES128();
 
    virtual void init(uint8_t* key) = 0;
 
    virtual size_t encryptECB(const uint8_t* in, size_t len, uint8_t* out) = 0;
    
    virtual size_t decryptECB(const uint8_t* in, size_t len, uint8_t* out) = 0;
 
    void generateCMAC(const uint8_t* in, size_t len, uint8_t* cmac);
 
    void initCMAC(RadioLibCmacState* st);
 
    void updateCMAC(RadioLibCmacState* st, const uint8_t* data, size_t len);
    
    void finishCMAC(RadioLibCmacState* st, uint8_t* out);
 
    bool verifyCMAC(const uint8_t* in, size_t len, const uint8_t* cmac);
  
  private:
    void blockXor(uint8_t* dst, const uint8_t* a, const uint8_t* b);
    void blockLeftshift(uint8_t* dst, const uint8_t* src);
    void generateSubkeys(uint8_t* key1, uint8_t* key2);
};
 
// in cases the user does not provide their own hardware-based AES-128, use the default software implementation
#if !RADIOLIB_CUSTOM_AES128
 
class RadioLibSoftwareAES128: public RadioLibAES128 {
  public:
    RadioLibSoftwareAES128();
 
    void init(uint8_t* key) override;
 
    size_t encryptECB(const uint8_t* in, size_t len, uint8_t* out) override;
    
    size_t decryptECB(const uint8_t* in, size_t len, uint8_t* out) override;
 
  private:
    uint8_t* keyPtr = nullptr;
    uint8_t roundKey[RADIOLIB_AES128_KEY_EXP_SIZE] = { 0 };
 
    void keyExpansion(uint8_t* roundKey, const uint8_t* key);
    void cipher(state_t* state, uint8_t* roundKey);
    void decipher(state_t* state, uint8_t* roundKey);
 
    void subWord(uint8_t* word);
    void rotWord(uint8_t* word);
 
    void subBytes(state_t* state, const uint8_t* box);
    void shiftRows(state_t* state, bool inv);
    void mixColumns(state_t* state, bool inv);
 
    // cppcheck seems convinced these are nut used, which is not true
    uint8_t mul(uint8_t a, uint8_t b); // cppcheck-suppress unusedPrivateFunction
    void addRoundKey(uint8_t round, state_t* state, const uint8_t* roundKey); // cppcheck-suppress unusedPrivateFunction
};
 
#endif
 
#endif