150 lines
4.8 KiB
C
150 lines
4.8 KiB
C
/* SPDX-License-Identifier: GPL-2.0-only */
|
|
/*
|
|
* AES accelerated using the sparc64 aes opcodes
|
|
*
|
|
* Copyright (C) 2008, Intel Corp.
|
|
* Copyright (c) 2010, Intel Corporation.
|
|
* Copyright 2026 Google LLC
|
|
*/
|
|
|
|
#include <asm/fpumacro.h>
|
|
#include <asm/opcodes.h>
|
|
#include <asm/pstate.h>
|
|
#include <asm/elf.h>
|
|
|
|
static __ro_after_init DEFINE_STATIC_KEY_FALSE(have_aes_opcodes);
|
|
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_key_expand);
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_load_encrypt_keys_128);
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_load_encrypt_keys_192);
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_load_encrypt_keys_256);
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_load_decrypt_keys_128);
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_load_decrypt_keys_192);
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_load_decrypt_keys_256);
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_ecb_encrypt_128);
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_ecb_encrypt_192);
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_ecb_encrypt_256);
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_ecb_decrypt_128);
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_ecb_decrypt_192);
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_ecb_decrypt_256);
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_cbc_encrypt_128);
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_cbc_encrypt_192);
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_cbc_encrypt_256);
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_cbc_decrypt_128);
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_cbc_decrypt_192);
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_cbc_decrypt_256);
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_ctr_crypt_128);
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_ctr_crypt_192);
|
|
EXPORT_SYMBOL_GPL(aes_sparc64_ctr_crypt_256);
|
|
|
|
void aes_sparc64_encrypt_128(const u64 *key, const u32 *input, u32 *output);
|
|
void aes_sparc64_encrypt_192(const u64 *key, const u32 *input, u32 *output);
|
|
void aes_sparc64_encrypt_256(const u64 *key, const u32 *input, u32 *output);
|
|
void aes_sparc64_decrypt_128(const u64 *key, const u32 *input, u32 *output);
|
|
void aes_sparc64_decrypt_192(const u64 *key, const u32 *input, u32 *output);
|
|
void aes_sparc64_decrypt_256(const u64 *key, const u32 *input, u32 *output);
|
|
|
|
static void aes_preparekey_arch(union aes_enckey_arch *k,
|
|
union aes_invkey_arch *inv_k,
|
|
const u8 *in_key, int key_len, int nrounds)
|
|
{
|
|
if (static_branch_likely(&have_aes_opcodes)) {
|
|
u32 aligned_key[AES_MAX_KEY_SIZE / 4];
|
|
|
|
if (IS_ALIGNED((uintptr_t)in_key, 4)) {
|
|
aes_sparc64_key_expand((const u32 *)in_key,
|
|
k->sparc_rndkeys, key_len);
|
|
} else {
|
|
memcpy(aligned_key, in_key, key_len);
|
|
aes_sparc64_key_expand(aligned_key,
|
|
k->sparc_rndkeys, key_len);
|
|
memzero_explicit(aligned_key, key_len);
|
|
}
|
|
/*
|
|
* Note that nothing needs to be written to inv_k (if it's
|
|
* non-NULL) here, since the SPARC64 assembly code uses
|
|
* k->sparc_rndkeys for both encryption and decryption.
|
|
*/
|
|
} else {
|
|
aes_expandkey_generic(k->rndkeys,
|
|
inv_k ? inv_k->inv_rndkeys : NULL,
|
|
in_key, key_len);
|
|
}
|
|
}
|
|
|
|
static void aes_sparc64_encrypt(const struct aes_enckey *key,
|
|
const u32 *input, u32 *output)
|
|
{
|
|
if (key->len == AES_KEYSIZE_128)
|
|
aes_sparc64_encrypt_128(key->k.sparc_rndkeys, input, output);
|
|
else if (key->len == AES_KEYSIZE_192)
|
|
aes_sparc64_encrypt_192(key->k.sparc_rndkeys, input, output);
|
|
else
|
|
aes_sparc64_encrypt_256(key->k.sparc_rndkeys, input, output);
|
|
}
|
|
|
|
static void aes_encrypt_arch(const struct aes_enckey *key,
|
|
u8 out[AES_BLOCK_SIZE],
|
|
const u8 in[AES_BLOCK_SIZE])
|
|
{
|
|
u32 bounce_buf[AES_BLOCK_SIZE / 4];
|
|
|
|
if (static_branch_likely(&have_aes_opcodes)) {
|
|
if (IS_ALIGNED((uintptr_t)in | (uintptr_t)out, 4)) {
|
|
aes_sparc64_encrypt(key, (const u32 *)in, (u32 *)out);
|
|
} else {
|
|
memcpy(bounce_buf, in, AES_BLOCK_SIZE);
|
|
aes_sparc64_encrypt(key, bounce_buf, bounce_buf);
|
|
memcpy(out, bounce_buf, AES_BLOCK_SIZE);
|
|
}
|
|
} else {
|
|
aes_encrypt_generic(key->k.rndkeys, key->nrounds, out, in);
|
|
}
|
|
}
|
|
|
|
static void aes_sparc64_decrypt(const struct aes_key *key,
|
|
const u32 *input, u32 *output)
|
|
{
|
|
if (key->len == AES_KEYSIZE_128)
|
|
aes_sparc64_decrypt_128(key->k.sparc_rndkeys, input, output);
|
|
else if (key->len == AES_KEYSIZE_192)
|
|
aes_sparc64_decrypt_192(key->k.sparc_rndkeys, input, output);
|
|
else
|
|
aes_sparc64_decrypt_256(key->k.sparc_rndkeys, input, output);
|
|
}
|
|
|
|
static void aes_decrypt_arch(const struct aes_key *key,
|
|
u8 out[AES_BLOCK_SIZE],
|
|
const u8 in[AES_BLOCK_SIZE])
|
|
{
|
|
u32 bounce_buf[AES_BLOCK_SIZE / 4];
|
|
|
|
if (static_branch_likely(&have_aes_opcodes)) {
|
|
if (IS_ALIGNED((uintptr_t)in | (uintptr_t)out, 4)) {
|
|
aes_sparc64_decrypt(key, (const u32 *)in, (u32 *)out);
|
|
} else {
|
|
memcpy(bounce_buf, in, AES_BLOCK_SIZE);
|
|
aes_sparc64_decrypt(key, bounce_buf, bounce_buf);
|
|
memcpy(out, bounce_buf, AES_BLOCK_SIZE);
|
|
}
|
|
} else {
|
|
aes_decrypt_generic(key->inv_k.inv_rndkeys, key->nrounds,
|
|
out, in);
|
|
}
|
|
}
|
|
|
|
#define aes_mod_init_arch aes_mod_init_arch
|
|
static void aes_mod_init_arch(void)
|
|
{
|
|
unsigned long cfr;
|
|
|
|
if (!(sparc64_elf_hwcap & HWCAP_SPARC_CRYPTO))
|
|
return;
|
|
|
|
__asm__ __volatile__("rd %%asr26, %0" : "=r" (cfr));
|
|
if (!(cfr & CFR_AES))
|
|
return;
|
|
|
|
static_branch_enable(&have_aes_opcodes);
|
|
}
|