Rijndael.h

//Rijndael.h
#pragma once
// #ifndef __RIJNDAEL_H__
// #define __RIJNDAEL_H__

#include <exception>
#include <cstring>

using namespace std;

//Rijndael (pronounced Reindaal) is a block cipher, designed by Joan Daemen and Vincent Rijmen as a candidate algorithm for the AES.
//The cipher has a variable block length and key length. The authors currently specify how to use keys with a length
//of 128, 192, or 256 bits to encrypt blocks with al length of 128, 192 or 256 bits (all nine combinations of
//key length and block length are possible). Both block length and key length can be extended very easily to
// multiples of 32 bits.
//Rijndael can be implemented very efficiently on a wide range of processors and in hardware. 
//This implementation is based on the Java Implementation used with the Cryptix toolkit found at:
//http://www.esat.kuleuven.ac.be/~rijmen/rijndael/rijndael.zip
//Java code authors: Raif S. Naffah, Paulo S. L. M. Barreto
//This Implementation was tested against KAT test published by the authors of the method and the
//results were identical.
class CRijndael
{
public:
  //Operation Modes
  //The Electronic Code Book (ECB), Cipher Block Chaining (CBC) and Cipher Feedback Block (CFB) modes
  //are implemented.
  //In ECB mode if the same block is encrypted twice with the same key, the resulting
  //ciphertext blocks are the same.
  //In CBC Mode a ciphertext block is obtained by first xoring the
  //plaintext block with the previous ciphertext block, and encrypting the resulting value.
  //In CFB mode a ciphertext block is obtained by encrypting the previous ciphertext block
  //and xoring the resulting value with the plaintext.
  enum { ECB=0, CBC=1, CFB=2 };

private:
  enum { DEFAULT_BLOCK_SIZE=16 };
  enum { MAX_BLOCK_SIZE=32, MAX_ROUNDS=14, MAX_KC=8, MAX_BC=8 };

  //Auxiliary Functions
  //Multiply two elements of GF(2^m)
  static int Mul(int a, int b)
  {
    return (a != 0 && b != 0) ? sm_alog[(sm_log[a & 0xFF] + sm_log[b & 0xFF]) % 255] : 0;
  }

  //Convenience method used in generating Transposition Boxes
  static int Mul4(int a, char b[])
  {
    if(a == 0)
      return 0;
    a = sm_log[a & 0xFF];
    int a0 = (b[0] != 0) ? sm_alog[(a + sm_log[b[0] & 0xFF]) % 255] & 0xFF : 0;
    int a1 = (b[1] != 0) ? sm_alog[(a + sm_log[b[1] & 0xFF]) % 255] & 0xFF : 0;
    int a2 = (b[2] != 0) ? sm_alog[(a + sm_log[b[2] & 0xFF]) % 255] & 0xFF : 0;
    int a3 = (b[3] != 0) ? sm_alog[(a + sm_log[b[3] & 0xFF]) % 255] & 0xFF : 0;
    return a0 << 24 | a1 << 16 | a2 << 8 | a3;
  }

public:
  //CONSTRUCTOR
  CRijndael();

  //DESTRUCTOR
  virtual ~CRijndael();

  //Expand a user-supplied key material into a session key.
  // key        - The 128/192/256-bit user-key to use.
  // chain      - initial chain block for CBC and CFB modes.
  // keylength  - 16, 24 or 32 bytes
  // blockSize  - The block size in bytes of this Rijndael (16, 24 or 32 bytes).
  void MakeKey(char const* key, char const* chain, int keylength=DEFAULT_BLOCK_SIZE, int blockSize=DEFAULT_BLOCK_SIZE);

private:
  //Auxiliary Function
  void Xor(char* buff, char const* chain)
  {
    if(false==m_bKeyInit)
      throw exception(sm_szErrorMsg1);
    for(int i=0; i<m_blockSize; i++)
      *(buff++) ^= *(chain++);  
  }

  //Convenience method to encrypt exactly one block of plaintext, assuming
  //Rijndael's default block size (128-bit).
  // in         - The plaintext
  // result     - The ciphertext generated from a plaintext using the key
  void DefEncryptBlock(char const* in, char* result);

  //Convenience method to decrypt exactly one block of plaintext, assuming
  //Rijndael's default block size (128-bit).
  // in         - The ciphertext.
  // result     - The plaintext generated from a ciphertext using the session key.
  void DefDecryptBlock(char const* in, char* result);

public:
  //Encrypt exactly one block of plaintext.
  // in           - The plaintext.
    // result       - The ciphertext generated from a plaintext using the key.
    void EncryptBlock(char const* in, char* result);
  
  //Decrypt exactly one block of ciphertext.
  // in         - The ciphertext.
  // result     - The plaintext generated from a ciphertext using the session key.
  void DecryptBlock(char const* in, char* result);

  void Encrypt(char const* in, char* result, size_t n, int iMode=ECB);
  
  void Decrypt(char const* in, char* result, size_t n, int iMode=ECB);

  //Get Key Length
  int GetKeyLength()
  {
    if(false==m_bKeyInit)
      throw exception(sm_szErrorMsg1);
    return m_keylength;
  }

  //Block Size
  int  GetBlockSize()
  {
    if(false==m_bKeyInit)
      throw exception(sm_szErrorMsg1);
    return m_blockSize;
  }
  
  //Number of Rounds
  int GetRounds()
  {
    if(false==m_bKeyInit)
      throw exception(sm_szErrorMsg1);
    return m_iROUNDS;
  }

  void ResetChain()
  {
    memcpy(m_chain, m_chain0, m_blockSize);
  }

public:
  //Null chain
  static char const* sm_chain0;

private:
  static const int sm_alog[256];
  static const int sm_log[256];
  static const char sm_S[256];
    static const char sm_Si[256];
    static const int sm_T1[256];
    static const int sm_T2[256];
    static const int sm_T3[256];
    static const int sm_T4[256];
    static const int sm_T5[256];
    static const int sm_T6[256];
    static const int sm_T7[256];
    static const int sm_T8[256];
    static const int sm_U1[256];
    static const int sm_U2[256];
    static const int sm_U3[256];
    static const int sm_U4[256];
    static const char sm_rcon[30];
    static const int sm_shifts[3][4][2];
  //Error Messages
  static char const* sm_szErrorMsg1;
  static char const* sm_szErrorMsg2;
  //Key Initialization Flag
  bool m_bKeyInit;
  //Encryption (m_Ke) round key
  int m_Ke[MAX_ROUNDS+1][MAX_BC];
  //Decryption (m_Kd) round key
    int m_Kd[MAX_ROUNDS+1][MAX_BC];
  //Key Length
  int m_keylength;
  //Block Size
  int  m_blockSize;
  //Number of Rounds
  int m_iROUNDS;
  //Chain Block
  char m_chain0[MAX_BLOCK_SIZE];
  char m_chain[MAX_BLOCK_SIZE];
  //Auxiliary private use buffers
  int tk[MAX_KC];
  int a[MAX_BC];
  int t[MAX_BC];
};

// pragma statement on top takes care of it
// #endif // __RIJNDAEL_H__