304 lines · c
1/* SPDX-License-Identifier: GPL-2.0-or-later */2/*3 * Symmetric key ciphers.4 * 5 * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>6 */7 8#ifndef _CRYPTO_INTERNAL_SKCIPHER_H9#define _CRYPTO_INTERNAL_SKCIPHER_H10 11#include <crypto/algapi.h>12#include <crypto/internal/cipher.h>13#include <crypto/skcipher.h>14#include <linux/list.h>15#include <linux/types.h>16 17/*18 * Set this if your algorithm is sync but needs a reqsize larger19 * than MAX_SYNC_SKCIPHER_REQSIZE.20 *21 * Reuse bit that is specific to hash algorithms.22 */23#define CRYPTO_ALG_SKCIPHER_REQSIZE_LARGE CRYPTO_ALG_OPTIONAL_KEY24 25struct aead_request;26struct rtattr;27 28struct skcipher_instance {29 void (*free)(struct skcipher_instance *inst);30 union {31 struct {32 char head[offsetof(struct skcipher_alg, base)];33 struct crypto_instance base;34 } s;35 struct skcipher_alg alg;36 };37};38 39struct lskcipher_instance {40 void (*free)(struct lskcipher_instance *inst);41 union {42 struct {43 char head[offsetof(struct lskcipher_alg, co.base)];44 struct crypto_instance base;45 } s;46 struct lskcipher_alg alg;47 };48};49 50struct crypto_skcipher_spawn {51 struct crypto_spawn base;52};53 54struct crypto_lskcipher_spawn {55 struct crypto_spawn base;56};57 58struct skcipher_walk {59 union {60 struct {61 struct page *page;62 unsigned long offset;63 } phys;64 65 struct {66 u8 *page;67 void *addr;68 } virt;69 } src, dst;70 71 struct scatter_walk in;72 unsigned int nbytes;73 74 struct scatter_walk out;75 unsigned int total;76 77 struct list_head buffers;78 79 u8 *page;80 u8 *buffer;81 u8 *oiv;82 void *iv;83 84 unsigned int ivsize;85 86 int flags;87 unsigned int blocksize;88 unsigned int stride;89 unsigned int alignmask;90};91 92static inline struct crypto_instance *skcipher_crypto_instance(93 struct skcipher_instance *inst)94{95 return &inst->s.base;96}97 98static inline struct crypto_instance *lskcipher_crypto_instance(99 struct lskcipher_instance *inst)100{101 return &inst->s.base;102}103 104static inline struct skcipher_instance *skcipher_alg_instance(105 struct crypto_skcipher *skcipher)106{107 return container_of(crypto_skcipher_alg(skcipher),108 struct skcipher_instance, alg);109}110 111static inline struct lskcipher_instance *lskcipher_alg_instance(112 struct crypto_lskcipher *lskcipher)113{114 return container_of(crypto_lskcipher_alg(lskcipher),115 struct lskcipher_instance, alg);116}117 118static inline void *skcipher_instance_ctx(struct skcipher_instance *inst)119{120 return crypto_instance_ctx(skcipher_crypto_instance(inst));121}122 123static inline void *lskcipher_instance_ctx(struct lskcipher_instance *inst)124{125 return crypto_instance_ctx(lskcipher_crypto_instance(inst));126}127 128static inline void skcipher_request_complete(struct skcipher_request *req, int err)129{130 crypto_request_complete(&req->base, err);131}132 133int crypto_grab_skcipher(struct crypto_skcipher_spawn *spawn,134 struct crypto_instance *inst,135 const char *name, u32 type, u32 mask);136 137int crypto_grab_lskcipher(struct crypto_lskcipher_spawn *spawn,138 struct crypto_instance *inst,139 const char *name, u32 type, u32 mask);140 141static inline void crypto_drop_skcipher(struct crypto_skcipher_spawn *spawn)142{143 crypto_drop_spawn(&spawn->base);144}145 146static inline void crypto_drop_lskcipher(struct crypto_lskcipher_spawn *spawn)147{148 crypto_drop_spawn(&spawn->base);149}150 151static inline struct lskcipher_alg *crypto_lskcipher_spawn_alg(152 struct crypto_lskcipher_spawn *spawn)153{154 return container_of(spawn->base.alg, struct lskcipher_alg, co.base);155}156 157static inline struct skcipher_alg_common *crypto_spawn_skcipher_alg_common(158 struct crypto_skcipher_spawn *spawn)159{160 return container_of(spawn->base.alg, struct skcipher_alg_common, base);161}162 163static inline struct lskcipher_alg *crypto_spawn_lskcipher_alg(164 struct crypto_lskcipher_spawn *spawn)165{166 return crypto_lskcipher_spawn_alg(spawn);167}168 169static inline struct crypto_skcipher *crypto_spawn_skcipher(170 struct crypto_skcipher_spawn *spawn)171{172 return crypto_spawn_tfm2(&spawn->base);173}174 175static inline struct crypto_lskcipher *crypto_spawn_lskcipher(176 struct crypto_lskcipher_spawn *spawn)177{178 return crypto_spawn_tfm2(&spawn->base);179}180 181static inline void crypto_skcipher_set_reqsize(182 struct crypto_skcipher *skcipher, unsigned int reqsize)183{184 skcipher->reqsize = reqsize;185}186 187static inline void crypto_skcipher_set_reqsize_dma(188 struct crypto_skcipher *skcipher, unsigned int reqsize)189{190 reqsize += crypto_dma_align() & ~(crypto_tfm_ctx_alignment() - 1);191 skcipher->reqsize = reqsize;192}193 194int crypto_register_skcipher(struct skcipher_alg *alg);195void crypto_unregister_skcipher(struct skcipher_alg *alg);196int crypto_register_skciphers(struct skcipher_alg *algs, int count);197void crypto_unregister_skciphers(struct skcipher_alg *algs, int count);198int skcipher_register_instance(struct crypto_template *tmpl,199 struct skcipher_instance *inst);200 201int crypto_register_lskcipher(struct lskcipher_alg *alg);202void crypto_unregister_lskcipher(struct lskcipher_alg *alg);203int crypto_register_lskciphers(struct lskcipher_alg *algs, int count);204void crypto_unregister_lskciphers(struct lskcipher_alg *algs, int count);205int lskcipher_register_instance(struct crypto_template *tmpl,206 struct lskcipher_instance *inst);207 208int skcipher_walk_done(struct skcipher_walk *walk, int err);209int skcipher_walk_virt(struct skcipher_walk *walk,210 struct skcipher_request *req,211 bool atomic);212int skcipher_walk_async(struct skcipher_walk *walk,213 struct skcipher_request *req);214int skcipher_walk_aead_encrypt(struct skcipher_walk *walk,215 struct aead_request *req, bool atomic);216int skcipher_walk_aead_decrypt(struct skcipher_walk *walk,217 struct aead_request *req, bool atomic);218void skcipher_walk_complete(struct skcipher_walk *walk, int err);219 220static inline void skcipher_walk_abort(struct skcipher_walk *walk)221{222 skcipher_walk_done(walk, -ECANCELED);223}224 225static inline void *crypto_skcipher_ctx(struct crypto_skcipher *tfm)226{227 return crypto_tfm_ctx(&tfm->base);228}229 230static inline void *crypto_lskcipher_ctx(struct crypto_lskcipher *tfm)231{232 return crypto_tfm_ctx(&tfm->base);233}234 235static inline void *crypto_skcipher_ctx_dma(struct crypto_skcipher *tfm)236{237 return crypto_tfm_ctx_dma(&tfm->base);238}239 240static inline void *skcipher_request_ctx(struct skcipher_request *req)241{242 return req->__ctx;243}244 245static inline void *skcipher_request_ctx_dma(struct skcipher_request *req)246{247 unsigned int align = crypto_dma_align();248 249 if (align <= crypto_tfm_ctx_alignment())250 align = 1;251 252 return PTR_ALIGN(skcipher_request_ctx(req), align);253}254 255static inline u32 skcipher_request_flags(struct skcipher_request *req)256{257 return req->base.flags;258}259 260/* Helpers for simple block cipher modes of operation */261struct skcipher_ctx_simple {262 struct crypto_cipher *cipher; /* underlying block cipher */263};264static inline struct crypto_cipher *265skcipher_cipher_simple(struct crypto_skcipher *tfm)266{267 struct skcipher_ctx_simple *ctx = crypto_skcipher_ctx(tfm);268 269 return ctx->cipher;270}271 272struct skcipher_instance *skcipher_alloc_instance_simple(273 struct crypto_template *tmpl, struct rtattr **tb);274 275static inline struct crypto_alg *skcipher_ialg_simple(276 struct skcipher_instance *inst)277{278 struct crypto_cipher_spawn *spawn = skcipher_instance_ctx(inst);279 280 return crypto_spawn_cipher_alg(spawn);281}282 283static inline struct crypto_lskcipher *lskcipher_cipher_simple(284 struct crypto_lskcipher *tfm)285{286 struct crypto_lskcipher **ctx = crypto_lskcipher_ctx(tfm);287 288 return *ctx;289}290 291struct lskcipher_instance *lskcipher_alloc_instance_simple(292 struct crypto_template *tmpl, struct rtattr **tb);293 294static inline struct lskcipher_alg *lskcipher_ialg_simple(295 struct lskcipher_instance *inst)296{297 struct crypto_lskcipher_spawn *spawn = lskcipher_instance_ctx(inst);298 299 return crypto_lskcipher_spawn_alg(spawn);300}301 302#endif /* _CRYPTO_INTERNAL_SKCIPHER_H */303 304