include/aes.h

   1 #ifndef __AES_H__\r
   2 #define __AES_H__\r
   3 \r
   4 #include <cstring>\r
   5 #include "base.h"\r
   6 \r
   7 using namespace std;\r
   8 \r
   9 /** The AES class is a utility class for use in modules and the core for encryption of data.\r
  10  */\r
  11 class AES : public classbase\r
  12 {\r
  13 public:\r
  14         enum { ECB=0, CBC=1, CFB=2 };\r
  15 \r
  16 private:\r
  17         enum { DEFAULT_BLOCK_SIZE=16 };\r
  18         enum { MAX_BLOCK_SIZE=32, MAX_ROUNDS=14, MAX_KC=8, MAX_BC=8 };\r
  19 \r
  20         static int Mul(int a, int b)\r
  21         {\r
  22                 return (a != 0 && b != 0) ? sm_alog[(sm_log[a & 0xFF] + sm_log[b & 0xFF]) % 255] : 0;\r
  23         }\r
  24 \r
  25         /** Convenience method used in generating Transposition Boxes\r
  26          */\r
  27         static int Mul4(int a, char b[])\r
  28         {\r
  29                 if(a == 0)\r
  30                         return 0;\r
  31                 a = sm_log[a & 0xFF];\r
  32                 int a0 = (b[0] != 0) ? sm_alog[(a + sm_log[b[0] & 0xFF]) % 255] & 0xFF : 0;\r
  33                 int a1 = (b[1] != 0) ? sm_alog[(a + sm_log[b[1] & 0xFF]) % 255] & 0xFF : 0;\r
  34                 int a2 = (b[2] != 0) ? sm_alog[(a + sm_log[b[2] & 0xFF]) % 255] & 0xFF : 0;\r
  35                 int a3 = (b[3] != 0) ? sm_alog[(a + sm_log[b[3] & 0xFF]) % 255] & 0xFF : 0;\r
  36                 return a0 << 24 | a1 << 16 | a2 << 8 | a3;\r
  37         }\r
  38 \r
  39 public:\r
  40         AES();\r
  41 \r
  42         virtual ~AES();\r
  43 \r
  44         /** Expand a user-supplied key material into a session key.\r
  45          * \r
  46          * @param key The 128/192/256-bit user-key to use.\r
  47          * @param chain Initial chain block for CBC and CFB modes.\r
  48          * @param keylength 16, 24 or 32 bytes\r
  49          * @param blockSize The block size in bytes of this Rijndael (16, 24 or 32 bytes).\r
  50          */\r
  51         void MakeKey(char const* key, char const* chain, int keylength=DEFAULT_BLOCK_SIZE, int blockSize=DEFAULT_BLOCK_SIZE);\r
  52 \r
  53 private:\r
  54         /** Auxiliary Function\r
  55          */\r
  56         void Xor(char* buff, char const* chain)\r
  57         {\r
  58                 if(false==m_bKeyInit)\r
  59                         return;\r
  60                 for(int i=0; i<m_blockSize; i++)\r
  61                         *(buff++) ^= *(chain++);        \r
  62         }\r
  63 \r
  64         /** Convenience method to encrypt exactly one block of plaintext, assuming Rijndael's default block size (128-bit).\r
  65          * @param in The plaintext\r
  66          * @param result The ciphertext generated from a plaintext using the key\r
  67          */\r
  68         void DefEncryptBlock(char const* in, char* result);\r
  69 \r
  70         /** Convenience method to decrypt exactly one block of plaintext, assuming Rijndael's default block size (128-bit).\r
  71          * @param in The ciphertext.\r
  72          * @param result The plaintext generated from a ciphertext using the session key.\r
  73          */\r
  74         void DefDecryptBlock(char const* in, char* result);\r
  75 \r
  76 public:\r
  77         /** Encrypt exactly one block of plaintext.\r
  78          * @param in The plaintext.\r
  79          * @param result The ciphertext generated from a plaintext using the key.\r
  80          */\r
  81         void EncryptBlock(char const* in, char* result);\r
  82         \r
  83         /** Decrypt exactly one block of ciphertext.\r
  84          * @param in The ciphertext.\r
  85          * @param result The plaintext generated from a ciphertext using the session key.\r
  86          */\r
  87         void DecryptBlock(char const* in, char* result);\r
  88 \r
  89         /** Encrypt multiple blocks of plaintext.\r
  90          * @param n Number of bytes to encrypt, must be a multiple of the keysize\r
  91          * @param in The plaintext to encrypt\r
  92          * @param result The output ciphertext\r
  93          * @param iMode Mode to use\r
  94          */\r
  95         void Encrypt(char const* in, char* result, size_t n, int iMode=ECB);\r
  96         \r
  97         /** Decrypt multiple blocks of ciphertext.\r
  98          * @param n Number of bytes to decrypt, must be a multiple of the keysize\r
  99          * @param in The ciphertext to decrypt\r
 100          * @param result The output plaintext\r
 101          * @param iMode Mode to use\r
 102          */\r
 103         void Decrypt(char const* in, char* result, size_t n, int iMode=ECB);\r
 104 \r
 105         /** Get Key Length\r
 106          */\r
 107         int GetKeyLength()\r
 108         {\r
 109                 if(false==m_bKeyInit)\r
 110                         return 0;\r
 111                 return m_keylength;\r
 112         }\r
 113 \r
 114         /** Get Block Size\r
 115          */\r
 116         int GetBlockSize()\r
 117         {\r
 118                 if(false==m_bKeyInit)\r
 119                         return 0;\r
 120                 return m_blockSize;\r
 121         }\r
 122         \r
 123         /** Get Number of Rounds\r
 124          */\r
 125         int GetRounds()\r
 126         {\r
 127                 if(false==m_bKeyInit)\r
 128                         return 0;\r
 129                 return m_iROUNDS;\r
 130         }\r
 131 \r
 132         /** Reset the chain\r
 133          */\r
 134         void ResetChain()\r
 135         {\r
 136                 memcpy(m_chain, m_chain0, m_blockSize);\r
 137         }\r
 138 \r
 139 public:\r
 140         /** Null chain\r
 141          */\r
 142         static char const* sm_chain0;\r
 143 \r
 144 private:\r
 145         static const int sm_alog[256];\r
 146         static const int sm_log[256];\r
 147         static const char sm_S[256];\r
 148         static const char sm_Si[256];\r
 149         static const int sm_T1[256];\r
 150         static const int sm_T2[256];\r
 151         static const int sm_T3[256];\r
 152         static const int sm_T4[256];\r
 153         static const int sm_T5[256];\r
 154         static const int sm_T6[256];\r
 155         static const int sm_T7[256];\r
 156         static const int sm_T8[256];\r
 157         static const int sm_U1[256];\r
 158         static const int sm_U2[256];\r
 159         static const int sm_U3[256];\r
 160         static const int sm_U4[256];\r
 161         static const char sm_rcon[30];\r
 162         static const int sm_shifts[3][4][2];\r
 163         /** Key Initialization Flag\r
 164          */\r
 165         bool m_bKeyInit;\r
 166         /** Encryption (m_Ke) round key\r
 167          */\r
 168         int m_Ke[MAX_ROUNDS+1][MAX_BC];\r
 169         /** Decryption (m_Kd) round key\r
 170          */\r
 171         int m_Kd[MAX_ROUNDS+1][MAX_BC];\r
 172         /** Key Length\r
 173          */\r
 174         int m_keylength;\r
 175         /** Block Size\r
 176          */\r
 177         int     m_blockSize;\r
 178         /** Number of Rounds\r
 179          */\r
 180         int m_iROUNDS;\r
 181         /**Chain Block\r
 182          */\r
 183         char m_chain0[MAX_BLOCK_SIZE];\r
 184         char m_chain[MAX_BLOCK_SIZE];\r
 185         /** Auxiliary private use buffers\r
 186          */\r
 187         int tk[MAX_KC];\r
 188         int a[MAX_BC];\r
 189         int t[MAX_BC];\r
 190 };\r
 191 \r
 192 #endif\r
 193 \r
 194 /** Convert from binary to base64\r
 195  * @param out Output\r
 196  * @param in Input\r
 197  * @param inlen Number of bytes in input buffer\r
 198  */\r
 199 \r
 200 void to64frombits(unsigned char *out, const unsigned char *in, int inlen);\r
 201 /** Convert from base64 to binary\r
 202  * @out Output\r
 203  * @in Input\r
 204  * @maxlen Size of output buffer\r
 205  * @return Number of bytes actually converted\r
 206  */\r
 207 int from64tobits(char *out, const char *in, int maxlen);\r
 208 \r