[thirdparty/openssl.git] / include / crypto / aes_platform.h

/*
 * Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#ifndef OSSL_AES_PLATFORM_H
# define OSSL_AES_PLATFORM_H
# pragma once

# include "openssl/aes.h"

# ifdef VPAES_ASM
int vpaes_set_encrypt_key(const unsigned char *userKey, int bits,
                          AES_KEY *key);
int vpaes_set_decrypt_key(const unsigned char *userKey, int bits,
                          AES_KEY *key);
void vpaes_encrypt(const unsigned char *in, unsigned char *out,
                   const AES_KEY *key);
void vpaes_decrypt(const unsigned char *in, unsigned char *out,
                   const AES_KEY *key);
void vpaes_cbc_encrypt(const unsigned char *in,
                       unsigned char *out,
                       size_t length,
                       const AES_KEY *key, unsigned char *ivec, int enc);
# endif /* VPAES_ASM */

# ifdef BSAES_ASM
void bsaes_cbc_encrypt(const unsigned char *in, unsigned char *out,
                       size_t length, const AES_KEY *key,
                       unsigned char ivec[16], int enc);
void bsaes_ctr32_encrypt_blocks(const unsigned char *in, unsigned char *out,
                                size_t len, const AES_KEY *key,
                                const unsigned char ivec[16]);
void bsaes_xts_encrypt(const unsigned char *inp, unsigned char *out,
                       size_t len, const AES_KEY *key1,
                       const AES_KEY *key2, const unsigned char iv[16]);
void bsaes_xts_decrypt(const unsigned char *inp, unsigned char *out,
                       size_t len, const AES_KEY *key1,
                       const AES_KEY *key2, const unsigned char iv[16]);
# endif /* BSAES_ASM */

# ifdef AES_CTR_ASM
void AES_ctr32_encrypt(const unsigned char *in, unsigned char *out,
                       size_t blocks, const AES_KEY *key,
                       const unsigned char ivec[AES_BLOCK_SIZE]);
# endif /*  AES_CTR_ASM */

# ifdef AES_XTS_ASM
void AES_xts_encrypt(const unsigned char *inp, unsigned char *out, size_t len,
                     const AES_KEY *key1, const AES_KEY *key2,
                     const unsigned char iv[16]);
void AES_xts_decrypt(const unsigned char *inp, unsigned char *out, size_t len,
                     const AES_KEY *key1, const AES_KEY *key2,
                     const unsigned char iv[16]);
# endif /* AES_XTS_ASM */

# if defined(OPENSSL_CPUID_OBJ)
#  if (defined(__powerpc__) || defined(__ppc__) || defined(_ARCH_PPC))
#   include "ppc_arch.h"
#   ifdef VPAES_ASM
#    define VPAES_CAPABLE (OPENSSL_ppccap_P & PPC_ALTIVEC)
#   endif
#   define HWAES_CAPABLE  (OPENSSL_ppccap_P & PPC_CRYPTO207)
#   define HWAES_set_encrypt_key aes_p8_set_encrypt_key
#   define HWAES_set_decrypt_key aes_p8_set_decrypt_key
#   define HWAES_encrypt aes_p8_encrypt
#   define HWAES_decrypt aes_p8_decrypt
#   define HWAES_cbc_encrypt aes_p8_cbc_encrypt
#   define HWAES_ctr32_encrypt_blocks aes_p8_ctr32_encrypt_blocks
#   define HWAES_xts_encrypt aes_p8_xts_encrypt
#   define HWAES_xts_decrypt aes_p8_xts_decrypt
#  endif /* PPC */

#  if (defined(__arm__) || defined(__arm) || defined(__aarch64__))
#   include "arm_arch.h"
#   if __ARM_MAX_ARCH__>=7
#    if defined(BSAES_ASM)
#     define BSAES_CAPABLE (OPENSSL_armcap_P & ARMV7_NEON)
#    endif
#    if defined(VPAES_ASM)
#     define VPAES_CAPABLE (OPENSSL_armcap_P & ARMV7_NEON)
#    endif
#    define HWAES_CAPABLE (OPENSSL_armcap_P & ARMV8_AES)
#    define HWAES_set_encrypt_key aes_v8_set_encrypt_key
#    define HWAES_set_decrypt_key aes_v8_set_decrypt_key
#    define HWAES_encrypt aes_v8_encrypt
#    define HWAES_decrypt aes_v8_decrypt
#    define HWAES_cbc_encrypt aes_v8_cbc_encrypt
#    define HWAES_ecb_encrypt aes_v8_ecb_encrypt
#    if __ARM_MAX_ARCH__>=8
#     define HWAES_xts_encrypt aes_v8_xts_encrypt
#     define HWAES_xts_decrypt aes_v8_xts_decrypt
#    endif
#    define HWAES_ctr32_encrypt_blocks aes_v8_ctr32_encrypt_blocks
#    define AES_PMULL_CAPABLE ((OPENSSL_armcap_P & ARMV8_PMULL) && (OPENSSL_armcap_P & ARMV8_AES))
#    define AES_GCM_ENC_BYTES 512
#    define AES_GCM_DEC_BYTES 512
#    if __ARM_MAX_ARCH__>=8
#     define AES_gcm_encrypt armv8_aes_gcm_encrypt
#     define AES_gcm_decrypt armv8_aes_gcm_decrypt
#     define AES_GCM_ASM(gctx) ((gctx)->ctr==aes_v8_ctr32_encrypt_blocks && \
                                (gctx)->gcm.ghash==gcm_ghash_v8)
size_t aes_gcm_enc_128_kernel(const uint8_t * plaintext, uint64_t plaintext_length, uint8_t * ciphertext,
                              uint64_t *Xi, unsigned char ivec[16], const void *key);
size_t aes_gcm_enc_192_kernel(const uint8_t * plaintext, uint64_t plaintext_length, uint8_t * ciphertext,
                              uint64_t *Xi, unsigned char ivec[16], const void *key);
size_t aes_gcm_enc_256_kernel(const uint8_t * plaintext, uint64_t plaintext_length, uint8_t * ciphertext,
                              uint64_t *Xi, unsigned char ivec[16], const void *key);
size_t aes_gcm_dec_128_kernel(const uint8_t * ciphertext, uint64_t plaintext_length, uint8_t * plaintext,
                              uint64_t *Xi, unsigned char ivec[16], const void *key);
size_t aes_gcm_dec_192_kernel(const uint8_t * ciphertext, uint64_t plaintext_length, uint8_t * plaintext,
                              uint64_t *Xi, unsigned char ivec[16], const void *key);
