Line data    Source code

       1             : /* SPDX-License-Identifier: GPL-2.0 */
       2             : /*
       3             :  * Common values for AES algorithms
       4             :  */
       5             : 
       6             : #ifndef _CRYPTO_AES_H
       7             : #define _CRYPTO_AES_H
       8             : 
       9             : #include <linux/types.h>
      10             : #include <linux/crypto.h>
      11             : 
      12             : #define AES_MIN_KEY_SIZE        16
      13             : #define AES_MAX_KEY_SIZE        32
      14             : #define AES_KEYSIZE_128         16
      15             : #define AES_KEYSIZE_192         24
      16             : #define AES_KEYSIZE_256         32
      17             : #define AES_BLOCK_SIZE          16
      18             : #define AES_MAX_KEYLENGTH       (15 * 16)
      19             : #define AES_MAX_KEYLENGTH_U32   (AES_MAX_KEYLENGTH / sizeof(u32))
      20             : 
      21             : /*
      22             :  * Please ensure that the first two fields are 16-byte aligned
      23             :  * relative to the start of the structure, i.e., don't move them!
      24             :  */
      25             : struct crypto_aes_ctx {
      26             :         u32 key_enc[AES_MAX_KEYLENGTH_U32];
      27             :         u32 key_dec[AES_MAX_KEYLENGTH_U32];
      28             :         u32 key_length;
      29             : };
      30             : 
      31             : extern const u32 crypto_ft_tab[4][256] ____cacheline_aligned;
      32             : extern const u32 crypto_it_tab[4][256] ____cacheline_aligned;
      33             : 
      34             : /*
      35             :  * validate key length for AES algorithms
      36             :  */
      37           0 : static inline int aes_check_keylen(unsigned int keylen)
      38             : {
      39           0 :         switch (keylen) {
      40             :         case AES_KEYSIZE_128:
      41             :         case AES_KEYSIZE_192:
      42             :         case AES_KEYSIZE_256:
      43           0 :                 break;
      44             :         default:
      45             :                 return -EINVAL;
      46             :         }
      47             : 
      48           0 :         return 0;
      49             : }
      50             : 
      51             : int crypto_aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
      52             :                 unsigned int key_len);
      53             : 
      54             : /**
      55             :  * aes_expandkey - Expands the AES key as described in FIPS-197
      56             :  * @ctx:        The location where the computed key will be stored.
      57             :  * @in_key:     The supplied key.
      58             :  * @key_len:    The length of the supplied key.
      59             :  *
      60             :  * Returns 0 on success. The function fails only if an invalid key size (or
      61             :  * pointer) is supplied.
      62             :  * The expanded key size is 240 bytes (max of 14 rounds with a unique 16 bytes
      63             :  * key schedule plus a 16 bytes key which is used before the first round).
      64             :  * The decryption key is prepared for the "Equivalent Inverse Cipher" as
      65             :  * described in FIPS-197. The first slot (16 bytes) of each key (enc or dec) is
      66             :  * for the initial combination, the second slot for the first round and so on.
      67             :  */
      68             : int aes_expandkey(struct crypto_aes_ctx *ctx, const u8 *in_key,
      69             :                   unsigned int key_len);
      70             : 
      71             : /**
      72             :  * aes_encrypt - Encrypt a single AES block
      73             :  * @ctx:        Context struct containing the key schedule
      74             :  * @out:        Buffer to store the ciphertext
      75             :  * @in:         Buffer containing the plaintext
      76             :  */
      77             : void aes_encrypt(const struct crypto_aes_ctx *ctx, u8 *out, const u8 *in);
      78             : 
      79             : /**
      80             :  * aes_decrypt - Decrypt a single AES block
      81             :  * @ctx:        Context struct containing the key schedule
      82             :  * @out:        Buffer to store the plaintext
      83             :  * @in:         Buffer containing the ciphertext
      84             :  */
      85             : void aes_decrypt(const struct crypto_aes_ctx *ctx, u8 *out, const u8 *in);
      86             : 
      87             : extern const u8 crypto_aes_sbox[];
      88             : extern const u8 crypto_aes_inv_sbox[];
      89             : 
      90             : #endif