mirror/openssl
2
0
Fork 0
mirror of https://github.com/openssl/openssl.git synced 2025-04-24 20:51:14 +08:00
Code Issues Packages Projects Releases Wiki Activity

provider: cipher: aes: add riscv32 zkn (zbkb) support

Browse Source 
Reviewed-by: Tomas Mraz <tomas@openssl.org>
Reviewed-by: Paul Dale <pauli@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/18308)
This commit is contained in:
Hongren (Zenithal) Zheng 2022-05-14 00:01:11 +08:00 committed by Pauli
parent cbb15b31b9
commit 5ccee69b13
8 changed files with 311 additions and 0 deletions

2
providers/implementations/ciphers/cipher_aes_ccm_hw.c

@ -63,6 +63,8 @@ static const PROV_CCM_HW aes_ccm = {
# include "cipher_aes_ccm_hw_t4.inc"
#elif defined(RV64I_ZKND_ZKNE_CAPABLE)
# include "cipher_aes_ccm_hw_rv64i_zknd_zkne.inc"
#elif defined(RV32I_ZBKB_ZKND_ZKNE_CAPABLE) && defined(RV32I_ZKND_ZKNE_CAPABLE)
# include "cipher_aes_ccm_hw_rv32i_zknd_zkne.inc"
#else
const PROV_CCM_HW *ossl_prov_aes_hw_ccm(size_t keybits)
{

60
providers/implementations/ciphers/cipher_aes_ccm_hw_rv32i_zknd_zkne.inc Normal file

@ -0,0 +1,60 @@
/*
* Copyright 2022 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
*/
/*-
* RISC-V 32 ZKND ZKNE support for AES CCM.
* This file is included by cipher_aes_ccm_hw.c
*/
static int ccm_rv32i_zknd_zkne_initkey(PROV_CCM_CTX *ctx, const unsigned char *key,
size_t keylen)
{
PROV_AES_CCM_CTX *actx = (PROV_AES_CCM_CTX *)ctx;
AES_HW_CCM_SET_KEY_FN(rv32i_zkne_set_encrypt_key, rv32i_zkne_encrypt,
NULL, NULL);
return 1;
}
static int ccm_rv32i_zbkb_zknd_zkne_initkey(PROV_CCM_CTX *ctx, const unsigned char *key,
size_t keylen)
{
PROV_AES_CCM_CTX *actx = (PROV_AES_CCM_CTX *)ctx;
AES_HW_CCM_SET_KEY_FN(rv32i_zbkb_zkne_set_encrypt_key, rv32i_zkne_encrypt,
NULL, NULL);
return 1;
}
static const PROV_CCM_HW rv32i_zknd_zkne_ccm = {
ccm_rv32i_zknd_zkne_initkey,
ossl_ccm_generic_setiv,
ossl_ccm_generic_setaad,
ossl_ccm_generic_auth_encrypt,
ossl_ccm_generic_auth_decrypt,
ossl_ccm_generic_gettag
};
static const PROV_CCM_HW rv32i_zbkb_zknd_zkne_ccm = {
ccm_rv32i_zbkb_zknd_zkne_initkey,
ossl_ccm_generic_setiv,
ossl_ccm_generic_setaad,
ossl_ccm_generic_auth_encrypt,
ossl_ccm_generic_auth_decrypt,
ossl_ccm_generic_gettag
};
const PROV_CCM_HW *ossl_prov_aes_hw_ccm(size_t keybits)
{
if (RV32I_ZBKB_ZKND_ZKNE_CAPABLE)
return &rv32i_zbkb_zknd_zkne_ccm;
if (RV32I_ZKND_ZKNE_CAPABLE)
return &rv32i_zknd_zkne_ccm;
return &aes_ccm;
}

2
providers/implementations/ciphers/cipher_aes_gcm_hw.c

@ -145,6 +145,8 @@ static const PROV_GCM_HW aes_gcm = {
# include "cipher_aes_gcm_hw_ppc.inc"
#elif defined(RV64I_ZKND_ZKNE_CAPABLE)
# include "cipher_aes_gcm_hw_rv64i_zknd_zkne.inc"
#elif defined(RV32I_ZBKB_ZKND_ZKNE_CAPABLE) && defined(RV32I_ZKND_ZKNE_CAPABLE)
# include "cipher_aes_gcm_hw_rv32i_zknd_zkne.inc"
#else
const PROV_GCM_HW *ossl_prov_aes_hw_gcm(size_t keybits)
{

63
providers/implementations/ciphers/cipher_aes_gcm_hw_rv32i_zknd_zkne.inc Normal file

@ -0,0 +1,63 @@
/*
* Copyright 2022 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
*/
/*-
* RISC-V 32 ZKND ZKNE support for AES GCM.
* This file is included by cipher_aes_gcm_hw.c
*/
static int rv32i_zknd_zkne_gcm_initkey(PROV_GCM_CTX *ctx, const unsigned char *key,
size_t keylen)
{
PROV_AES_GCM_CTX *actx = (PROV_AES_GCM_CTX *)ctx;
AES_KEY *ks = &actx->ks.ks;
GCM_HW_SET_KEY_CTR_FN(ks, rv32i_zkne_set_encrypt_key, rv32i_zkne_encrypt,
NULL);
return 1;
}
static int rv32i_zbkb_zknd_zkne_gcm_initkey(PROV_GCM_CTX *ctx,
const unsigned char *key,
size_t keylen)
{
PROV_AES_GCM_CTX *actx = (PROV_AES_GCM_CTX *)ctx;
AES_KEY *ks = &actx->ks.ks;
GCM_HW_SET_KEY_CTR_FN(ks, rv32i_zbkb_zkne_set_encrypt_key, rv32i_zkne_encrypt,
NULL);
return 1;
}
static const PROV_GCM_HW rv32i_zknd_zkne_gcm = {
rv32i_zknd_zkne_gcm_initkey,
ossl_gcm_setiv,
ossl_gcm_aad_update,
generic_aes_gcm_cipher_update,
ossl_gcm_cipher_final,
ossl_gcm_one_shot
};
static const PROV_GCM_HW rv32i_zbkb_zknd_zkne_gcm = {
rv32i_zbkb_zknd_zkne_gcm_initkey,
ossl_gcm_setiv,
ossl_gcm_aad_update,
generic_aes_gcm_cipher_update,
ossl_gcm_cipher_final,
ossl_gcm_one_shot
};
const PROV_GCM_HW *ossl_prov_aes_hw_gcm(size_t keybits)
{
if (RV32I_ZBKB_ZKND_ZKNE_CAPABLE)
return &rv32i_zbkb_zknd_zkne_gcm;
if (RV32I_ZKND_ZKNE_CAPABLE)
return &rv32i_zknd_zkne_gcm;
return &aes_gcm;
}

2
providers/implementations/ciphers/cipher_aes_hw.c

@ -144,6 +144,8 @@ const PROV_CIPHER_HW *ossl_prov_cipher_hw_aes_##mode(size_t keybits) \
# include "cipher_aes_hw_s390x.inc"
#elif defined(RV64I_ZKND_ZKNE_CAPABLE)
# include "cipher_aes_hw_rv64i_zknd_zkne.inc"
#elif defined(RV32I_ZBKB_ZKND_ZKNE_CAPABLE) && defined(RV32I_ZKND_ZKNE_CAPABLE)
# include "cipher_aes_hw_rv32i_zknd_zkne.inc"
#else
/* The generic case */
# define PROV_CIPHER_HW_declare(mode)

102
providers/implementations/ciphers/cipher_aes_hw_rv32i_zknd_zkne.inc Normal file

@ -0,0 +1,102 @@
/*
* Copyright 2022 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
*/
/*-
* RISC-V 32 ZKND ZKNE support for AES modes ecb, cbc, ofb, cfb, ctr.
* This file is included by cipher_aes_hw.c
*/
#define cipher_hw_rv32i_zknd_zkne_cbc ossl_cipher_hw_generic_cbc
#define cipher_hw_rv32i_zknd_zkne_ecb ossl_cipher_hw_generic_ecb
#define cipher_hw_rv32i_zknd_zkne_ofb128 ossl_cipher_hw_generic_ofb128
#define cipher_hw_rv32i_zknd_zkne_cfb128 ossl_cipher_hw_generic_cfb128
#define cipher_hw_rv32i_zknd_zkne_cfb8 ossl_cipher_hw_generic_cfb8
#define cipher_hw_rv32i_zknd_zkne_cfb1 ossl_cipher_hw_generic_cfb1
#define cipher_hw_rv32i_zknd_zkne_ctr ossl_cipher_hw_generic_ctr
#define cipher_hw_rv32i_zbkb_zknd_zkne_cbc ossl_cipher_hw_generic_cbc
#define cipher_hw_rv32i_zbkb_zknd_zkne_ecb ossl_cipher_hw_generic_ecb
#define cipher_hw_rv32i_zbkb_zknd_zkne_ofb128 ossl_cipher_hw_generic_ofb128
#define cipher_hw_rv32i_zbkb_zknd_zkne_cfb128 ossl_cipher_hw_generic_cfb128
#define cipher_hw_rv32i_zbkb_zknd_zkne_cfb8 ossl_cipher_hw_generic_cfb8
#define cipher_hw_rv32i_zbkb_zknd_zkne_cfb1 ossl_cipher_hw_generic_cfb1
#define cipher_hw_rv32i_zbkb_zknd_zkne_ctr ossl_cipher_hw_generic_ctr
static int cipher_hw_rv32i_zknd_zkne_initkey(PROV_CIPHER_CTX *dat,
const unsigned char *key, size_t keylen)
{
int ret;
PROV_AES_CTX *adat = (PROV_AES_CTX *)dat;
AES_KEY *ks = &adat->ks.ks;
dat->ks = ks;
if ((dat->mode == EVP_CIPH_ECB_MODE || dat->mode == EVP_CIPH_CBC_MODE)
&& !dat->enc) {
ret = rv32i_zknd_zkne_set_decrypt_key(key, keylen * 8, ks);
dat->block = (block128_f) rv32i_zknd_decrypt;
dat->stream.cbc = NULL;
} else {
ret = rv32i_zkne_set_encrypt_key(key, keylen * 8, ks);
dat->block = (block128_f) rv32i_zkne_encrypt;
dat->stream.cbc = NULL;
}
if (ret < 0) {
ERR_raise(ERR_LIB_PROV, PROV_R_KEY_SETUP_FAILED);
return 0;
}
return 1;
}
static int cipher_hw_rv32i_zbkb_zknd_zkne_initkey(PROV_CIPHER_CTX *dat,
const unsigned char *key, size_t keylen)
{
int ret;
PROV_AES_CTX *adat = (PROV_AES_CTX *)dat;
AES_KEY *ks = &adat->ks.ks;
dat->ks = ks;
if ((dat->mode == EVP_CIPH_ECB_MODE || dat->mode == EVP_CIPH_CBC_MODE)
&& !dat->enc) {
ret = rv32i_zbkb_zknd_zkne_set_decrypt_key(key, keylen * 8, ks);
dat->block = (block128_f) rv32i_zknd_decrypt;
dat->stream.cbc = NULL;
} else {
ret = rv32i_zbkb_zkne_set_encrypt_key(key, keylen * 8, ks);
dat->block = (block128_f) rv32i_zkne_encrypt;
dat->stream.cbc = NULL;
}
if (ret < 0) {
ERR_raise(ERR_LIB_PROV, PROV_R_KEY_SETUP_FAILED);
return 0;
}
return 1;
}
#define PROV_CIPHER_HW_declare(mode) \
static const PROV_CIPHER_HW rv32i_zknd_zkne_##mode = { \
cipher_hw_rv32i_zknd_zkne_initkey, \
cipher_hw_rv32i_zknd_zkne_##mode, \
cipher_hw_aes_copyctx \
}; \
static const PROV_CIPHER_HW rv32i_zbkb_zknd_zkne_##mode = { \
cipher_hw_rv32i_zbkb_zknd_zkne_initkey, \
cipher_hw_rv32i_zbkb_zknd_zkne_##mode, \
cipher_hw_aes_copyctx \
};
#define PROV_CIPHER_HW_select(mode) \
if (RV32I_ZBKB_ZKND_ZKNE_CAPABLE) \
return &rv32i_zbkb_zknd_zkne_##mode; \
if (RV32I_ZKND_ZKNE_CAPABLE) \
return &rv32i_zknd_zkne_##mode;

38
providers/implementations/ciphers/cipher_aes_ocb_hw.c

@ -124,6 +124,44 @@ static const PROV_CIPHER_HW aes_rv64i_zknd_zkne_ocb = { \
# define PROV_CIPHER_HW_select() \
if (RV64I_ZKND_ZKNE_CAPABLE) \
return &aes_rv64i_zknd_zkne_ocb;
#elif defined(RV32I_ZBKB_ZKND_ZKNE_CAPABLE) && defined(RV32I_ZKND_ZKNE_CAPABLE)
static int cipher_hw_aes_ocb_rv32i_zknd_zkne_initkey(PROV_CIPHER_CTX *vctx,
const unsigned char *key,
size_t keylen)
{
PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
OCB_SET_KEY_FN(rv32i_zkne_set_encrypt_key, rv32i_zknd_zkne_set_decrypt_key,
rv32i_zkne_encrypt, rv32i_zknd_decrypt, NULL, NULL);
return 1;
}
static int cipher_hw_aes_ocb_rv32i_zbkb_zknd_zkne_initkey(PROV_CIPHER_CTX *vctx,
const unsigned char *key,
size_t keylen)
{
PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
OCB_SET_KEY_FN(rv32i_zbkb_zkne_set_encrypt_key, rv32i_zbkb_zknd_zkne_set_decrypt_key,
rv32i_zkne_encrypt, rv32i_zknd_decrypt, NULL, NULL);
return 1;
}
# define PROV_CIPHER_HW_declare() \
static const PROV_CIPHER_HW aes_rv32i_zknd_zkne_ocb = { \
cipher_hw_aes_ocb_rv32i_zknd_zkne_initkey, \
NULL \
}; \
static const PROV_CIPHER_HW aes_rv32i_zbkb_zknd_zkne_ocb = { \
cipher_hw_aes_ocb_rv32i_zbkb_zknd_zkne_initkey, \
NULL \
};
# define PROV_CIPHER_HW_select() \
if (RV32I_ZBKB_ZKND_ZKNE_CAPABLE) \
return &aes_rv32i_zbkb_zknd_zkne_ocb; \
if (RV32I_ZKND_ZKNE_CAPABLE) \
return &aes_rv32i_zknd_zkne_ocb;
#else
# define PROV_CIPHER_HW_declare()
# define PROV_CIPHER_HW_select()

42
providers/implementations/ciphers/cipher_aes_xts_hw.c

@ -183,6 +183,48 @@ static const PROV_CIPHER_HW aes_xts_rv64i_zknd_zkne = { \
# define PROV_CIPHER_HW_select_xts() \
if (RV64I_ZKND_ZKNE_CAPABLE) \
return &aes_xts_rv64i_zknd_zkne;
#elif defined(RV32I_ZBKB_ZKND_ZKNE_CAPABLE) && defined(RV32I_ZKND_ZKNE_CAPABLE)
static int cipher_hw_aes_xts_rv32i_zknd_zkne_initkey(PROV_CIPHER_CTX *ctx,
const unsigned char *key,
size_t keylen)
{
PROV_AES_XTS_CTX *xctx = (PROV_AES_XTS_CTX *)ctx;
XTS_SET_KEY_FN(rv32i_zkne_set_encrypt_key, rv32i_zknd_zkne_set_decrypt_key,
rv32i_zkne_encrypt, rv32i_zknd_decrypt,
NULL, NULL);
return 1;
}
static int cipher_hw_aes_xts_rv32i_zbkb_zknd_zkne_initkey(PROV_CIPHER_CTX *ctx,
const unsigned char *key,
size_t keylen)
{
PROV_AES_XTS_CTX *xctx = (PROV_AES_XTS_CTX *)ctx;
XTS_SET_KEY_FN(rv32i_zbkb_zkne_set_encrypt_key, rv32i_zbkb_zknd_zkne_set_decrypt_key,
rv32i_zkne_encrypt, rv32i_zknd_decrypt,
NULL, NULL);
return 1;
}
# define PROV_CIPHER_HW_declare_xts() \
static const PROV_CIPHER_HW aes_xts_rv32i_zknd_zkne = { \
cipher_hw_aes_xts_rv32i_zknd_zkne_initkey, \
NULL, \
cipher_hw_aes_xts_copyctx \
}; \
static const PROV_CIPHER_HW aes_xts_rv32i_zbkb_zknd_zkne = { \
cipher_hw_aes_xts_rv32i_zbkb_zknd_zkne_initkey, \
NULL, \
cipher_hw_aes_xts_copyctx \
};
# define PROV_CIPHER_HW_select_xts() \
if (RV32I_ZBKB_ZKND_ZKNE_CAPABLE) \
return &aes_xts_rv32i_zbkb_zknd_zkne; \
if (RV32I_ZKND_ZKNE_CAPABLE) \
return &aes_xts_rv32i_zknd_zkne;
# else
/* The generic case */
# define PROV_CIPHER_HW_declare_xts()