size_t aes_gcm_dec_256_kernel(const uint8_t * ciphertext, uint64_t plaintext_length, uint8_t * plaintext,
                              uint64_t *Xi, unsigned char ivec[16], const void *key);
size_t armv8_aes_gcm_encrypt(const unsigned char *in, unsigned char *out, size_t len, const void *key,
                             unsigned char ivec[16], u64 *Xi);
size_t armv8_aes_gcm_decrypt(const unsigned char *in, unsigned char *out, size_t len, const void *key,
                             unsigned char ivec[16], u64 *Xi);
void gcm_ghash_v8(u64 Xi[2],const u128 Htable[16],const u8 *inp, size_t len);
#    endif
#   endif
#  endif
# endif /* OPENSSL_CPUID_OBJ */

# if     defined(AES_ASM) &&     ( \
         defined(__x86_64)       || defined(__x86_64__)  || \
         defined(_M_AMD64)       || defined(_M_X64)      )
#  define AES_CBC_HMAC_SHA_CAPABLE 1
#  define AESNI_CBC_HMAC_SHA_CAPABLE (OPENSSL_ia32cap_P[1]&(1<<(57-32)))
# endif

# if     defined(AES_ASM) && !defined(I386_ONLY) &&      (  \
         ((defined(__i386)       || defined(__i386__)    || \
           defined(_M_IX86)) && defined(OPENSSL_IA32_SSE2))|| \
         defined(__x86_64)       || defined(__x86_64__)  || \
         defined(_M_AMD64)       || defined(_M_X64)      )

/* AES-NI section */

#  define AESNI_CAPABLE   (OPENSSL_ia32cap_P[1]&(1<<(57-32)))
#  ifdef VPAES_ASM
#   define VPAES_CAPABLE   (OPENSSL_ia32cap_P[1]&(1<<(41-32)))
#  endif
#  ifdef BSAES_ASM
#   define BSAES_CAPABLE   (OPENSSL_ia32cap_P[1]&(1<<(41-32)))
#  endif

#  define AES_GCM_ENC_BYTES 32
#  define AES_GCM_DEC_BYTES 16

int aesni_set_encrypt_key(const unsigned char *userKey, int bits,
                          AES_KEY *key);
int aesni_set_decrypt_key(const unsigned char *userKey, int bits,
                          AES_KEY *key);

void aesni_encrypt(const unsigned char *in, unsigned char *out,
                   const AES_KEY *key);
void aesni_decrypt(const unsigned char *in, unsigned char *out,
                   const AES_KEY *key);

void aesni_ecb_encrypt(const unsigned char *in,
                       unsigned char *out,
                       size_t length, const AES_KEY *key, int enc);
void aesni_cbc_encrypt(const unsigned char *in,
                       unsigned char *out,
                       size_t length,
                       const AES_KEY *key, unsigned char *ivec, int enc);
#  ifndef OPENSSL_NO_OCB
void aesni_ocb_encrypt(const unsigned char *in, unsigned char *out,
                       size_t blocks, const void *key,
                       size_t start_block_num,
                       unsigned char offset_i[16],
                       const unsigned char L_[][16],
                       unsigned char checksum[16]);
void aesni_ocb_decrypt(const unsigned char *in, unsigned char *out,
                       size_t blocks, const void *key,
                       size_t start_block_num,
                       unsigned char offset_i[16],
                       const unsigned char L_[][16],
                       unsigned char checksum[16]);
#  endif /* OPENSSL_NO_OCB */

void aesni_ctr32_encrypt_blocks(const unsigned char *in,
                                unsigned char *out,
                                size_t blocks,
                                const void *key, const unsigned char *ivec);

void aesni_xts_encrypt(const unsigned char *in,
                       unsigned char *out,
                       size_t length,
                       const AES_KEY *key1, const AES_KEY *key2,
                       const unsigned char iv[16]);

void aesni_xts_decrypt(const unsigned char *in,
                       unsigned char *out,
                       size_t length,
                       const AES_KEY *key1, const AES_KEY *key2,
                       const unsigned char iv[16]);

void aesni_ccm64_encrypt_blocks(const unsigned char *in,
                                unsigned char *out,
                                size_t blocks,
                                const void *key,
                                const unsigned char ivec[16],
                                unsigned char cmac[16]);

void aesni_ccm64_decrypt_blocks(const unsigned char *in,
                                unsigned char *out,
                                size_t blocks,
                                const void *key,
                                const unsigned char ivec[16],
                                unsigned char cmac[16]);

#  if defined(__x86_64) || defined(__x86_64__) || defined(_M_AMD64) || defined(_M_X64)
size_t aesni_gcm_encrypt(const unsigned char *in, unsigned char *out, size_t len,
                         const void *key, unsigned char ivec[16], u64 *Xi);
size_t aesni_gcm_decrypt(const unsigned char *in, unsigned char *out, size_t len,
                         const void *key, unsigned char ivec[16], u64 *Xi);
void gcm_ghash_avx(u64 Xi[2], const u128 Htable[16], const u8 *in, size_t len);

#   define AES_gcm_encrypt aesni_gcm_encrypt
#   define AES_gcm_decrypt aesni_gcm_decrypt
#   define AES_GCM_ASM(ctx)    (ctx->ctr == aesni_ctr32_encrypt_blocks && \
                                ctx->gcm.ghash == gcm_ghash_avx)
#  endif


# elif defined(AES_ASM) && (defined(__sparc) || defined(__sparc__))

/* Fujitsu SPARC64 X support */
extern unsigned int OPENSSL_sparcv9cap_P[];
#  include "sparc_arch.h"

#  define SPARC_AES_CAPABLE       (OPENSSL_sparcv9cap_P[1] & CFR_AES)
#  define HWAES_CAPABLE           (OPENSSL_sparcv9cap_P[0] & SPARCV9_FJAESX)
#  define HWAES_set_encrypt_key aes_fx_set_encrypt_key
#  define HWAES_set_decrypt_key aes_fx_set_decrypt_key
#  define HWAES_encrypt aes_fx_encrypt
#  define HWAES_decrypt aes_fx_decrypt
#  define HWAES_cbc_encrypt aes_fx_cbc_encrypt
#  define HWAES_ctr32_encrypt_blocks aes_fx_ctr32_encrypt_blocks

void aes_t4_set_encrypt_key(const unsigned char *key, int bits, AES_KEY *ks);
void aes_t4_set_decrypt_key(const unsigned char *key, int bits, AES_KEY *ks);
void aes_t4_encrypt(const unsigned char *in, unsigned char *out,
                    const AES_KEY *key);
