tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

crypto: kpp - provide support for KPP spawns

The upcoming support for the RFC 7919 ffdhe group parameters will be
made available in the form of templates like "ffdhe2048(dh)",
"ffdhe3072(dh)" and so on. Template instantiations thereof would wrap the
inner "dh" kpp_alg and also provide kpp_alg services to the outside again.

The primitves needed for providing kpp_alg services from template instances
have been introduced with the previous patch. Continue this work now and
implement everything needed for enabling template instances to make use
of inner KPP algorithms like "dh".

More specifically, define a struct crypto_kpp_spawn in close analogy to
crypto_skcipher_spawn, crypto_shash_spawn and alike. Implement a
crypto_grab_kpp() and crypto_drop_kpp() pair for binding such a spawn to
some inner kpp_alg and for releasing it respectively. Template
implementations can instantiate transforms from the underlying kpp_alg by
means of the new crypto_spawn_kpp(). Finally, provide the
crypto_spawn_kpp_alg() helper for accessing a spawn's underlying kpp_alg
during template instantiation.

Annotate everything with proper kernel-doc comments, even though
include/crypto/internal/kpp.h is not considered for the generated docs.

Signed-off-by: Nicolai Stange <nstange@suse.de>
Reviewed-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

authored by

Nicolai Stange and committed by
Herbert Xu 46ed5269 1038fd78

+84
+9
crypto/kpp.c
··· 95 95 } 96 96 EXPORT_SYMBOL_GPL(crypto_alloc_kpp); 97 97 98 + int crypto_grab_kpp(struct crypto_kpp_spawn *spawn, 99 + struct crypto_instance *inst, 100 + const char *name, u32 type, u32 mask) 101 + { 102 + spawn->base.frontend = &crypto_kpp_type; 103 + return crypto_grab_spawn(&spawn->base, inst, name, type, mask); 104 + } 105 + EXPORT_SYMBOL_GPL(crypto_grab_kpp); 106 + 98 107 static void kpp_prepare_alg(struct kpp_alg *alg) 99 108 { 100 109 struct crypto_alg *base = &alg->base;
+75
include/crypto/internal/kpp.h
··· 28 28 }; 29 29 }; 30 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 + 31 45 /* 32 46 * Transform internal helpers. 33 47 */ ··· 152 138 */ 153 139 int kpp_register_instance(struct crypto_template *tmpl, 154 140 struct kpp_instance *inst); 141 + 142 + /* 143 + * KPP spawn related functions. 144 + */ 145 + /** 146 + * crypto_grab_kpp() - Look up a KPP algorithm and bind a spawn to it. 147 + * @spawn: The KPP spawn to bind. 148 + * @inst: The template instance owning @spawn. 149 + * @name: The KPP algorithm name to look up. 150 + * @type: The type bitset to pass on to the lookup. 151 + * @mask: The mask bismask to pass on to the lookup. 152 + * Return: %0 on success, a negative error code otherwise. 153 + */ 154 + int crypto_grab_kpp(struct crypto_kpp_spawn *spawn, 155 + struct crypto_instance *inst, 156 + const char *name, u32 type, u32 mask); 157 + 158 + /** 159 + * crypto_drop_kpp() - Release a spawn previously bound via crypto_grab_kpp(). 160 + * @spawn: The spawn to release. 161 + */ 162 + static inline void crypto_drop_kpp(struct crypto_kpp_spawn *spawn) 163 + { 164 + crypto_drop_spawn(&spawn->base); 165 + } 166 + 167 + /** 168 + * crypto_spawn_kpp_alg() - Get the algorithm a KPP spawn has been bound to. 169 + * @spawn: The spawn to get the referenced &struct kpp_alg for. 170 + * 171 + * This function as well as the returned result are safe to use only 172 + * after @spawn has been successfully bound via crypto_grab_kpp() and 173 + * up to until the template instance owning @spawn has either been 174 + * registered successfully or the spawn has been released again via 175 + * crypto_drop_spawn(). 176 + * 177 + * Return: A pointer to the &struct kpp_alg referenced from the spawn. 178 + */ 179 + static inline struct kpp_alg *crypto_spawn_kpp_alg( 180 + struct crypto_kpp_spawn *spawn) 181 + { 182 + return container_of(spawn->base.alg, struct kpp_alg, base); 183 + } 184 + 185 + /** 186 + * crypto_spawn_kpp() - Create a transform from a KPP spawn. 187 + * @spawn: The spawn previously bound to some &struct kpp_alg via 188 + * crypto_grab_kpp(). 189 + * 190 + * Once a &struct crypto_kpp_spawn has been successfully bound to a 191 + * &struct kpp_alg via crypto_grab_kpp(), transforms for the latter 192 + * may get instantiated from the former by means of this function. 193 + * 194 + * Return: A pointer to the freshly created KPP transform on success 195 + * or an ``ERR_PTR()`` otherwise. 196 + */ 197 + static inline struct crypto_kpp *crypto_spawn_kpp( 198 + struct crypto_kpp_spawn *spawn) 199 + { 200 + return crypto_spawn_tfm2(&spawn->base); 201 + } 155 202 156 203 #endif