xref: /openbmc/linux/include/crypto/internal/kpp.h (revision ba354b2f)
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /*
3  * Key-agreement Protocol Primitives (KPP)
4  *
5  * Copyright (c) 2016, Intel Corporation
6  * Authors: Salvatore Benedetto <salvatore.benedetto@intel.com>
7  */
8 #ifndef _CRYPTO_KPP_INT_H
9 #define _CRYPTO_KPP_INT_H
10 #include <crypto/kpp.h>
11 #include <crypto/algapi.h>
12 
13 /**
14  * struct kpp_instance - KPP template instance
15  * @free: Callback getting invoked upon instance destruction. Must be set.
16  * @s: Internal. Generic crypto core instance state properly layout
17  *     to alias with @alg as needed.
18  * @alg: The &struct kpp_alg implementation provided by the instance.
19  */
20 struct kpp_instance {
21 	void (*free)(struct kpp_instance *inst);
22 	union {
23 		struct {
24 			char head[offsetof(struct kpp_alg, base)];
25 			struct crypto_instance base;
26 		} s;
27 		struct kpp_alg alg;
28 	};
29 };
30 
31 /**
32  * struct crypto_kpp_spawn - KPP algorithm spawn
33  * @base: Internal. Generic crypto core spawn state.
34  *
35  * Template instances can get a hold on some inner KPP algorithm by
36  * binding a &struct crypto_kpp_spawn via
37  * crypto_grab_kpp(). Transforms may subsequently get instantiated
38  * from the referenced inner &struct kpp_alg by means of
39  * crypto_spawn_kpp().
40  */
41 struct crypto_kpp_spawn {
42 	struct crypto_spawn base;
43 };
44 
45 /*
46  * Transform internal helpers.
47  */
kpp_request_ctx(struct kpp_request * req)48 static inline void *kpp_request_ctx(struct kpp_request *req)
49 {
50 	return req->__ctx;
51 }
52 
kpp_request_ctx_dma(struct kpp_request * req)53 static inline void *kpp_request_ctx_dma(struct kpp_request *req)
54 {
55 	unsigned int align = crypto_dma_align();
56 
57 	if (align <= crypto_tfm_ctx_alignment())
58 		align = 1;
59 
60 	return PTR_ALIGN(kpp_request_ctx(req), align);
61 }
62 
kpp_set_reqsize(struct crypto_kpp * kpp,unsigned int reqsize)63 static inline void kpp_set_reqsize(struct crypto_kpp *kpp,
64 				   unsigned int reqsize)
65 {
66 	kpp->reqsize = reqsize;
67 }
68 
kpp_set_reqsize_dma(struct crypto_kpp * kpp,unsigned int reqsize)69 static inline void kpp_set_reqsize_dma(struct crypto_kpp *kpp,
70 				       unsigned int reqsize)
71 {
72 	reqsize += crypto_dma_align() & ~(crypto_tfm_ctx_alignment() - 1);
73 	kpp->reqsize = reqsize;
74 }
75 
kpp_tfm_ctx(struct crypto_kpp * tfm)76 static inline void *kpp_tfm_ctx(struct crypto_kpp *tfm)
77 {
78 	return crypto_tfm_ctx(&tfm->base);
79 }
80 
kpp_tfm_ctx_dma(struct crypto_kpp * tfm)81 static inline void *kpp_tfm_ctx_dma(struct crypto_kpp *tfm)
82 {
83 	return crypto_tfm_ctx_dma(&tfm->base);
84 }
85 
kpp_request_complete(struct kpp_request * req,int err)86 static inline void kpp_request_complete(struct kpp_request *req, int err)
87 {
88 	crypto_request_complete(&req->base, err);
89 }
90 
kpp_alg_name(struct crypto_kpp * tfm)91 static inline const char *kpp_alg_name(struct crypto_kpp *tfm)
92 {
93 	return crypto_kpp_tfm(tfm)->__crt_alg->cra_name;
94 }
95 
96 /*
97  * Template instance internal helpers.
98  */
99 /**
100  * kpp_crypto_instance() - Cast a &struct kpp_instance to the corresponding
101  *                         generic &struct crypto_instance.
102  * @inst: Pointer to the &struct kpp_instance to be cast.
103  * Return: A pointer to the &struct crypto_instance embedded in @inst.
104  */
kpp_crypto_instance(struct kpp_instance * inst)105 static inline struct crypto_instance *kpp_crypto_instance(
106 	struct kpp_instance *inst)
107 {
108 	return &inst->s.base;
109 }
110 
111 /**
112  * kpp_instance() - Cast a generic &struct crypto_instance to the corresponding
113  *                  &struct kpp_instance.
114  * @inst: Pointer to the &struct crypto_instance to be cast.
115  * Return: A pointer to the &struct kpp_instance @inst is embedded in.
116  */
kpp_instance(struct crypto_instance * inst)117 static inline struct kpp_instance *kpp_instance(struct crypto_instance *inst)
118 {
119 	return container_of(inst, struct kpp_instance, s.base);
120 }
121 
122 /**
123  * kpp_alg_instance() - Get the &struct kpp_instance a given KPP transform has
124  *                      been instantiated from.
125  * @kpp: The KPP transform instantiated from some &struct kpp_instance.
126  * Return: The &struct kpp_instance associated with @kpp.
127  */
kpp_alg_instance(struct crypto_kpp * kpp)128 static inline struct kpp_instance *kpp_alg_instance(struct crypto_kpp *kpp)
129 {
130 	return kpp_instance(crypto_tfm_alg_instance(&kpp->base));
131 }
132 
133 /**
134  * kpp_instance_ctx() - Get a pointer to a &struct kpp_instance's implementation
135  *                      specific context data.
136  * @inst: The &struct kpp_instance whose context data to access.
137  *
138  * A KPP template implementation may allocate extra memory beyond the
139  * end of a &struct kpp_instance instantiated from &crypto_template.create().
140  * This function provides a means to obtain a pointer to this area.
141  *
142  * Return: A pointer to the implementation specific context data.
143  */
kpp_instance_ctx(struct kpp_instance * inst)144 static inline void *kpp_instance_ctx(struct kpp_instance *inst)
145 {
146 	return crypto_instance_ctx(kpp_crypto_instance(inst));
147 }
148 
149 /*
150  * KPP algorithm (un)registration functions.
151  */
152 /**
153  * crypto_register_kpp() -- Register key-agreement protocol primitives algorithm
154  *
155  * Function registers an implementation of a key-agreement protocol primitive
156  * algorithm
157  *
158  * @alg:	algorithm definition
159  *
160  * Return: zero on success; error code in case of error
161  */
162 int crypto_register_kpp(struct kpp_alg *alg);
163 
164 /**
165  * crypto_unregister_kpp() -- Unregister key-agreement protocol primitive
166  * algorithm
167  *
168  * Function unregisters an implementation of a key-agreement protocol primitive
169  * algorithm
170  *
171  * @alg:	algorithm definition
172  */
173 void crypto_unregister_kpp(struct kpp_alg *alg);
174 
175 /**
176  * kpp_register_instance() - Register a KPP template instance.
177  * @tmpl: The instantiating template.
178  * @inst: The KPP template instance to be registered.
179  * Return: %0 on success, negative error code otherwise.
180  */
181 int kpp_register_instance(struct crypto_template *tmpl,
182 			  struct kpp_instance *inst);
183 
184 /*
185  * KPP spawn related functions.
186  */
187 /**
188  * crypto_grab_kpp() - Look up a KPP algorithm and bind a spawn to it.
189  * @spawn: The KPP spawn to bind.
190  * @inst: The template instance owning @spawn.
191  * @name: The KPP algorithm name to look up.
192  * @type: The type bitset to pass on to the lookup.
193  * @mask: The mask bismask to pass on to the lookup.
194  * Return: %0 on success, a negative error code otherwise.
195  */
196 int crypto_grab_kpp(struct crypto_kpp_spawn *spawn,
197 		    struct crypto_instance *inst,
198 		    const char *name, u32 type, u32 mask);
199 
200 /**
201  * crypto_drop_kpp() - Release a spawn previously bound via crypto_grab_kpp().
202  * @spawn: The spawn to release.
203  */
crypto_drop_kpp(struct crypto_kpp_spawn * spawn)204 static inline void crypto_drop_kpp(struct crypto_kpp_spawn *spawn)
205 {
206 	crypto_drop_spawn(&spawn->base);
207 }
208 
209 /**
210  * crypto_spawn_kpp_alg() - Get the algorithm a KPP spawn has been bound to.
211  * @spawn: The spawn to get the referenced &struct kpp_alg for.
212  *
213  * This function as well as the returned result are safe to use only
214  * after @spawn has been successfully bound via crypto_grab_kpp() and
215  * up to until the template instance owning @spawn has either been
216  * registered successfully or the spawn has been released again via
217  * crypto_drop_spawn().
218  *
219  * Return: A pointer to the &struct kpp_alg referenced from the spawn.
220  */
crypto_spawn_kpp_alg(struct crypto_kpp_spawn * spawn)221 static inline struct kpp_alg *crypto_spawn_kpp_alg(
222 	struct crypto_kpp_spawn *spawn)
223 {
224 	return container_of(spawn->base.alg, struct kpp_alg, base);
225 }
226 
227 /**
228  * crypto_spawn_kpp() - Create a transform from a KPP spawn.
229  * @spawn: The spawn previously bound to some &struct kpp_alg via
230  *         crypto_grab_kpp().
231  *
232  * Once a &struct crypto_kpp_spawn has been successfully bound to a
233  * &struct kpp_alg via crypto_grab_kpp(), transforms for the latter
234  * may get instantiated from the former by means of this function.
235  *
236  * Return: A pointer to the freshly created KPP transform on success
237  * or an ``ERR_PTR()`` otherwise.
238  */
crypto_spawn_kpp(struct crypto_kpp_spawn * spawn)239 static inline struct crypto_kpp *crypto_spawn_kpp(
240 	struct crypto_kpp_spawn *spawn)
241 {
242 	return crypto_spawn_tfm2(&spawn->base);
243 }
244 
245 #endif
246