void aes_t4_decrypt(const unsigned char *in, unsigned char *out,
                    const AES_KEY *key);
/*
 * Key-length specific subroutines were chosen for following reason.
 * Each SPARC T4 core can execute up to 8 threads which share core's
 * resources. Loading as much key material to registers allows to
 * minimize references to shared memory interface, as well as amount
 * of instructions in inner loops [much needed on T4]. But then having
 * non-key-length specific routines would require conditional branches
 * either in inner loops or on subroutines' entries. Former is hardly
 * acceptable, while latter means code size increase to size occupied
 * by multiple key-length specific subroutines, so why fight?
 */
void aes128_t4_cbc_encrypt(const unsigned char *in, unsigned char *out,
                           size_t len, const AES_KEY *key,
                           unsigned char *ivec);
void aes128_t4_cbc_decrypt(const unsigned char *in, unsigned char *out,
                           size_t len, const AES_KEY *key,
                           unsigned char *ivec);
void aes192_t4_cbc_encrypt(const unsigned char *in, unsigned char *out,
                           size_t len, const AES_KEY *key,
                           unsigned char *ivec);
void aes192_t4_cbc_decrypt(const unsigned char *in, unsigned char *out,
                           size_t len, const AES_KEY *key,
                           unsigned char *ivec);
void aes256_t4_cbc_encrypt(const unsigned char *in, unsigned char *out,
                           size_t len, const AES_KEY *key,
                           unsigned char *ivec);
void aes256_t4_cbc_decrypt(const unsigned char *in, unsigned char *out,
                           size_t len, const AES_KEY *key,
                           unsigned char *ivec);
void aes128_t4_ctr32_encrypt(const unsigned char *in, unsigned char *out,
                             size_t blocks, const AES_KEY *key,
                             unsigned char *ivec);
void aes192_t4_ctr32_encrypt(const unsigned char *in, unsigned char *out,
                             size_t blocks, const AES_KEY *key,
                             unsigned char *ivec);
void aes256_t4_ctr32_encrypt(const unsigned char *in, unsigned char *out,
                             size_t blocks, const AES_KEY *key,
                             unsigned char *ivec);
void aes128_t4_xts_encrypt(const unsigned char *in, unsigned char *out,
                           size_t blocks, const AES_KEY *key1,
                           const AES_KEY *key2, const unsigned char *ivec);
void aes128_t4_xts_decrypt(const unsigned char *in, unsigned char *out,
                           size_t blocks, const AES_KEY *key1,
                           const AES_KEY *key2, const unsigned char *ivec);
void aes256_t4_xts_encrypt(const unsigned char *in, unsigned char *out,
                           size_t blocks, const AES_KEY *key1,
                           const AES_KEY *key2, const unsigned char *ivec);
void aes256_t4_xts_decrypt(const unsigned char *in, unsigned char *out,
                           size_t blocks, const AES_KEY *key1,
                           const AES_KEY *key2, const unsigned char *ivec);

# elif defined(OPENSSL_CPUID_OBJ) && defined(__s390__)
/* IBM S390X support */
#  include "s390x_arch.h"


/* Convert key size to function code: [16,24,32] -> [18,19,20]. */
#  define S390X_AES_FC(keylen)  (S390X_AES_128 + ((((keylen) << 3) - 128) >> 6))

/* Most modes of operation need km for partial block processing. */
#  define S390X_aes_128_CAPABLE (OPENSSL_s390xcap_P.km[0] &  \
                                S390X_CAPBIT(S390X_AES_128))
#  define S390X_aes_192_CAPABLE (OPENSSL_s390xcap_P.km[0] &  \
                                S390X_CAPBIT(S390X_AES_192))
#  define S390X_aes_256_CAPABLE (OPENSSL_s390xcap_P.km[0] &  \
                                S390X_CAPBIT(S390X_AES_256))

#  define S390X_aes_128_cbc_CAPABLE     1       /* checked by callee */
#  define S390X_aes_192_cbc_CAPABLE     1
#  define S390X_aes_256_cbc_CAPABLE     1

#  define S390X_aes_128_ecb_CAPABLE     S390X_aes_128_CAPABLE
#  define S390X_aes_192_ecb_CAPABLE     S390X_aes_192_CAPABLE
#  define S390X_aes_256_ecb_CAPABLE     S390X_aes_256_CAPABLE

#  define S390X_aes_128_ofb_CAPABLE (S390X_aes_128_CAPABLE &&           \
                                    (OPENSSL_s390xcap_P.kmo[0] &        \
                                     S390X_CAPBIT(S390X_AES_128)))
#  define S390X_aes_192_ofb_CAPABLE (S390X_aes_192_CAPABLE &&           \
                                    (OPENSSL_s390xcap_P.kmo[0] &        \
                                     S390X_CAPBIT(S390X_AES_192)))
#  define S390X_aes_256_ofb_CAPABLE (S390X_aes_256_CAPABLE &&           \
                                    (OPENSSL_s390xcap_P.kmo[0] &        \
                                     S390X_CAPBIT(S390X_AES_256)))

#  define S390X_aes_128_cfb_CAPABLE (S390X_aes_128_CAPABLE &&           \
                                    (OPENSSL_s390xcap_P.kmf[0] &        \
                                     S390X_CAPBIT(S390X_AES_128)))
#  define S390X_aes_192_cfb_CAPABLE (S390X_aes_192_CAPABLE &&           \
                                    (OPENSSL_s390xcap_P.kmf[0] &        \
                                     S390X_CAPBIT(S390X_AES_192)))
#  define S390X_aes_256_cfb_CAPABLE (S390X_aes_256_CAPABLE &&           \
                                    (OPENSSL_s390xcap_P.kmf[0] &        \
                                     S390X_CAPBIT(S390X_AES_256)))
#  define S390X_aes_128_cfb8_CAPABLE (OPENSSL_s390xcap_P.kmf[0] &       \
                                     S390X_CAPBIT(S390X_AES_128))
#  define S390X_aes_192_cfb8_CAPABLE (OPENSSL_s390xcap_P.kmf[0] &       \
                                     S390X_CAPBIT(S390X_AES_192))
#  define S390X_aes_256_cfb8_CAPABLE (OPENSSL_s390xcap_P.kmf[0] &       \
                                     S390X_CAPBIT(S390X_AES_256))
#  define S390X_aes_128_cfb1_CAPABLE    0
#  define S390X_aes_192_cfb1_CAPABLE    0
#  define S390X_aes_256_cfb1_CAPABLE    0

