version2/src/C/aes.h

   1 /*********************************************************************\r
   2 * Filename:   aes.h\r
   3 * Author:     Brad Conte (brad AT bradconte.com)\r
   4 * Copyright:\r
   5 * Disclaimer: This code is presented "as is" without any guarantees.\r
   6 * Details:    Defines the API for the corresponding AES implementation.\r
   7 *********************************************************************/\r
   8 \r
   9 #ifndef AES_H\r
  10 #define AES_H\r
  11 \r
  12 /*************************** HEADER FILES ***************************/\r
  13 #include <stddef.h>\r
  14 \r
  15 /****************************** MACROS ******************************/\r
  16 #define AES_BLOCK_SIZE 16               // AES operates on 16 bytes at a time\r
  17 \r
  18 /**************************** DATA TYPES ****************************/\r
  19 typedef unsigned char BYTE;            // 8-bit byte\r
  20 typedef unsigned int WORD;             // 32-bit word, change to "long" for 16-bit machines\r
  21 \r
  22 /*********************** FUNCTION DECLARATIONS **********************/\r
  23 ///////////////////\r
  24 // AES\r
  25 ///////////////////\r
  26 // Key setup must be done before any AES en/de-cryption functions can be used.\r
  27 void aes_key_setup(const BYTE key[],          // The key, must be 128, 192, or 256 bits\r
  28                    WORD w[],                  // Output key schedule to be used later\r
  29                    int keysize);              // Bit length of the key, 128, 192, or 256\r
  30 \r
  31 void aes_encrypt(const BYTE in[],             // 16 bytes of plaintext\r
  32                  BYTE out[],                  // 16 bytes of ciphertext\r
  33                  const WORD key[],            // From the key setup\r
  34                  int keysize);                // Bit length of the key, 128, 192, or 256\r
  35 \r
  36 void aes_decrypt(const BYTE in[],             // 16 bytes of ciphertext\r
  37                  BYTE out[],                  // 16 bytes of plaintext\r
  38                  const WORD key[],            // From the key setup\r
  39                  int keysize);                // Bit length of the key, 128, 192, or 256\r
  40 \r
  41 ///////////////////\r
  42 // AES - CBC\r
  43 ///////////////////\r
  44 int aes_encrypt_cbc(const BYTE in[],          // Plaintext\r
  45                     size_t in_len,            // Must be a multiple of AES_BLOCK_SIZE\r
  46                     BYTE out[],               // Ciphertext, same length as plaintext\r
  47                     const WORD key[],         // From the key setup\r
  48                     int keysize,              // Bit length of the key, 128, 192, or 256\r
  49                     const BYTE iv[]);         // IV, must be AES_BLOCK_SIZE bytes long\r
  50 \r
  51 // Only output the CBC-MAC of the input.\r
  52 int aes_encrypt_cbc_mac(const BYTE in[],      // plaintext\r
  53                         size_t in_len,        // Must be a multiple of AES_BLOCK_SIZE\r
  54                         BYTE out[],           // Output MAC\r
  55                         const WORD key[],     // From the key setup\r
  56                         int keysize,          // Bit length of the key, 128, 192, or 256\r
  57                         const BYTE iv[]);     // IV, must be AES_BLOCK_SIZE bytes long\r
  58 \r
  59 ///////////////////\r
  60 // AES - CTR\r
  61 ///////////////////\r
  62 void increment_iv(BYTE iv[],                  // Must be a multiple of AES_BLOCK_SIZE\r
  63                   int counter_size);          // Bytes of the IV used for counting (low end)\r
  64 \r
  65 void aes_encrypt_ctr(const BYTE in[],         // Plaintext\r
  66                      size_t in_len,           // Any byte length\r
  67                      BYTE out[],              // Ciphertext, same length as plaintext\r
  68                      const WORD key[],        // From the key setup\r
  69                      int keysize,             // Bit length of the key, 128, 192, or 256\r
  70                      const BYTE iv[]);        // IV, must be AES_BLOCK_SIZE bytes long\r
  71 \r
  72 void aes_decrypt_ctr(const BYTE in[],         // Ciphertext\r
  73                      size_t in_len,           // Any byte length\r
  74                      BYTE out[],              // Plaintext, same length as ciphertext\r
  75                      const WORD key[],        // From the key setup\r
  76                      int keysize,             // Bit length of the key, 128, 192, or 256\r
  77                      const BYTE iv[]);        // IV, must be AES_BLOCK_SIZE bytes long\r
  78 \r
  79 ///////////////////\r
  80 // AES - CCM\r
  81 ///////////////////\r
  82 // Returns True if the input parameters do not violate any constraint.\r
  83 int aes_encrypt_ccm(const BYTE plaintext[],              // IN  - Plaintext.\r
  84                     WORD plaintext_len,                  // IN  - Plaintext length.\r
  85                     const BYTE associated_data[],        // IN  - Associated Data included in authentication, but not encryption.\r
  86                     unsigned short associated_data_len,  // IN  - Associated Data length in bytes.\r
  87                     const BYTE nonce[],                  // IN  - The Nonce to be used for encryption.\r
  88                     unsigned short nonce_len,            // IN  - Nonce length in bytes.\r
  89                     BYTE ciphertext[],                   // OUT - Ciphertext, a concatination of the plaintext and the MAC.\r
  90                     WORD *ciphertext_len,                // OUT - The length of the ciphertext, always plaintext_len + mac_len.\r
  91                     WORD mac_len,                        // IN  - The desired length of the MAC, must be 4, 6, 8, 10, 12, 14, or 16.\r
  92                     const BYTE key[],                    // IN  - The AES key for encryption.\r
  93                     int keysize);                        // IN  - The length of the key in bits. Valid values are 128, 192, 256.\r
  94 \r
  95 // Returns True if the input parameters do not violate any constraint.\r
  96 // Use mac_auth to ensure decryption/validation was preformed correctly.\r
  97 // If authentication does not succeed, the plaintext is zeroed out. To overwride\r
  98 // this, call with mac_auth = NULL. The proper proceedure is to decrypt with\r
  99 // authentication enabled (mac_auth != NULL) and make a second call to that\r
 100 // ignores authentication explicitly if the first call failes.\r
 101 int aes_decrypt_ccm(const BYTE ciphertext[],             // IN  - Ciphertext, the concatination of encrypted plaintext and MAC.\r
 102                     WORD ciphertext_len,                 // IN  - Ciphertext length in bytes.\r
 103                     const BYTE assoc[],                  // IN  - The Associated Data, required for authentication.\r
 104                     unsigned short assoc_len,            // IN  - Associated Data length in bytes.\r
 105                     const BYTE nonce[],                  // IN  - The Nonce to use for decryption, same one as for encryption.\r
 106                     unsigned short nonce_len,            // IN  - Nonce length in bytes.\r
 107                     BYTE plaintext[],                    // OUT - The plaintext that was decrypted. Will need to be large enough to hold ciphertext_len - mac_len.\r
 108                     WORD *plaintext_len,                 // OUT - Length in bytes of the output plaintext, always ciphertext_len - mac_len .\r
 109                     WORD mac_len,                        // IN  - The length of the MAC that was calculated.\r
 110                     int *mac_auth,                       // OUT - TRUE if authentication succeeded, FALSE if it did not. NULL pointer will ignore the authentication.\r
 111                     const BYTE key[],                    // IN  - The AES key for decryption.\r
 112                     int keysize);                        // IN  - The length of the key in BITS. Valid values are 128, 192, 256.\r
 113 \r
 114 ///////////////////\r
 115 // Test functions\r
 116 ///////////////////\r
 117 int aes_test();\r
 118 int aes_ecb_test();\r
 119 int aes_cbc_test();\r
 120 int aes_ctr_test();\r
 121 int aes_ccm_test();\r
 122 \r
 123 #endif   // AES_H\r