diff options
Diffstat (limited to 'include/aesni/aes.h')
| -rw-r--r-- | include/aesni/aes.h | 955 |
1 files changed, 955 insertions, 0 deletions
diff --git a/include/aesni/aes.h b/include/aesni/aes.h new file mode 100644 index 0000000..dcee06b --- /dev/null +++ b/include/aesni/aes.h @@ -0,0 +1,955 @@ +/** + * \file + * \author Egor Tensin <Egor.Tensin@gmail.com> + * \date 2015 + * \copyright This file is licensed under the terms of the MIT License. + * See LICENSE.txt for details. + */ + +#pragma once + +#include "data.h" + +#include <assert.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + +typedef struct +{ + AesNI_Block128 keys[11]; +} +AesNI_Aes128_RoundKeys; + +typedef struct +{ + AesNI_Block128 keys[13]; +} +AesNI_Aes192_RoundKeys; + +typedef struct +{ + AesNI_Block128 keys[15]; +} +AesNI_Aes256_RoundKeys; + +void __fastcall aesni_aes128_expand_key_( + AesNI_Block128 key, + AesNI_Aes128_RoundKeys* encryption_keys); + +void __fastcall aesni_aes192_expand_key_( + AesNI_Block128 key_lo, + AesNI_Block128 key_hi, + AesNI_Aes192_RoundKeys* encryption_keys); + +void __fastcall aesni_aes256_expand_key_( + AesNI_Block128 key_lo, + AesNI_Block128 key_hi, + AesNI_Aes256_RoundKeys* encryption_keys); + +void __fastcall aesni_aes128_derive_decryption_keys_( + const AesNI_Aes128_RoundKeys* encryption_keys, + AesNI_Aes128_RoundKeys* decryption_keys); + +void __fastcall aesni_aes192_derive_decryption_keys_( + const AesNI_Aes192_RoundKeys* encryption_keys, + AesNI_Aes192_RoundKeys* decryption_keys); + +void __fastcall aesni_aes256_derive_decryption_keys_( + const AesNI_Aes256_RoundKeys* encryption_keys, + AesNI_Aes256_RoundKeys* decryption_keys); + +AesNI_Block128 __fastcall aesni_aes128_encrypt_block_( + AesNI_Block128 plaintext, + const AesNI_Aes128_RoundKeys*); + +AesNI_Block128 __fastcall aesni_aes192_encrypt_block_( + AesNI_Block128 plaintext, + const AesNI_Aes192_RoundKeys*); + +AesNI_Block128 __fastcall aesni_aes256_encrypt_block_( + AesNI_Block128 plaintext, + const AesNI_Aes256_RoundKeys*); + +AesNI_Block128 __fastcall aesni_aes128_decrypt_block_( + AesNI_Block128 ciphertext, + const AesNI_Aes128_RoundKeys*); + +AesNI_Block128 __fastcall aesni_aes192_decrypt_block_( + AesNI_Block128 ciphertext, + const AesNI_Aes192_RoundKeys*); + +AesNI_Block128 __fastcall aesni_aes256_decrypt_block_( + AesNI_Block128 ciphertext, + const AesNI_Aes256_RoundKeys*); + + + + +/** + * \brief Expands a key schedule for AES-128 encryption. + * + * \param[in] key The AES-128 key. + * \param[out] key_schedule The AES-128 encryption key schedule. Must not be + * `NULL`. + */ +static __inline void __fastcall aesni_aes128_expand_key( + AesNI_Block128 key, + AesNI_Aes128_RoundKeys* key_schedule) +{ + assert(key_schedule); + + aesni_aes128_expand_key_(key, key_schedule); +} + +/** + * \brief "Inverts" an AES-128 key schedule to prepare for decryption. + * + * \param[in] key_schedule The AES-128 encryption key schedule. Must not be + * `NULL`. + * \param[out] inverted_schedule The AES-128 decryption key schedule. Must not + * be `NULL`. + */ +static __inline void __fastcall aesni_aes128_derive_decryption_keys( + const AesNI_Aes128_RoundKeys* key_schedule, + AesNI_Aes128_RoundKeys* inverted_schedule) +{ + assert(key_schedule); + assert(inverted_schedule); + + aesni_aes128_derive_decryption_keys_(key_schedule, inverted_schedule); +} + +/** + * \brief Encrypts a 128-bit block using AES-128 in ECB mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-128 encryption key schedule. Must not be + * `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes128_encrypt_block_ecb( + AesNI_Block128 plain, + const AesNI_Aes128_RoundKeys* key_schedule) +{ + assert(key_schedule); + + return aesni_aes128_encrypt_block_(plain, key_schedule); +} + +/** + * \brief Decrypts a 128-bit block using AES-128 in ECB mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] inverted_schedule The AES-128 decryption key schedule. Must not + * be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes128_decrypt_block_ecb( + AesNI_Block128 cipher, + const AesNI_Aes128_RoundKeys* inverted_schedule) +{ + assert(inverted_schedule); + + return aesni_aes128_decrypt_block_(cipher, inverted_schedule); +} + +/** + * \brief Encrypts a 128-bit block using AES-128 in CBC mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-128 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CBC initialization vector. + * \param[out] next_init_vector The next CBC initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes128_encrypt_block_cbc( + AesNI_Block128 plain, + const AesNI_Aes128_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 cipher = aesni_aes128_encrypt_block_( + aesni_xor_block128(plain, init_vector), + key_schedule); + *next_init_vector = cipher; + return cipher; +} + +/** + * \brief Decrypts a 128-bit block using AES-128 in CBC mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] inverted_schedule The AES-128 decryption key schedule. Must not + * be `NULL`. + * \param[in] init_vector The CBC initialization vector. + * \param[out] next_init_vector The next CBC initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes128_decrypt_block_cbc( + AesNI_Block128 cipher, + const AesNI_Aes128_RoundKeys* inverted_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(inverted_schedule); + assert(next_init_vector); + + AesNI_Block128 plain = aesni_xor_block128( + aesni_aes128_decrypt_block_(cipher, inverted_schedule), + init_vector); + *next_init_vector = cipher; + return plain; +} + +/** + * \brief Encrypts a 128-bit block using AES-128 in CFB mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-128 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CFB initialization vector. + * \param[out] next_init_vector The next CFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes128_encrypt_block_cfb( + AesNI_Block128 plain, + const AesNI_Aes128_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 cipher = aesni_xor_block128( + aesni_aes128_encrypt_block_(init_vector, key_schedule), + plain); + *next_init_vector = cipher; + return cipher; +} + +/** + * \brief Decrypts a 128-bit block using AES-128 in CFB mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] key_schedule The AES-128 **encryption** key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CFB initialization vector. + * \param[out] next_init_vector The next CFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes128_decrypt_block_cfb( + AesNI_Block128 cipher, + const AesNI_Aes128_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 plain = aesni_xor_block128( + aesni_aes128_encrypt_block_(init_vector, key_schedule), + cipher); + *next_init_vector = cipher; + return plain; +} + +/** + * \brief Encrypts a 128-bit block using AES-128 in OFB mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-128 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The OFB initialization vector. + * \param[out] next_init_vector The next OFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes128_encrypt_block_ofb( + AesNI_Block128 plain, + const AesNI_Aes128_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 tmp = aesni_aes128_encrypt_block_(init_vector, key_schedule); + *next_init_vector = tmp; + return aesni_xor_block128(tmp, plain); +} + +/** + * \brief Decrypts a 128-bit block using AES-128 in OFB mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] key_schedule The AES-128 **encryption** key schedule. Must not be + * `NULL`. + * \param[in] init_vector The OFB initialization vector. + * \param[out] next_init_vector The next OFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes128_decrypt_block_ofb( + AesNI_Block128 cipher, + const AesNI_Aes128_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 tmp = aesni_aes128_encrypt_block_(init_vector, key_schedule); + *next_init_vector = tmp; + return aesni_xor_block128(tmp, cipher); +} + +/** + * \brief Encrypts a 128-bit block using AES-128 in CTR mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-128 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CTR initialization vector. + * \param[in] counter The counter, typically incremented between consecutive + * calls. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes128_encrypt_block_ctr( + AesNI_Block128 plain, + const AesNI_Aes128_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + int counter) +{ + assert(key_schedule); + + init_vector = aesni_be2le128(_mm_add_epi32( + aesni_le2be128(init_vector), + aesni_make_block128(0, 0, 0, counter))); + + return aesni_xor_block128( + plain, + aesni_aes128_encrypt_block_(init_vector, key_schedule)); +} + +/** + * \brief Decrypts a 128-bit block using AES-128 in CTR mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] key_schedule The AES-128 **encryption** key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CTR initialization vector. + * \param[in] counter The counter, typically incremented between consecutive + * calls. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes128_decrypt_block_ctr( + AesNI_Block128 cipher, + const AesNI_Aes128_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + int counter) +{ + assert(key_schedule); + + init_vector = aesni_be2le128(_mm_add_epi32( + aesni_le2be128(init_vector), + aesni_make_block128(0, 0, 0, counter))); + + return aesni_xor_block128( + cipher, + aesni_aes128_encrypt_block_(init_vector, key_schedule)); +} + +/** + * \} + * + * \defgroup aesni_block_api_aes192 AES-192 + * \{ + */ + +/** + * \brief Expands a key schedule for AES-192 encryption. + * + * \param[in] key The AES-192 key. Must not be `NULL`. + * \param[out] key_schedule The AES-192 encryption key schedule. Must not be + * `NULL`. + */ +static __inline void __fastcall aesni_aes192_expand_key( + AesNI_Block192* key, + AesNI_Aes192_RoundKeys* key_schedule) +{ + assert(key); + assert(key_schedule); + + aesni_aes192_expand_key_(key->lo, key->hi, key_schedule); +} + +/** + * \brief "Inverts" an AES-192 key schedule to prepare for decryption. + * + * \param[in] key_schedule The AES-192 encryption key schedule. Must not be + * `NULL`. + * \param[out] inverted_schedule The AES-192 decryption key schedule. Must not + * be `NULL`. + */ +static __inline void __fastcall aesni_aes192_derive_decryption_keys( + const AesNI_Aes192_RoundKeys* key_schedule, + AesNI_Aes192_RoundKeys* inverted_schedule) +{ + assert(key_schedule); + assert(inverted_schedule); + + aesni_aes192_derive_decryption_keys_(key_schedule, inverted_schedule); +} + +/** + * \brief Encrypts a 128-bit block using AES-192 in ECB mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-192 encryption key schedule. Must not be + * `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes192_encrypt_block_ecb( + AesNI_Block128 plain, + const AesNI_Aes192_RoundKeys* key_schedule) +{ + assert(key_schedule); + + return aesni_aes192_encrypt_block_(plain, key_schedule); +} + +/** + * \brief Decrypts a 128-bit block using AES-192 in ECB mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] inverted_schedule The AES-192 decryption key schedule. Must not + * be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes192_decrypt_block_ecb( + AesNI_Block128 cipher, + const AesNI_Aes192_RoundKeys* inverted_schedule) +{ + assert(inverted_schedule); + + return aesni_aes192_decrypt_block_(cipher, inverted_schedule); +} + +/** + * \brief Encrypts a 128-bit block using AES-192 in CBC mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-192 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CBC initialization vector. + * \param[out] next_init_vector The next CBC initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes192_encrypt_block_cbc( + AesNI_Block128 plain, + const AesNI_Aes192_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 cipher = aesni_aes192_encrypt_block_( + aesni_xor_block128(plain, init_vector), + key_schedule); + *next_init_vector = cipher; + return cipher; +} + +/** + * \brief Decrypts a 128-bit block using AES-192 in CBC mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] inverted_schedule The AES-192 decryption key schedule. Must not + * be `NULL`. + * \param[in] init_vector The CBC initialization vector. + * \param[out] next_init_vector The next CBC initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes192_decrypt_block_cbc( + AesNI_Block128 cipher, + const AesNI_Aes192_RoundKeys* inverted_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(inverted_schedule); + assert(next_init_vector); + + AesNI_Block128 plain = aesni_xor_block128( + aesni_aes192_decrypt_block_(cipher, inverted_schedule), + init_vector); + *next_init_vector = cipher; + return plain; +} + +/** + * \brief Encrypts a 128-bit block using AES-192 in CFB mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-192 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CFB initialization vector. + * \param[out] next_init_vector The next CFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes192_encrypt_block_cfb( + AesNI_Block128 plain, + const AesNI_Aes192_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 cipher = aesni_xor_block128( + aesni_aes192_encrypt_block_(init_vector, key_schedule), + plain); + *next_init_vector = cipher; + return cipher; +} + +/** + * \brief Decrypts a 128-bit block using AES-192 in CFB mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] key_schedule The AES-192 **encryption** key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CFB initialization vector. + * \param[out] next_init_vector The next CFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes192_decrypt_block_cfb( + AesNI_Block128 cipher, + const AesNI_Aes192_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 plain = aesni_xor_block128( + aesni_aes192_encrypt_block_(init_vector, key_schedule), + cipher); + *next_init_vector = cipher; + return plain; +} + +/** + * \brief Encrypts a 128-bit block using AES-192 in OFB mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-192 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The OFB initialization vector. + * \param[out] next_init_vector The next OFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes192_encrypt_block_ofb( + AesNI_Block128 plain, + const AesNI_Aes192_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 tmp = aesni_aes192_encrypt_block_(init_vector, key_schedule); + *next_init_vector = tmp; + return aesni_xor_block128(tmp, plain); +} + +/** + * \brief Decrypts a 128-bit block using AES-192 in OFB mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] key_schedule The AES-192 **encryption** key schedule. Must not be + * `NULL`. + * \param[in] init_vector The OFB initialization vector. + * \param[out] next_init_vector The next OFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes192_decrypt_block_ofb( + AesNI_Block128 cipher, + const AesNI_Aes192_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 tmp = aesni_aes192_encrypt_block_(init_vector, key_schedule); + *next_init_vector = tmp; + return aesni_xor_block128(tmp, cipher); +} + +/** + * \brief Encrypts a 128-bit block using AES-192 in CTR mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-192 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CTR initialization vector. + * \param[in] counter The counter, typically incremented between consecutive + * calls. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes192_encrypt_block_ctr( + AesNI_Block128 plain, + const AesNI_Aes192_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + int counter) +{ + assert(key_schedule); + + init_vector = aesni_be2le128(_mm_add_epi32( + aesni_le2be128(init_vector), + aesni_make_block128(0, 0, 0, counter))); + + return aesni_xor_block128( + plain, + aesni_aes192_encrypt_block_(init_vector, key_schedule)); +} + +/** + * \brief Decrypts a 128-bit block using AES-192 in CTR mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] key_schedule The AES-192 **encryption** key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CTR initialization vector. + * \param[in] counter The counter, typically incremented between consecutive + * calls. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes192_decrypt_block_ctr( + AesNI_Block128 cipher, + const AesNI_Aes192_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + int counter) +{ + assert(key_schedule); + + init_vector = aesni_be2le128(_mm_add_epi32( + aesni_le2be128(init_vector), + aesni_make_block128(0, 0, 0, counter))); + + return aesni_xor_block128( + cipher, + aesni_aes192_encrypt_block_(init_vector, key_schedule)); +} + +/** + * \} + * + * \defgroup aesni_block_api_aes256 AES-256 + * \{ + */ + +/** + * \brief Expands a key schedule for AES-256 encryption. + * + * \param[in] key The AES-256 key. Must not be `NULL`. + * \param[out] key_schedule The AES-256 encryption key schedule. Must not be + * `NULL`. + */ +static __inline void __fastcall aesni_aes256_expand_key( + const AesNI_Block256* key, + AesNI_Aes256_RoundKeys* key_schedule) +{ + assert(key); + assert(key_schedule); + + aesni_aes256_expand_key_(key->lo, key->hi, key_schedule); +} + +/** + * \brief "Inverts" an AES-256 key schedule to prepare for decryption. + * + * \param[in] key_schedule The AES-256 encryption key schedule. Must not be + * `NULL`. + * \param[out] inverted_schedule The AES-256 decryption key schedule. Must not + * be `NULL`. + */ +static __inline void __fastcall aesni_aes256_derive_decryption_keys( + const AesNI_Aes256_RoundKeys* key_schedule, + AesNI_Aes256_RoundKeys* inverted_schedule) +{ + assert(key_schedule); + assert(inverted_schedule); + + aesni_aes256_derive_decryption_keys_(key_schedule, inverted_schedule); +} + +/** + * \brief Encrypts a 128-bit block using AES-256 in ECB mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-256 encryption key schedule. Must not be + * `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes256_encrypt_block_ecb( + AesNI_Block128 plain, + const AesNI_Aes256_RoundKeys* key_schedule) +{ + assert(key_schedule); + + return aesni_aes256_encrypt_block_(plain, key_schedule); +} + +/** + * \brief Decrypts a 128-bit block using AES-256 in ECB mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] inverted_schedule The AES-256 decryption key schedule. Must not + * be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes256_decrypt_block_ecb( + AesNI_Block128 cipher, + const AesNI_Aes256_RoundKeys* inverted_schedule) +{ + assert(inverted_schedule); + + return aesni_aes256_decrypt_block_(cipher, inverted_schedule); +} + +/** + * \brief Encrypts a 128-bit block using AES-256 in CBC mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-256 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CBC initialization vector. + * \param[out] next_init_vector The next CBC initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes256_encrypt_block_cbc( + AesNI_Block128 plain, + const AesNI_Aes256_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 cipher = aesni_aes256_encrypt_block_( + aesni_xor_block128(plain, init_vector), + key_schedule); + *next_init_vector = cipher; + return cipher; +} + +/** + * \brief Decrypts a 128-bit block using AES-256 in CBC mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] inverted_schedule The AES-256 decryption key schedule. Must not + * be `NULL`. + * \param[in] init_vector The CBC initialization vector. + * \param[out] next_init_vector The next CBC initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes256_decrypt_block_cbc( + AesNI_Block128 cipher, + const AesNI_Aes256_RoundKeys* inverted_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(inverted_schedule); + assert(next_init_vector); + + AesNI_Block128 plain = aesni_xor_block128( + aesni_aes256_decrypt_block_(cipher, inverted_schedule), + init_vector); + *next_init_vector = cipher; + return plain; +} + +/** + * \brief Encrypts a 128-bit block using AES-256 in CFB mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-256 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CFB initialization vector. + * \param[out] next_init_vector The next CFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes256_encrypt_block_cfb( + AesNI_Block128 plain, + const AesNI_Aes256_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 cipher = aesni_xor_block128( + aesni_aes256_encrypt_block_(init_vector, key_schedule), + plain); + *next_init_vector = cipher; + return cipher; +} + +/** + * \brief Decrypts a 128-bit block using AES-256 in CFB mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] key_schedule The AES-256 **encryption** key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CFB initialization vector. + * \param[out] next_init_vector The next CFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes256_decrypt_block_cfb( + AesNI_Block128 cipher, + const AesNI_Aes256_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 plain = aesni_xor_block128( + aesni_aes256_encrypt_block_(init_vector, key_schedule), + cipher); + *next_init_vector = cipher; + return plain; +} + +/** + * \brief Encrypts a 128-bit block using AES-256 in OFB mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-256 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The OFB initialization vector. + * \param[out] next_init_vector The next OFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes256_encrypt_block_ofb( + AesNI_Block128 plain, + const AesNI_Aes256_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 tmp = aesni_aes256_encrypt_block_(init_vector, key_schedule); + *next_init_vector = tmp; + return aesni_xor_block128(tmp, plain); +} + +/** + * \brief Decrypts a 128-bit block using AES-256 in OFB mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] key_schedule The AES-256 **encryption** key schedule. Must not be + * `NULL`. + * \param[in] init_vector The OFB initialization vector. + * \param[out] next_init_vector The next OFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes256_decrypt_block_ofb( + AesNI_Block128 cipher, + const AesNI_Aes256_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 tmp = aesni_aes256_encrypt_block_(init_vector, key_schedule); + *next_init_vector = tmp; + return aesni_xor_block128(tmp, cipher); +} + +/** + * \brief Encrypts a 128-bit block using AES-256 in CTR mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-256 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CTR initialization vector. + * \param[in] counter The counter, typically incremented between consecutive + * calls. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes256_encrypt_block_ctr( + AesNI_Block128 plain, + const AesNI_Aes256_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + int counter) +{ + assert(key_schedule); + + init_vector = aesni_be2le128(_mm_add_epi32( + aesni_le2be128(init_vector), + aesni_make_block128(0, 0, 0, counter))); + + return aesni_xor_block128( + plain, + aesni_aes256_encrypt_block_(init_vector, key_schedule)); +} + +/** + * \brief Decrypts a 128-bit block using AES-256 in CTR mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] key_schedule The AES-256 **encryption** key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CTR initialization vector. + * \param[in] counter The counter, typically incremented between consecutive + * calls. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes256_decrypt_block_ctr( + AesNI_Block128 cipher, + const AesNI_Aes256_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + int counter) +{ + assert(key_schedule); + + init_vector = aesni_be2le128(_mm_add_epi32( + aesni_le2be128(init_vector), + aesni_make_block128(0, 0, 0, counter))); + + return aesni_xor_block128( + cipher, + aesni_aes256_encrypt_block_(init_vector, key_schedule)); +} + +#ifdef __cplusplus +} +#endif |