Loading...
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 * Transform internal helpers.
15 */
16static inline void *kpp_request_ctx(struct kpp_request *req)
17{
18 return req->__ctx;
19}
20
21static inline void *kpp_tfm_ctx(struct crypto_kpp *tfm)
22{
23 return tfm->base.__crt_ctx;
24}
25
26static inline void kpp_request_complete(struct kpp_request *req, int err)
27{
28 req->base.complete(&req->base, err);
29}
30
31static inline const char *kpp_alg_name(struct crypto_kpp *tfm)
32{
33 return crypto_kpp_tfm(tfm)->__crt_alg->cra_name;
34}
35
36/**
37 * crypto_register_kpp() -- Register key-agreement protocol primitives algorithm
38 *
39 * Function registers an implementation of a key-agreement protocol primitive
40 * algorithm
41 *
42 * @alg: algorithm definition
43 *
44 * Return: zero on success; error code in case of error
45 */
46int crypto_register_kpp(struct kpp_alg *alg);
47
48/**
49 * crypto_unregister_kpp() -- Unregister key-agreement protocol primitive
50 * algorithm
51 *
52 * Function unregisters an implementation of a key-agreement protocol primitive
53 * algorithm
54 *
55 * @alg: algorithm definition
56 */
57void crypto_unregister_kpp(struct kpp_alg *alg);
58
59#endif
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 */
20struct 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 */
41struct crypto_kpp_spawn {
42 struct crypto_spawn base;
43};
44
45/*
46 * Transform internal helpers.
47 */
48static inline void *kpp_request_ctx(struct kpp_request *req)
49{
50 return req->__ctx;
51}
52
53static 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
63static inline void kpp_set_reqsize(struct crypto_kpp *kpp,
64 unsigned int reqsize)
65{
66 kpp->reqsize = reqsize;
67}
68
69static 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
76static inline void *kpp_tfm_ctx(struct crypto_kpp *tfm)
77{
78 return crypto_tfm_ctx(&tfm->base);
79}
80
81static inline void *kpp_tfm_ctx_dma(struct crypto_kpp *tfm)
82{
83 return crypto_tfm_ctx_dma(&tfm->base);
84}
85
86static inline void kpp_request_complete(struct kpp_request *req, int err)
87{
88 req->base.complete(&req->base, err);
89}
90
91static 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 */
105static 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 */
117static 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 */
128static 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 */
144static 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 */
162int 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 */
173void 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 */
181int 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 */
196int 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 */
204static 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 */
221static 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 */
239static 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