#  define S390X_aes_128_ctr_CAPABLE     1       /* checked by callee */
#  define S390X_aes_192_ctr_CAPABLE     1
#  define S390X_aes_256_ctr_CAPABLE     1

#  define S390X_aes_128_xts_CAPABLE     1       /* checked by callee */
#  define S390X_aes_256_xts_CAPABLE     1

# define S390X_aes_128_gcm_CAPABLE (S390X_aes_128_CAPABLE &&        \
                                    (OPENSSL_s390xcap_P.kma[0] &    \
                                     S390X_CAPBIT(S390X_AES_128)))
# define S390X_aes_192_gcm_CAPABLE (S390X_aes_192_CAPABLE &&        \
                                    (OPENSSL_s390xcap_P.kma[0] &    \
                                     S390X_CAPBIT(S390X_AES_192)))
# define S390X_aes_256_gcm_CAPABLE (S390X_aes_256_CAPABLE &&        \
                                    (OPENSSL_s390xcap_P.kma[0] &    \
                                     S390X_CAPBIT(S390X_AES_256)))

#  define S390X_aes_128_ccm_CAPABLE (S390X_aes_128_CAPABLE &&       \
                                    (OPENSSL_s390xcap_P.kmac[0] &   \
                                     S390X_CAPBIT(S390X_AES_128)))
#  define S390X_aes_192_ccm_CAPABLE (S390X_aes_192_CAPABLE &&       \
                                    (OPENSSL_s390xcap_P.kmac[0] &   \
                                     S390X_CAPBIT(S390X_AES_192)))
#  define S390X_aes_256_ccm_CAPABLE (S390X_aes_256_CAPABLE &&       \
                                    (OPENSSL_s390xcap_P.kmac[0] &   \
                                     S390X_CAPBIT(S390X_AES_256)))
#  define S390X_CCM_AAD_FLAG    0x40

#  ifndef OPENSSL_NO_OCB
#   define S390X_aes_128_ocb_CAPABLE    0
#   define S390X_aes_192_ocb_CAPABLE    0
#   define S390X_aes_256_ocb_CAPABLE    0
#  endif /* OPENSSL_NO_OCB */

#  ifndef OPENSSL_NO_SIV
#   define S390X_aes_128_siv_CAPABLE    0
#   define S390X_aes_192_siv_CAPABLE    0
#   define S390X_aes_256_siv_CAPABLE    0
#  endif /* OPENSSL_NO_SIV */

/* Convert key size to function code: [16,24,32] -> [18,19,20]. */
#  define S390X_AES_FC(keylen)  (S390X_AES_128 + ((((keylen) << 3) - 128) >> 6))
# endif

# if defined(HWAES_CAPABLE)
int HWAES_set_encrypt_key(const unsigned char *userKey, const int bits,
                          AES_KEY *key);
int HWAES_set_decrypt_key(const unsigned char *userKey, const int bits,
                          AES_KEY *key);
void HWAES_encrypt(const unsigned char *in, unsigned char *out,
                   const AES_KEY *key);
void HWAES_decrypt(const unsigned char *in, unsigned char *out,
                   const AES_KEY *key);
void HWAES_cbc_encrypt(const unsigned char *in, unsigned char *out,
                       size_t length, const AES_KEY *key,
                       unsigned char *ivec, const int enc);
void HWAES_ecb_encrypt(const unsigned char *in, unsigned char *out,
                       size_t length, const AES_KEY *key,
                       const int enc);
void HWAES_ctr32_encrypt_blocks(const unsigned char *in, unsigned char *out,
                                size_t len, const void *key,
                                const unsigned char ivec[16]);
void HWAES_xts_encrypt(const unsigned char *inp, unsigned char *out,
                       size_t len, const AES_KEY *key1,
                       const AES_KEY *key2, const unsigned char iv[16]);
void HWAES_xts_decrypt(const unsigned char *inp, unsigned char *out,
                       size_t len, const AES_KEY *key1,
                       const AES_KEY *key2, const unsigned char iv[16]);
#  ifndef OPENSSL_NO_OCB
#   ifdef HWAES_ocb_encrypt
void HWAES_ocb_encrypt(const unsigned char *in, unsigned char *out,
                       size_t blocks, const void *key,
                       size_t start_block_num,
                       unsigned char offset_i[16],
                       const unsigned char L_[][16],
                       unsigned char checksum[16]);
#   else
#     define HWAES_ocb_encrypt ((ocb128_f)NULL)
#   endif
#   ifdef HWAES_ocb_decrypt
void HWAES_ocb_decrypt(const unsigned char *in, unsigned char *out,
                       size_t blocks, const void *key,
                       size_t start_block_num,
                       unsigned char offset_i[16],
                       const unsigned char L_[][16],
                       unsigned char checksum[16]);
#   else
#     define HWAES_ocb_decrypt ((ocb128_f)NULL)
#   endif
#  endif /* OPENSSL_NO_OCB */

# endif /* HWAES_CAPABLE */

#endif /* OSSL_AES_PLATFORM_H */
Commit	Line	Data
459b15d4	1	/*
33388b44	2	* Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved.
459b15d4 SL	3	*
	4	* Licensed under the Apache License 2.0 (the "License"). You may not use
	5	* this file except in compliance with the License. You can obtain a copy
	6	* in the file LICENSE in the source distribution or at
	7	* https://www.openssl.org/source/license.html
	8	*/
	9
