2019-05-27 09:55:01 +03:00
// SPDX-License-Identifier: GPL-2.0-or-later
2015-06-16 20:30:55 +03:00
/*
* Public Key Encryption
*
* Copyright ( c ) 2015 , Intel Corporation
* Authors : Tadeusz Struk < tadeusz . struk @ intel . com >
*/
2023-02-16 13:35:13 +03:00
# include <crypto/internal/akcipher.h>
# include <linux/cryptouser.h>
2015-06-16 20:30:55 +03:00
# include <linux/errno.h>
# include <linux/kernel.h>
# include <linux/module.h>
# include <linux/seq_file.h>
# include <linux/slab.h>
# include <linux/string.h>
# include <net/netlink.h>
2023-02-16 13:35:13 +03:00
2015-06-16 20:30:55 +03:00
# include "internal.h"
2023-02-16 13:35:28 +03:00
static int __maybe_unused crypto_akcipher_report (
struct sk_buff * skb , struct crypto_alg * alg )
2015-06-16 20:30:55 +03:00
{
struct crypto_report_akcipher rakcipher ;
2018-11-04 00:56:03 +03:00
memset ( & rakcipher , 0 , sizeof ( rakcipher ) ) ;
2015-06-16 20:30:55 +03:00
2018-11-04 00:56:03 +03:00
strscpy ( rakcipher . type , " akcipher " , sizeof ( rakcipher . type ) ) ;
2015-06-16 20:30:55 +03:00
2018-11-04 00:56:03 +03:00
return nla_put ( skb , CRYPTOCFGA_REPORT_AKCIPHER ,
sizeof ( rakcipher ) , & rakcipher ) ;
2015-06-16 20:30:55 +03:00
}
static void crypto_akcipher_show ( struct seq_file * m , struct crypto_alg * alg )
2016-12-31 18:56:23 +03:00
__maybe_unused ;
2015-06-16 20:30:55 +03:00
static void crypto_akcipher_show ( struct seq_file * m , struct crypto_alg * alg )
{
seq_puts ( m , " type : akcipher \n " ) ;
}
static void crypto_akcipher_exit_tfm ( struct crypto_tfm * tfm )
{
struct crypto_akcipher * akcipher = __crypto_akcipher_tfm ( tfm ) ;
struct akcipher_alg * alg = crypto_akcipher_alg ( akcipher ) ;
alg - > exit ( akcipher ) ;
}
static int crypto_akcipher_init_tfm ( struct crypto_tfm * tfm )
{
struct crypto_akcipher * akcipher = __crypto_akcipher_tfm ( tfm ) ;
struct akcipher_alg * alg = crypto_akcipher_alg ( akcipher ) ;
if ( alg - > exit )
akcipher - > base . exit = crypto_akcipher_exit_tfm ;
if ( alg - > init )
return alg - > init ( akcipher ) ;
return 0 ;
}
2015-12-05 19:09:33 +03:00
static void crypto_akcipher_free_instance ( struct crypto_instance * inst )
{
struct akcipher_instance * akcipher = akcipher_instance ( inst ) ;
akcipher - > free ( akcipher ) ;
}
2023-02-16 13:35:13 +03:00
static int __maybe_unused crypto_akcipher_report_stat (
struct sk_buff * skb , struct crypto_alg * alg )
{
struct akcipher_alg * akcipher = __crypto_akcipher_alg ( alg ) ;
struct crypto_istat_akcipher * istat ;
struct crypto_stat_akcipher rakcipher ;
istat = akcipher_get_stat ( akcipher ) ;
memset ( & rakcipher , 0 , sizeof ( rakcipher ) ) ;
strscpy ( rakcipher . type , " akcipher " , sizeof ( rakcipher . type ) ) ;
rakcipher . stat_encrypt_cnt = atomic64_read ( & istat - > encrypt_cnt ) ;
rakcipher . stat_encrypt_tlen = atomic64_read ( & istat - > encrypt_tlen ) ;
rakcipher . stat_decrypt_cnt = atomic64_read ( & istat - > decrypt_cnt ) ;
rakcipher . stat_decrypt_tlen = atomic64_read ( & istat - > decrypt_tlen ) ;
rakcipher . stat_sign_cnt = atomic64_read ( & istat - > sign_cnt ) ;
rakcipher . stat_verify_cnt = atomic64_read ( & istat - > verify_cnt ) ;
rakcipher . stat_err_cnt = atomic64_read ( & istat - > err_cnt ) ;
return nla_put ( skb , CRYPTOCFGA_STAT_AKCIPHER ,
sizeof ( rakcipher ) , & rakcipher ) ;
}
2015-06-16 20:30:55 +03:00
static const struct crypto_type crypto_akcipher_type = {
. extsize = crypto_alg_extsize ,
. init_tfm = crypto_akcipher_init_tfm ,
2015-12-05 19:09:33 +03:00
. free = crypto_akcipher_free_instance ,
2015-06-16 20:30:55 +03:00
# ifdef CONFIG_PROC_FS
. show = crypto_akcipher_show ,
# endif
2023-05-02 11:02:33 +03:00
# if IS_ENABLED(CONFIG_CRYPTO_USER)
2015-06-16 20:30:55 +03:00
. report = crypto_akcipher_report ,
2023-02-16 13:35:28 +03:00
# endif
2023-02-16 13:35:13 +03:00
# ifdef CONFIG_CRYPTO_STATS
. report_stat = crypto_akcipher_report_stat ,
# endif
2015-06-16 20:30:55 +03:00
. maskclear = ~ CRYPTO_ALG_TYPE_MASK ,
. maskset = CRYPTO_ALG_TYPE_MASK ,
. type = CRYPTO_ALG_TYPE_AKCIPHER ,
. tfmsize = offsetof ( struct crypto_akcipher , base ) ,
} ;
2020-01-03 06:58:47 +03:00
int crypto_grab_akcipher ( struct crypto_akcipher_spawn * spawn ,
struct crypto_instance * inst ,
const char * name , u32 type , u32 mask )
2015-12-05 19:09:33 +03:00
{
spawn - > base . frontend = & crypto_akcipher_type ;
2020-01-03 06:58:48 +03:00
return crypto_grab_spawn ( & spawn - > base , inst , name , type , mask ) ;
2015-12-05 19:09:33 +03:00
}
EXPORT_SYMBOL_GPL ( crypto_grab_akcipher ) ;
2015-06-16 20:30:55 +03:00
struct crypto_akcipher * crypto_alloc_akcipher ( const char * alg_name , u32 type ,
u32 mask )
{
return crypto_alloc_tfm ( alg_name , & crypto_akcipher_type , type , mask ) ;
}
EXPORT_SYMBOL_GPL ( crypto_alloc_akcipher ) ;
2015-12-05 19:09:33 +03:00
static void akcipher_prepare_alg ( struct akcipher_alg * alg )
2015-06-16 20:30:55 +03:00
{
2023-02-16 13:35:13 +03:00
struct crypto_istat_akcipher * istat = akcipher_get_stat ( alg ) ;
2015-06-16 20:30:55 +03:00
struct crypto_alg * base = & alg - > base ;
base - > cra_type = & crypto_akcipher_type ;
base - > cra_flags & = ~ CRYPTO_ALG_TYPE_MASK ;
base - > cra_flags | = CRYPTO_ALG_TYPE_AKCIPHER ;
2023-02-16 13:35:13 +03:00
if ( IS_ENABLED ( CONFIG_CRYPTO_STATS ) )
memset ( istat , 0 , sizeof ( * istat ) ) ;
2015-12-05 19:09:33 +03:00
}
2019-04-11 18:51:13 +03:00
static int akcipher_default_op ( struct akcipher_request * req )
{
return - ENOSYS ;
}
2022-08-31 21:37:06 +03:00
static int akcipher_default_set_key ( struct crypto_akcipher * tfm ,
const void * key , unsigned int keylen )
{
return - ENOSYS ;
}
2015-12-05 19:09:33 +03:00
int crypto_register_akcipher ( struct akcipher_alg * alg )
{
struct crypto_alg * base = & alg - > base ;
2019-04-11 18:51:13 +03:00
if ( ! alg - > sign )
alg - > sign = akcipher_default_op ;
if ( ! alg - > verify )
alg - > verify = akcipher_default_op ;
if ( ! alg - > encrypt )
alg - > encrypt = akcipher_default_op ;
if ( ! alg - > decrypt )
alg - > decrypt = akcipher_default_op ;
2022-08-31 21:37:06 +03:00
if ( ! alg - > set_priv_key )
alg - > set_priv_key = akcipher_default_set_key ;
2019-04-11 18:51:13 +03:00
2015-12-05 19:09:33 +03:00
akcipher_prepare_alg ( alg ) ;
2015-06-16 20:30:55 +03:00
return crypto_register_alg ( base ) ;
}
EXPORT_SYMBOL_GPL ( crypto_register_akcipher ) ;
void crypto_unregister_akcipher ( struct akcipher_alg * alg )
{
crypto_unregister_alg ( & alg - > base ) ;
}
EXPORT_SYMBOL_GPL ( crypto_unregister_akcipher ) ;
2015-12-05 19:09:33 +03:00
int akcipher_register_instance ( struct crypto_template * tmpl ,
struct akcipher_instance * inst )
{
2020-01-03 07:04:40 +03:00
if ( WARN_ON ( ! inst - > free ) )
return - EINVAL ;
2015-12-05 19:09:33 +03:00
akcipher_prepare_alg ( & inst - > alg ) ;
return crypto_register_instance ( tmpl , akcipher_crypto_instance ( inst ) ) ;
}
EXPORT_SYMBOL_GPL ( akcipher_register_instance ) ;
2015-06-16 20:30:55 +03:00
MODULE_LICENSE ( " GPL " ) ;
2015-06-23 20:18:53 +03:00
MODULE_DESCRIPTION ( " Generic public key cipher type " ) ;