include/aes.h

   1 #ifndef __AES_H__\r
   2 #define __AES_H__\r
   3 \r
   4 #include <cstring>\r
   5 \r
   6 using namespace std;\r
   7 \r
   8 class AES\r
   9 {\r
  10 public:\r
  11         enum { ECB=0, CBC=1, CFB=2 };\r
  12 \r
  13 private:\r
  14         enum { DEFAULT_BLOCK_SIZE=16 };\r
  15         enum { MAX_BLOCK_SIZE=32, MAX_ROUNDS=14, MAX_KC=8, MAX_BC=8 };\r
  16 \r
  17         static int Mul(int a, int b)\r
  18         {\r
  19                 return (a != 0 && b != 0) ? sm_alog[(sm_log[a & 0xFF] + sm_log[b & 0xFF]) % 255] : 0;\r
  20         }\r
  21 \r
  22         //Convenience method used in generating Transposition Boxes\r
  23         static int Mul4(int a, char b[])\r
  24         {\r
  25                 if(a == 0)\r
  26                         return 0;\r
  27                 a = sm_log[a & 0xFF];\r
  28                 int a0 = (b[0] != 0) ? sm_alog[(a + sm_log[b[0] & 0xFF]) % 255] & 0xFF : 0;\r
  29                 int a1 = (b[1] != 0) ? sm_alog[(a + sm_log[b[1] & 0xFF]) % 255] & 0xFF : 0;\r
  30                 int a2 = (b[2] != 0) ? sm_alog[(a + sm_log[b[2] & 0xFF]) % 255] & 0xFF : 0;\r
  31                 int a3 = (b[3] != 0) ? sm_alog[(a + sm_log[b[3] & 0xFF]) % 255] & 0xFF : 0;\r
  32                 return a0 << 24 | a1 << 16 | a2 << 8 | a3;\r
  33         }\r
  34 \r
  35 public:\r
  36         //CONSTRUCTOR\r
  37         AES();\r
  38 \r
  39         //DESTRUCTOR\r
  40         virtual ~AES();\r
  41 \r
  42         //Expand a user-supplied key material into a session key.\r
  43         // key        - The 128/192/256-bit user-key to use.\r
  44         // chain      - initial chain block for CBC and CFB modes.\r
  45         // keylength  - 16, 24 or 32 bytes\r
  46         // blockSize  - The block size in bytes of this Rijndael (16, 24 or 32 bytes).\r
  47         void MakeKey(char const* key, char const* chain, int keylength=DEFAULT_BLOCK_SIZE, int blockSize=DEFAULT_BLOCK_SIZE);\r
  48 \r
  49 private:\r
  50         //Auxiliary Function\r
  51         void Xor(char* buff, char const* chain)\r
  52         {\r
  53                 if(false==m_bKeyInit)\r
  54                         return;\r
  55                 for(int i=0; i<m_blockSize; i++)\r
  56                         *(buff++) ^= *(chain++);        \r
  57         }\r
  58 \r
  59         //Convenience method to encrypt exactly one block of plaintext, assuming\r
  60         //Rijndael's default block size (128-bit).\r
  61         // in         - The plaintext\r
  62         // result     - The ciphertext generated from a plaintext using the key\r
  63         void DefEncryptBlock(char const* in, char* result);\r
  64 \r
  65         //Convenience method to decrypt exactly one block of plaintext, assuming\r
  66         //Rijndael's default block size (128-bit).\r
  67         // in         - The ciphertext.\r
  68         // result     - The plaintext generated from a ciphertext using the session key.\r
  69         void DefDecryptBlock(char const* in, char* result);\r
  70 \r
  71 public:\r
  72         //Encrypt exactly one block of plaintext.\r
  73         // in           - The plaintext.\r
  74         // result       - The ciphertext generated from a plaintext using the key.\r
  75         void EncryptBlock(char const* in, char* result);\r
  76         \r
  77         //Decrypt exactly one block of ciphertext.\r
  78         // in         - The ciphertext.\r
  79         // result     - The plaintext generated from a ciphertext using the session key.\r
  80         void DecryptBlock(char const* in, char* result);\r
  81 \r
  82         void Encrypt(char const* in, char* result, size_t n, int iMode=ECB);\r
  83         \r
  84         void Decrypt(char const* in, char* result, size_t n, int iMode=ECB);\r
  85 \r
  86         //Get Key Length\r
  87         int GetKeyLength()\r
  88         {\r
  89                 if(false==m_bKeyInit)\r
  90                         return 0;\r
  91                 return m_keylength;\r
  92         }\r
  93 \r
  94         //Block Size\r
  95         int GetBlockSize()\r
  96         {\r
  97                 if(false==m_bKeyInit)\r
  98                         return 0;\r
  99                 return m_blockSize;\r
 100         }\r
 101         \r
 102         //Number of Rounds\r
 103         int GetRounds()\r
 104         {\r
 105                 if(false==m_bKeyInit)\r
 106                         return 0;\r
 107                 return m_iROUNDS;\r
 108         }\r
 109 \r
 110         void ResetChain()\r
 111         {\r
 112                 memcpy(m_chain, m_chain0, m_blockSize);\r
 113         }\r
 114 \r
 115 public:\r
 116         //Null chain\r
 117         static char const* sm_chain0;\r
 118 \r
 119 private:\r
 120         static const int sm_alog[256];\r
 121         static const int sm_log[256];\r
 122         static const char sm_S[256];\r
 123         static const char sm_Si[256];\r
 124         static const int sm_T1[256];\r
 125         static const int sm_T2[256];\r
 126         static const int sm_T3[256];\r
 127         static const int sm_T4[256];\r
 128         static const int sm_T5[256];\r
 129         static const int sm_T6[256];\r
 130         static const int sm_T7[256];\r
 131         static const int sm_T8[256];\r
 132         static const int sm_U1[256];\r
 133         static const int sm_U2[256];\r
 134         static const int sm_U3[256];\r
 135         static const int sm_U4[256];\r
 136         static const char sm_rcon[30];\r
 137         static const int sm_shifts[3][4][2];\r
 138         //Error Messages\r
 139         static char const* sm_szErrorMsg1;\r
 140         static char const* sm_szErrorMsg2;\r
 141         //Key Initialization Flag\r
 142         bool m_bKeyInit;\r
 143         //Encryption (m_Ke) round key\r
 144         int m_Ke[MAX_ROUNDS+1][MAX_BC];\r
 145         //Decryption (m_Kd) round key\r
 146         int m_Kd[MAX_ROUNDS+1][MAX_BC];\r
 147         //Key Length\r
 148         int m_keylength;\r
 149         //Block Size\r
 150         int     m_blockSize;\r
 151         //Number of Rounds\r
 152         int m_iROUNDS;\r
 153         //Chain Block\r
 154         char m_chain0[MAX_BLOCK_SIZE];\r
 155         char m_chain[MAX_BLOCK_SIZE];\r
 156         //Auxiliary private use buffers\r
 157         int tk[MAX_KC];\r
 158         int a[MAX_BC];\r
 159         int t[MAX_BC];\r
 160 };\r
 161 \r
 162 #endif // __RIJNDAEL_H__\r
 163 \r