Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 28a4618a authored by Andrzej Zaborowski's avatar Andrzej Zaborowski Committed by Herbert Xu
Browse files

crypto: akcipher - add akcipher declarations needed by templates. 



Add a struct akcipher_instance and struct akcipher_spawn similar to
how AEAD declares them and the macros for converting to/from
crypto_instance/crypto_spawn.  Also add register functions to
avoid exposing crypto_akcipher_type.

Signed-off-by: default avatarAndrew Zaborowski <andrew.zaborowski@intel.com>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent 3771df3c

crypto/akcipher.c

+33 −1
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ 
#include <linux/cryptouser.h>

#include <net/netlink.h>

#include <crypto/akcipher.h>

#include <crypto/internal/akcipher.h>

#include "internal.h"



#ifdef CONFIG_NET
@@ -75,9 +76,17 @@ static int crypto_akcipher_init_tfm(struct crypto_tfm *tfm) 
	return 0;

}



static void crypto_akcipher_free_instance(struct crypto_instance *inst)

{

	struct akcipher_instance *akcipher = akcipher_instance(inst);



	akcipher->free(akcipher);

}



static const struct crypto_type crypto_akcipher_type = {

	.extsize = crypto_alg_extsize,

	.init_tfm = crypto_akcipher_init_tfm,

	.free = crypto_akcipher_free_instance,

#ifdef CONFIG_PROC_FS

	.show = crypto_akcipher_show,

#endif
@@ -88,6 +97,14 @@ static const struct crypto_type crypto_akcipher_type = { 
	.tfmsize = offsetof(struct crypto_akcipher, base),

};



int crypto_grab_akcipher(struct crypto_akcipher_spawn *spawn, const char *name,

			 u32 type, u32 mask)

{

	spawn->base.frontend = &crypto_akcipher_type;

	return crypto_grab_spawn(&spawn->base, name, type, mask);

}

EXPORT_SYMBOL_GPL(crypto_grab_akcipher);



struct crypto_akcipher *crypto_alloc_akcipher(const char *alg_name, u32 type,

					      u32 mask)

{
@@ -95,13 +112,20 @@ struct crypto_akcipher *crypto_alloc_akcipher(const char *alg_name, u32 type, 
}

EXPORT_SYMBOL_GPL(crypto_alloc_akcipher);



int crypto_register_akcipher(struct akcipher_alg *alg)

static void akcipher_prepare_alg(struct akcipher_alg *alg)

{

	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;

}



int crypto_register_akcipher(struct akcipher_alg *alg)

{

	struct crypto_alg *base = &alg->base;



	akcipher_prepare_alg(alg);

	return crypto_register_alg(base);

}

EXPORT_SYMBOL_GPL(crypto_register_akcipher);
@@ -112,5 +136,13 @@ void crypto_unregister_akcipher(struct akcipher_alg *alg) 
}

EXPORT_SYMBOL_GPL(crypto_unregister_akcipher);



int akcipher_register_instance(struct crypto_template *tmpl,

			       struct akcipher_instance *inst)

{

	akcipher_prepare_alg(&inst->alg);

	return crypto_register_instance(tmpl, akcipher_crypto_instance(inst));

}

EXPORT_SYMBOL_GPL(akcipher_register_instance);



MODULE_LICENSE("GPL");

MODULE_DESCRIPTION("Generic public key cipher type");

include/crypto/internal/akcipher.h

+78 −0
Original line number Diff line number Diff line
@@ -13,6 +13,22 @@ 
#ifndef _CRYPTO_AKCIPHER_INT_H

#define _CRYPTO_AKCIPHER_INT_H

#include <crypto/akcipher.h>

#include <crypto/algapi.h>



struct akcipher_instance {

	void (*free)(struct akcipher_instance *inst);

	union {

		struct {

			char head[offsetof(struct akcipher_alg, base)];

			struct crypto_instance base;

		} s;

		struct akcipher_alg alg;

	};

};



struct crypto_akcipher_spawn {

	struct crypto_spawn base;

};



/*

 * Transform internal helpers.
@@ -38,6 +54,56 @@ static inline const char *akcipher_alg_name(struct crypto_akcipher *tfm) 
	return crypto_akcipher_tfm(tfm)->__crt_alg->cra_name;

}



static inline struct crypto_instance *akcipher_crypto_instance(

		struct akcipher_instance *inst)

{

	return container_of(&inst->alg.base, struct crypto_instance, alg);

}



static inline struct akcipher_instance *akcipher_instance(

		struct crypto_instance *inst)

{

	return container_of(&inst->alg, struct akcipher_instance, alg.base);

}



static inline struct akcipher_instance *akcipher_alg_instance(

		struct crypto_akcipher *akcipher)

{

	return akcipher_instance(crypto_tfm_alg_instance(&akcipher->base));

}



static inline void *akcipher_instance_ctx(struct akcipher_instance *inst)

{

	return crypto_instance_ctx(akcipher_crypto_instance(inst));

}



static inline void crypto_set_akcipher_spawn(

		struct crypto_akcipher_spawn *spawn,

		struct crypto_instance *inst)

{

	crypto_set_spawn(&spawn->base, inst);

}



int crypto_grab_akcipher(struct crypto_akcipher_spawn *spawn, const char *name,

		u32 type, u32 mask);



static inline struct crypto_akcipher *crypto_spawn_akcipher(

		struct crypto_akcipher_spawn *spawn)

{

	return crypto_spawn_tfm2(&spawn->base);

}



static inline void crypto_drop_akcipher(struct crypto_akcipher_spawn *spawn)

{

	crypto_drop_spawn(&spawn->base);

}



static inline struct akcipher_alg *crypto_spawn_akcipher_alg(

		struct crypto_akcipher_spawn *spawn)

{

	return container_of(spawn->base.alg, struct akcipher_alg, base);

}



/**

 * crypto_register_akcipher() -- Register public key algorithm

 *
@@ -57,4 +123,16 @@ int crypto_register_akcipher(struct akcipher_alg *alg); 
 * @alg:	algorithm definition

 */

void crypto_unregister_akcipher(struct akcipher_alg *alg);



/**

 * akcipher_register_instance() -- Unregister public key template instance

 *

 * Function registers an implementation of an asymmetric key algorithm

 * created from a template

 *

 * @tmpl:	the template from which the algorithm was created

 * @inst:	the template instance

 */

int akcipher_register_instance(struct crypto_template *tmpl,

		struct akcipher_instance *inst);

#endif