vmrijndael.h

TOOL (Tiny Object Oriented Language) is an easily-embedded, object-oriented, C++-like-language inter

#ifndef VM_RIJNDAEL_H_ENCRYPTION_CLASSES_INCLUDED
#define VM_RIJNDAEL_H_ENCRYPTION_CLASSES_INCLUDED
/*****************************************************************************/
/*                              HEADER FILE                                  */
/*****************************************************************************/
/*
       $Archive:   $

      $Revision:   $
          $Date:   $
        $Author:   $

    Description:   Declaration of the Rijndael encryption classes. This file
                   was part of a project found on the web. It has been reworked
                   and significantly cleaned up so it may not resemble the 
                   original file very much at all. The original authors comments
                   follow:

                   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.

                  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.
*/
/*****************************************************************************/

#include <exception>
#include <cstring>

//using namespace std;

class VMRijndael
{
public:
  enum { ECB=0, CBC=1, CFB=2 };

private:
  enum { DEFAULT_BLOCK_SIZE = 16 };

  //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
  VMRijndael();

  //DESTRUCTOR
  virtual ~VMRijndael();

  //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(m_pchErrorMsg1);
    for(int i=0; i<m_iBlockSize; 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(m_pchErrorMsg1);
    return m_iKeyLength;
  }

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

  void ResetChain()
  {
    memcpy(m_pchChain, m_pchChain0, m_iBlockSize);
  }


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 ];

  static char const* m_pchErrorMsg1;   // error messages
  static char const* m_pchErrorMsg2;

  bool  m_bKeyInit;        // key initialization flag
  int** m_ppiEncRoundKey;  // encryption (m_Ke) round key
  int** m_ppiDecRoundKey;  // decryption (m_Kd) round key
  int   m_iKeyLength;      // key length
  int   m_iBlockSize;      // block size
  int   m_iROUNDS;         // number of rounds
  char* m_pchChain0;       // chain block
  char* m_pchChain;
};


#endif


/*****************************************************************************/
/* Check-in history */
/*
 *$Log:  $
*/
/*****************************************************************************/