c0d47492 RL	10	#ifndef OSSL_AES_PLATFORM_H
c0d47492 RL	11	# define OSSL_AES_PLATFORM_H
80ce21fe	12	# pragma once
e1178600 SL	13
e1178600 SL	14	# include "openssl/aes.h"
459b15d4 SL	15
	16	# ifdef VPAES_ASM
	17	int vpaes_set_encrypt_key(const unsigned char *userKey, int bits,
	18	AES_KEY *key);
	19	int vpaes_set_decrypt_key(const unsigned char *userKey, int bits,
	20	AES_KEY *key);
	21	void vpaes_encrypt(const unsigned char in, unsigned char out,
	22	const AES_KEY *key);
	23	void vpaes_decrypt(const unsigned char in, unsigned char out,
	24	const AES_KEY *key);
	25	void vpaes_cbc_encrypt(const unsigned char *in,
	26	unsigned char *out,
	27	size_t length,
	28	const AES_KEY key, unsigned char ivec, int enc);
	29	# endif /* VPAES_ASM */
	30
	31	# ifdef BSAES_ASM
	32	void bsaes_cbc_encrypt(const unsigned char in, unsigned char out,
	33	size_t length, const AES_KEY *key,
	34	unsigned char ivec[16], int enc);
	35	void bsaes_ctr32_encrypt_blocks(const unsigned char in, unsigned char out,
	36	size_t len, const AES_KEY *key,
	37	const unsigned char ivec[16]);
	38	void bsaes_xts_encrypt(const unsigned char inp, unsigned char out,
	39	size_t len, const AES_KEY *key1,
	40	const AES_KEY *key2, const unsigned char iv[16]);
	41	void bsaes_xts_decrypt(const unsigned char inp, unsigned char out,
	42	size_t len, const AES_KEY *key1,
	43	const AES_KEY *key2, const unsigned char iv[16]);
	44	# endif /* BSAES_ASM */
	45
	46	# ifdef AES_CTR_ASM
	47	void AES_ctr32_encrypt(const unsigned char in, unsigned char out,
	48	size_t blocks, const AES_KEY *key,
	49	const unsigned char ivec[AES_BLOCK_SIZE]);
	50	# endif /* AES_CTR_ASM */
	51
	52	# ifdef AES_XTS_ASM
	53	void AES_xts_encrypt(const unsigned char inp, unsigned char out, size_t len,
	54	const AES_KEY key1, const AES_KEY key2,
	55	const unsigned char iv[16]);
	56	void AES_xts_decrypt(const unsigned char inp, unsigned char out, size_t len,
	57	const AES_KEY key1, const AES_KEY key2,
	58	const unsigned char iv[16]);
	59	# endif /* AES_XTS_ASM */
	60
	61	# if defined(OPENSSL_CPUID_OBJ)
	62	# if (defined(__powerpc__) \|\| defined(__ppc__) \|\| defined(_ARCH_PPC))
	63	# include "ppc_arch.h"
	64	# ifdef VPAES_ASM
	65	# define VPAES_CAPABLE (OPENSSL_ppccap_P & PPC_ALTIVEC)
	66	# endif
	67	# define HWAES_CAPABLE (OPENSSL_ppccap_P & PPC_CRYPTO207)
	68	# define HWAES_set_encrypt_key aes_p8_set_encrypt_key
	69	# define HWAES_set_decrypt_key aes_p8_set_decrypt_key
	70	# define HWAES_encrypt aes_p8_encrypt
	71	# define HWAES_decrypt aes_p8_decrypt
	72	# define HWAES_cbc_encrypt aes_p8_cbc_encrypt
	73	# define HWAES_ctr32_encrypt_blocks aes_p8_ctr32_encrypt_blocks
	74	# define HWAES_xts_encrypt aes_p8_xts_encrypt
	75	# define HWAES_xts_decrypt aes_p8_xts_decrypt
	76	# endif /* PPC */
	77
	78	# if (defined(__arm__) \|\| defined(__arm) \|\| defined(__aarch64__))
79	# include "arm_arch.h"
80	# if __ARM_MAX_ARCH__>=7
81	# if defined(BSAES_ASM)
82	# define BSAES_CAPABLE (OPENSSL_armcap_P & ARMV7_NEON)
83	# endif
84	# if defined(VPAES_ASM)
85	# define VPAES_CAPABLE (OPENSSL_armcap_P & ARMV7_NEON)
86	# endif
87	# define HWAES_CAPABLE (OPENSSL_armcap_P & ARMV8_AES)
88	# define HWAES_set_encrypt_key aes_v8_set_encrypt_key
89	# define HWAES_set_decrypt_key aes_v8_set_decrypt_key
90	# define HWAES_encrypt aes_v8_encrypt
91	# define HWAES_decrypt aes_v8_decrypt
92	# define HWAES_cbc_encrypt aes_v8_cbc_encrypt
2ff16afc	93	# define HWAES_ecb_encrypt aes_v8_ecb_encrypt
9ce8e0d1 X	94	# if __ARM_MAX_ARCH__>=8
	95	# define HWAES_xts_encrypt aes_v8_xts_encrypt
	96	# define HWAES_xts_decrypt aes_v8_xts_decrypt
	97	# endif
459b15d4	98	# define HWAES_ctr32_encrypt_blocks aes_v8_ctr32_encrypt_blocks
31b59078 FF	99	# define AES_PMULL_CAPABLE ((OPENSSL_armcap_P & ARMV8_PMULL) && (OPENSSL_armcap_P & ARMV8_AES))
	100	# define AES_GCM_ENC_BYTES 512
	101	# define AES_GCM_DEC_BYTES 512
	102	# if __ARM_MAX_ARCH__>=8
	103	# define AES_gcm_encrypt armv8_aes_gcm_encrypt
	104	# define AES_gcm_decrypt armv8_aes_gcm_decrypt
	105	# define AES_GCM_ASM(gctx) ((gctx)->ctr==aes_v8_ctr32_encrypt_blocks && \
	106	(gctx)->gcm.ghash==gcm_ghash_v8)
	107	size_t aes_gcm_enc_128_kernel(const uint8_t * plaintext, uint64_t plaintext_length, uint8_t * ciphertext,
	108	uint64_t Xi, unsigned char ivec[16], const void key);
	109	size_t aes_gcm_enc_192_kernel(const uint8_t * plaintext, uint64_t plaintext_length, uint8_t * ciphertext,
	110	uint64_t Xi, unsigned char ivec[16], const void key);
	111	size_t aes_gcm_enc_256_kernel(const uint8_t * plaintext, uint64_t plaintext_length, uint8_t * ciphertext,
	112	uint64_t Xi, unsigned char ivec[16], const void key);
	113	size_t aes_gcm_dec_128_kernel(const uint8_t * ciphertext, uint64_t plaintext_length, uint8_t * plaintext,
	114	uint64_t Xi, unsigned char ivec[16], const void key);
	115	size_t aes_gcm_dec_192_kernel(const uint8_t * ciphertext, uint64_t plaintext_length, uint8_t * plaintext,
	116	uint64_t Xi, unsigned char ivec[16], const void key);
	117	size_t aes_gcm_dec_256_kernel(const uint8_t * ciphertext, uint64_t plaintext_length, uint8_t * plaintext,
	118	uint64_t Xi, unsigned char ivec[16], const void key);
	119	size_t armv8_aes_gcm_encrypt(const unsigned char in, unsigned char out, size_t len, const void *key,
	120	unsigned char ivec[16], u64 *Xi);
	121	size_t armv8_aes_gcm_decrypt(const unsigned char in, unsigned char out, size_t len, const void *key,
	122	unsigned char ivec[16], u64 *Xi);
	123	void gcm_ghash_v8(u64 Xi[2],const u128 Htable[16],const u8 *inp, size_t len);
	124	# endif
459b15d4 SL	125	# endif
	126	# endif
	127	# endif /* OPENSSL_CPUID_OBJ */
	128
0d2bfe52 SL	129	# if defined(AES_ASM) && ( \
	130	defined(__x86_64) \|\| defined(__x86_64__) \|\| \
	131	defined(_M_AMD64) \|\| defined(_M_X64) )
	132	# define AES_CBC_HMAC_SHA_CAPABLE 1
	133	# define AESNI_CBC_HMAC_SHA_CAPABLE (OPENSSL_ia32cap_P[1]&(1<<(57-32)))
	134	# endif
	135
459b15d4 SL	136	# if defined(AES_ASM) && !defined(I386_ONLY) && ( \
	137	((defined(__i386) \|\| defined(__i386__) \|\| \
	138	defined(_M_IX86)) && defined(OPENSSL_IA32_SSE2))\|\| \
	139	defined(__x86_64) \|\| defined(__x86_64__) \|\| \
	140	defined(_M_AMD64) \|\| defined(_M_X64) )
	141
	142	/* AES-NI section */
459b15d4 SL	143
	144	# define AESNI_CAPABLE (OPENSSL_ia32cap_P[1]&(1<<(57-32)))
	145	# ifdef VPAES_ASM
	146	# define VPAES_CAPABLE (OPENSSL_ia32cap_P[1]&(1<<(41-32)))
	147	# endif
	148	# ifdef BSAES_ASM
	149	# define BSAES_CAPABLE (OPENSSL_ia32cap_P[1]&(1<<(41-32)))
	150	# endif
	151
31b59078 FF	152	# define AES_GCM_ENC_BYTES 32
	153	# define AES_GCM_DEC_BYTES 16
	154
459b15d4 SL	155	int aesni_set_encrypt_key(const unsigned char *userKey, int bits,
	156	AES_KEY *key);
	157	int aesni_set_decrypt_key(const unsigned char *userKey, int bits,
	158	AES_KEY *key);
	159
	160	void aesni_encrypt(const unsigned char in, unsigned char out,
	161	const AES_KEY *key);
	162	void aesni_decrypt(const unsigned char in, unsigned char out,
	163	const AES_KEY *key);
	164
	165	void aesni_ecb_encrypt(const unsigned char *in,
	166	unsigned char *out,
	167	size_t length, const AES_KEY *key, int enc);
	168	void aesni_cbc_encrypt(const unsigned char *in,
	169	unsigned char *out,
	170	size_t length,
	171	const AES_KEY key, unsigned char ivec, int enc);
	172	# ifndef OPENSSL_NO_OCB
	173	void aesni_ocb_encrypt(const unsigned char in, unsigned char out,
	174	size_t blocks, const void *key,
	175	size_t start_block_num,
	176	unsigned char offset_i[16],
	177	const unsigned char L_[][16],
	178	unsigned char checksum[16]);
	179	void aesni_ocb_decrypt(const unsigned char in, unsigned char out,
	180	size_t blocks, const void *key,
	181	size_t start_block_num,
	182	unsigned char offset_i[16],
	183	const unsigned char L_[][16],
	184	unsigned char checksum[16]);
	185	# endif /* OPENSSL_NO_OCB */
	186
	187	void aesni_ctr32_encrypt_blocks(const unsigned char *in,
	188	unsigned char *out,
	189	size_t blocks,
	190	const void key, const unsigned char ivec);
	191
	192	void aesni_xts_encrypt(const unsigned char *in,
	193	unsigned char *out,
	194	size_t length,
	195	const AES_KEY key1, const AES_KEY key2,
	196	const unsigned char iv[16]);
	197
	198	void aesni_xts_decrypt(const unsigned char *in,
	199	unsigned char *out,
	200	size_t length,
	201	const AES_KEY key1, const AES_KEY key2,
	202	const unsigned char iv[16]);
	203
	204	void aesni_ccm64_encrypt_blocks(const unsigned char *in,
	205	unsigned char *out,
	206	size_t blocks,
	207	const void *key,
	208	const unsigned char ivec[16],
	209	unsigned char cmac[16]);
	210
	211	void aesni_ccm64_decrypt_blocks(const unsigned char *in,
	212	unsigned char *out,
	213	size_t blocks,
	214	const void *key,
	215	const unsigned char ivec[16],
	216	unsigned char cmac[16]);
	217
	218	# if defined(__x86_64) \|\| defined(__x86_64__) \|\| defined(_M_AMD64) \|\| defined(_M_X64)
219	size_t aesni_gcm_encrypt(const unsigned char in, unsigned char out, size_t len,
220	const void key, unsigned char ivec[16], u64 Xi);
221	size_t aesni_gcm_decrypt(const unsigned char in, unsigned char out, size_t len,
222	const void key, unsigned char ivec[16], u64 Xi);
223	void gcm_ghash_avx(u64 Xi[2], const u128 Htable[16], const u8 *in, size_t len);
224
31b59078 FF	225	# define AES_gcm_encrypt aesni_gcm_encrypt
31b59078 FF	226	# define AES_gcm_decrypt aesni_gcm_decrypt
459b15d4 SL	227	# define AES_GCM_ASM(ctx) (ctx->ctr == aesni_ctr32_encrypt_blocks && \
	228	ctx->gcm.ghash == gcm_ghash_avx)
	229	# endif
	230
	231
	232	# elif defined(AES_ASM) && (defined(__sparc) \|\| defined(__sparc__))
	233
	234	/* Fujitsu SPARC64 X support */
	235	extern unsigned int OPENSSL_sparcv9cap_P[];
	236	# include "sparc_arch.h"
e1178600	237
459b15d4 SL	238	# define SPARC_AES_CAPABLE (OPENSSL_sparcv9cap_P[1] & CFR_AES)
	239	# define HWAES_CAPABLE (OPENSSL_sparcv9cap_P[0] & SPARCV9_FJAESX)
	240	# define HWAES_set_encrypt_key aes_fx_set_encrypt_key
	241	# define HWAES_set_decrypt_key aes_fx_set_decrypt_key
	242	# define HWAES_encrypt aes_fx_encrypt
	243	# define HWAES_decrypt aes_fx_decrypt
	244	# define HWAES_cbc_encrypt aes_fx_cbc_encrypt
	245	# define HWAES_ctr32_encrypt_blocks aes_fx_ctr32_encrypt_blocks
	246
	247	void aes_t4_set_encrypt_key(const unsigned char key, int bits, AES_KEY ks);
	248	void aes_t4_set_decrypt_key(const unsigned char key, int bits, AES_KEY ks);
	249	void aes_t4_encrypt(const unsigned char in, unsigned char out,
	250	const AES_KEY *key);
	251	void aes_t4_decrypt(const unsigned char in, unsigned char out,
	252	const AES_KEY *key);
	253	/*
	254	* Key-length specific subroutines were chosen for following reason.
	255	* Each SPARC T4 core can execute up to 8 threads which share core's
	256	* resources. Loading as much key material to registers allows to
	257	* minimize references to shared memory interface, as well as amount
	258	* of instructions in inner loops [much needed on T4]. But then having
	259	* non-key-length specific routines would require conditional branches
	260	* either in inner loops or on subroutines' entries. Former is hardly
	261	* acceptable, while latter means code size increase to size occupied
	262	* by multiple key-length specific subroutines, so why fight?
	263	*/
	264	void aes128_t4_cbc_encrypt(const unsigned char in, unsigned char out,
	265	size_t len, const AES_KEY *key,
	266	unsigned char *ivec);
	267	void aes128_t4_cbc_decrypt(const unsigned char in, unsigned char out,
	268	size_t len, const AES_KEY *key,
	269	unsigned char *ivec);
	270	void aes192_t4_cbc_encrypt(const unsigned char in, unsigned char out,
	271	size_t len, const AES_KEY *key,
	272	unsigned char *ivec);
	273	void aes192_t4_cbc_decrypt(const unsigned char in, unsigned char out,
	274	size_t len, const AES_KEY *key,
	275	unsigned char *ivec);
	276	void aes256_t4_cbc_encrypt(const unsigned char in, unsigned char out,
	277	size_t len, const AES_KEY *key,
	278	unsigned char *ivec);
	279	void aes256_t4_cbc_decrypt(const unsigned char in, unsigned char out,
	280	size_t len, const AES_KEY *key,
	281	unsigned char *ivec);
	282	void aes128_t4_ctr32_encrypt(const unsigned char in, unsigned char out,
	283	size_t blocks, const AES_KEY *key,
	284	unsigned char *ivec);
	285	void aes192_t4_ctr32_encrypt(const unsigned char in, unsigned char out,
	286	size_t blocks, const AES_KEY *key,
	287	unsigned char *ivec);
	288	void aes256_t4_ctr32_encrypt(const unsigned char in, unsigned char out,
	289	size_t blocks, const AES_KEY *key,
	290	unsigned char *ivec);
	291	void aes128_t4_xts_encrypt(const unsigned char in, unsigned char out,
	292	size_t blocks, const AES_KEY *key1,
	293	const AES_KEY key2, const unsigned char ivec);
	294	void aes128_t4_xts_decrypt(const unsigned char in, unsigned char out,
	295	size_t blocks, const AES_KEY *key1,
	296	const AES_KEY key2, const unsigned char ivec);
	297	void aes256_t4_xts_encrypt(const unsigned char in, unsigned char out,
	298	size_t blocks, const AES_KEY *key1,
	299	const AES_KEY key2, const unsigned char ivec);
	300	void aes256_t4_xts_decrypt(const unsigned char in, unsigned char out,
	301	size_t blocks, const AES_KEY *key1,
302	const AES_KEY key2, const unsigned char ivec);
303
304	# elif defined(OPENSSL_CPUID_OBJ) && defined(__s390__)
305	/* IBM S390X support */
306	# include "s390x_arch.h"
307
308
309	/* Convert key size to function code: [16,24,32] -> [18,19,20]. */
310	# define S390X_AES_FC(keylen) (S390X_AES_128 + ((((keylen) << 3) - 128) >> 6))
311
312	/* Most modes of operation need km for partial block processing. */
313	# define S390X_aes_128_CAPABLE (OPENSSL_s390xcap_P.km[0] & \
314	S390X_CAPBIT(S390X_AES_128))
315	# define S390X_aes_192_CAPABLE (OPENSSL_s390xcap_P.km[0] & \
316	S390X_CAPBIT(S390X_AES_192))
317	# define S390X_aes_256_CAPABLE (OPENSSL_s390xcap_P.km[0] & \
318	S390X_CAPBIT(S390X_AES_256))
319
dd6b2706 P	320	# define S390X_aes_128_cbc_CAPABLE 1 /* checked by callee */
	321	# define S390X_aes_192_cbc_CAPABLE 1
	322	# define S390X_aes_256_cbc_CAPABLE 1
459b15d4	323
dd6b2706 P	324	# define S390X_aes_128_ecb_CAPABLE S390X_aes_128_CAPABLE
	325	# define S390X_aes_192_ecb_CAPABLE S390X_aes_192_CAPABLE
	326	# define S390X_aes_256_ecb_CAPABLE S390X_aes_256_CAPABLE
459b15d4	327
dd6b2706 P	328	# define S390X_aes_128_ofb_CAPABLE (S390X_aes_128_CAPABLE && \
dd6b2706 P	329	(OPENSSL_s390xcap_P.kmo[0] & \
459b15d4	330	S390X_CAPBIT(S390X_AES_128)))
dd6b2706 P	331	# define S390X_aes_192_ofb_CAPABLE (S390X_aes_192_CAPABLE && \
dd6b2706 P	332	(OPENSSL_s390xcap_P.kmo[0] & \
459b15d4	333	S390X_CAPBIT(S390X_AES_192)))
dd6b2706 P	334	# define S390X_aes_256_ofb_CAPABLE (S390X_aes_256_CAPABLE && \
dd6b2706 P	335	(OPENSSL_s390xcap_P.kmo[0] & \
459b15d4 SL	336	S390X_CAPBIT(S390X_AES_256)))
459b15d4 SL	337
dd6b2706 P	338	# define S390X_aes_128_cfb_CAPABLE (S390X_aes_128_CAPABLE && \
dd6b2706 P	339	(OPENSSL_s390xcap_P.kmf[0] & \
459b15d4	340	S390X_CAPBIT(S390X_AES_128)))
dd6b2706 P	341	# define S390X_aes_192_cfb_CAPABLE (S390X_aes_192_CAPABLE && \
dd6b2706 P	342	(OPENSSL_s390xcap_P.kmf[0] & \
459b15d4	343	S390X_CAPBIT(S390X_AES_192)))
dd6b2706 P	344	# define S390X_aes_256_cfb_CAPABLE (S390X_aes_256_CAPABLE && \
dd6b2706 P	345	(OPENSSL_s390xcap_P.kmf[0] & \
459b15d4	346	S390X_CAPBIT(S390X_AES_256)))
dd6b2706	347	# define S390X_aes_128_cfb8_CAPABLE (OPENSSL_s390xcap_P.kmf[0] & \
459b15d4	348	S390X_CAPBIT(S390X_AES_128))
dd6b2706	349	# define S390X_aes_192_cfb8_CAPABLE (OPENSSL_s390xcap_P.kmf[0] & \
459b15d4	350	S390X_CAPBIT(S390X_AES_192))
dd6b2706	351	# define S390X_aes_256_cfb8_CAPABLE (OPENSSL_s390xcap_P.kmf[0] & \
459b15d4	352	S390X_CAPBIT(S390X_AES_256))
dd6b2706 P	353	# define S390X_aes_128_cfb1_CAPABLE 0
	354	# define S390X_aes_192_cfb1_CAPABLE 0
	355	# define S390X_aes_256_cfb1_CAPABLE 0
459b15d4	356
dd6b2706 P	357	# define S390X_aes_128_ctr_CAPABLE 1 /* checked by callee */
	358	# define S390X_aes_192_ctr_CAPABLE 1
	359	# define S390X_aes_256_ctr_CAPABLE 1
459b15d4	360
dd6b2706 P	361	# define S390X_aes_128_xts_CAPABLE 1 /* checked by callee */
dd6b2706 P	362	# define S390X_aes_256_xts_CAPABLE 1
459b15d4	363
05f4eb2d SL	364	# define S390X_aes_128_gcm_CAPABLE (S390X_aes_128_CAPABLE && \
05f4eb2d SL	365	(OPENSSL_s390xcap_P.kma[0] & \
459b15d4	366	S390X_CAPBIT(S390X_AES_128)))
05f4eb2d SL	367	# define S390X_aes_192_gcm_CAPABLE (S390X_aes_192_CAPABLE && \
05f4eb2d SL	368	(OPENSSL_s390xcap_P.kma[0] & \
459b15d4	369	S390X_CAPBIT(S390X_AES_192)))
05f4eb2d SL	370	# define S390X_aes_256_gcm_CAPABLE (S390X_aes_256_CAPABLE && \
	371	(OPENSSL_s390xcap_P.kma[0] & \
	372	S390X_CAPBIT(S390X_AES_256)))
	373
	374	# define S390X_aes_128_ccm_CAPABLE (S390X_aes_128_CAPABLE && \
	375	(OPENSSL_s390xcap_P.kmac[0] & \
	376	S390X_CAPBIT(S390X_AES_128)))
	377	# define S390X_aes_192_ccm_CAPABLE (S390X_aes_192_CAPABLE && \
	378	(OPENSSL_s390xcap_P.kmac[0] & \
	379	S390X_CAPBIT(S390X_AES_192)))
	380	# define S390X_aes_256_ccm_CAPABLE (S390X_aes_256_CAPABLE && \
	381	(OPENSSL_s390xcap_P.kmac[0] & \
459b15d4	382	S390X_CAPBIT(S390X_AES_256)))
dd6b2706	383	# define S390X_CCM_AAD_FLAG 0x40
459b15d4 SL	384
459b15d4 SL	385	# ifndef OPENSSL_NO_OCB
dd6b2706 P	386	# define S390X_aes_128_ocb_CAPABLE 0
	387	# define S390X_aes_192_ocb_CAPABLE 0
	388	# define S390X_aes_256_ocb_CAPABLE 0
459b15d4 SL	389	# endif /* OPENSSL_NO_OCB */
	390
	391	# ifndef OPENSSL_NO_SIV
	392	# define S390X_aes_128_siv_CAPABLE 0
	393	# define S390X_aes_192_siv_CAPABLE 0
	394	# define S390X_aes_256_siv_CAPABLE 0
	395	# endif /* OPENSSL_NO_SIV */
	396
	397	/* Convert key size to function code: [16,24,32] -> [18,19,20]. */
	398	# define S390X_AES_FC(keylen) (S390X_AES_128 + ((((keylen) << 3) - 128) >> 6))
	399	# endif
	400
	401	# if defined(HWAES_CAPABLE)
	402	int HWAES_set_encrypt_key(const unsigned char *userKey, const int bits,
	403	AES_KEY *key);
	404	int HWAES_set_decrypt_key(const unsigned char *userKey, const int bits,
	405	AES_KEY *key);
	406	void HWAES_encrypt(const unsigned char in, unsigned char out,
	407	const AES_KEY *key);
	408	void HWAES_decrypt(const unsigned char in, unsigned char out,
	409	const AES_KEY *key);
	410	void HWAES_cbc_encrypt(const unsigned char in, unsigned char out,
	411	size_t length, const AES_KEY *key,
	412	unsigned char *ivec, const int enc);
2ff16afc X	413	void HWAES_ecb_encrypt(const unsigned char in, unsigned char out,
	414	size_t length, const AES_KEY *key,
	415	const int enc);
459b15d4	416	void HWAES_ctr32_encrypt_blocks(const unsigned char in, unsigned char out,
31b59078	417	size_t len, const void *key,
459b15d4 SL	418	const unsigned char ivec[16]);
	419	void HWAES_xts_encrypt(const unsigned char inp, unsigned char out,
	420	size_t len, const AES_KEY *key1,
	421	const AES_KEY *key2, const unsigned char iv[16]);
	422	void HWAES_xts_decrypt(const unsigned char inp, unsigned char out,
	423	size_t len, const AES_KEY *key1,
	424	const AES_KEY *key2, const unsigned char iv[16]);
	425	# ifndef OPENSSL_NO_OCB
	426	# ifdef HWAES_ocb_encrypt
	427	void HWAES_ocb_encrypt(const unsigned char in, unsigned char out,
	428	size_t blocks, const void *key,
	429	size_t start_block_num,
	430	unsigned char offset_i[16],
	431	const unsigned char L_[][16],
	432	unsigned char checksum[16]);
	433	# else
	434	# define HWAES_ocb_encrypt ((ocb128_f)NULL)
	435	# endif
	436	# ifdef HWAES_ocb_decrypt
	437	void HWAES_ocb_decrypt(const unsigned char in, unsigned char out,
	438	size_t blocks, const void *key,
	439	size_t start_block_num,
	440	unsigned char offset_i[16],
	441	const unsigned char L_[][16],
	442	unsigned char checksum[16]);
	443	# else
	444	# define HWAES_ocb_decrypt ((ocb128_f)NULL)
	445	# endif
	446	# endif /* OPENSSL_NO_OCB */
	447
	448	# endif /* HWAES_CAPABLE */
	449
c0d47492	450	#endif /* OSSL_AES_PLATFORM_H */