include/crypto/internal/skcipher.h

   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_H
   9 #define _CRYPTO_INTERNAL_SKCIPHER_H
  10
  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 larger
  19  * 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_KEY
  24
  25 struct aead_request;
  26 struct rtattr;
  27
  28 struct 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
  39 struct crypto_skcipher_spawn {
  40         struct crypto_spawn base;
  41 };
  42
  43 struct skcipher_walk {
  44         union {
  45                 struct {
  46                         struct page *page;
  47                         unsigned long offset;
  48                 } phys;
  49
  50                 struct {
  51                         u8 *page;
  52                         void *addr;
  53                 } virt;
  54         } src, dst;
  55
  56         struct scatter_walk in;
  57         unsigned int nbytes;
  58
  59         struct scatter_walk out;
  60         unsigned int total;
  61
  62         struct list_head buffers;
  63
  64         u8 *page;
  65         u8 *buffer;
  66         u8 *oiv;
  67         void *iv;
  68
  69         unsigned int ivsize;
  70
  71         int flags;
  72         unsigned int blocksize;
  73         unsigned int stride;
  74         unsigned int alignmask;
  75 };
  76
  77 static inline struct crypto_instance *skcipher_crypto_instance(
  78         struct skcipher_instance *inst)
  79 {
  80         return &inst->s.base;
  81 }
  82
  83 static inline struct skcipher_instance *skcipher_alg_instance(
  84         struct crypto_skcipher *skcipher)
  85 {
  86         return container_of(crypto_skcipher_alg(skcipher),
  87                             struct skcipher_instance, alg);
  88 }
  89
  90 static inline void *skcipher_instance_ctx(struct skcipher_instance *inst)
  91 {
  92         return crypto_instance_ctx(skcipher_crypto_instance(inst));
  93 }
  94
  95 static inline void skcipher_request_complete(struct skcipher_request *req, int err)
  96 {
  97         crypto_request_complete(&req->base, err);
  98 }
  99
 100 int crypto_grab_skcipher(struct crypto_skcipher_spawn *spawn,
 101                          struct crypto_instance *inst,
 102                          const char *name, u32 type, u32 mask);
 103
 104 static inline void crypto_drop_skcipher(struct crypto_skcipher_spawn *spawn)
 105 {
 106         crypto_drop_spawn(&spawn->base);
 107 }
 108
 109 static inline struct skcipher_alg *crypto_skcipher_spawn_alg(
 110         struct crypto_skcipher_spawn *spawn)
 111 {
 112         return container_of(spawn->base.alg, struct skcipher_alg, base);
 113 }
 114
 115 static inline struct skcipher_alg *crypto_spawn_skcipher_alg(
 116         struct crypto_skcipher_spawn *spawn)
 117 {
 118         return crypto_skcipher_spawn_alg(spawn);
 119 }
 120
 121 static inline struct crypto_skcipher *crypto_spawn_skcipher(
 122         struct crypto_skcipher_spawn *spawn)
 123 {
 124         return crypto_spawn_tfm2(&spawn->base);
 125 }
 126
 127 static inline void crypto_skcipher_set_reqsize(
 128         struct crypto_skcipher *skcipher, unsigned int reqsize)
 129 {
 130         skcipher->reqsize = reqsize;
 131 }
 132
 133 static inline void crypto_skcipher_set_reqsize_dma(
 134         struct crypto_skcipher *skcipher, unsigned int reqsize)
 135 {
 136         reqsize += crypto_dma_align() & ~(crypto_tfm_ctx_alignment() - 1);
 137         skcipher->reqsize = reqsize;
 138 }
 139
 140 int crypto_register_skcipher(struct skcipher_alg *alg);
 141 void crypto_unregister_skcipher(struct skcipher_alg *alg);
 142 int crypto_register_skciphers(struct skcipher_alg *algs, int count);
 143 void crypto_unregister_skciphers(struct skcipher_alg *algs, int count);
 144 int skcipher_register_instance(struct crypto_template *tmpl,
 145                                struct skcipher_instance *inst);
 146
 147 int skcipher_walk_done(struct skcipher_walk *walk, int err);
 148 int skcipher_walk_virt(struct skcipher_walk *walk,
 149                        struct skcipher_request *req,
 150                        bool atomic);
 151 int skcipher_walk_async(struct skcipher_walk *walk,
 152                         struct skcipher_request *req);
 153 int skcipher_walk_aead_encrypt(struct skcipher_walk *walk,
 154                                struct aead_request *req, bool atomic);
 155 int skcipher_walk_aead_decrypt(struct skcipher_walk *walk,
 156                                struct aead_request *req, bool atomic);
 157 void skcipher_walk_complete(struct skcipher_walk *walk, int err);
 158
 159 static inline void skcipher_walk_abort(struct skcipher_walk *walk)
 160 {
 161         skcipher_walk_done(walk, -ECANCELED);
 162 }
 163
 164 static inline void *crypto_skcipher_ctx(struct crypto_skcipher *tfm)
 165 {
 166         return crypto_tfm_ctx(&tfm->base);
 167 }
 168
 169 static inline void *crypto_skcipher_ctx_dma(struct crypto_skcipher *tfm)
 170 {
 171         return crypto_tfm_ctx_dma(&tfm->base);
 172 }
 173
 174 static inline void *skcipher_request_ctx(struct skcipher_request *req)
 175 {
 176         return req->__ctx;
 177 }
 178
 179 static inline void *skcipher_request_ctx_dma(struct skcipher_request *req)
 180 {
 181         unsigned int align = crypto_dma_align();
 182
 183         if (align <= crypto_tfm_ctx_alignment())
 184                 align = 1;
 185
 186         return PTR_ALIGN(skcipher_request_ctx(req), align);
 187 }
 188
 189 static inline u32 skcipher_request_flags(struct skcipher_request *req)
 190 {
 191         return req->base.flags;
 192 }
 193
 194 static inline unsigned int crypto_skcipher_alg_min_keysize(
 195         struct skcipher_alg *alg)
 196 {
 197         return alg->min_keysize;
 198 }
 199
 200 static inline unsigned int crypto_skcipher_alg_max_keysize(
 201         struct skcipher_alg *alg)
 202 {
 203         return alg->max_keysize;
 204 }
 205
 206 static inline unsigned int crypto_skcipher_alg_walksize(
 207         struct skcipher_alg *alg)
 208 {
 209         return alg->walksize;
 210 }
 211
 212 /**
 213  * crypto_skcipher_walksize() - obtain walk size
 214  * @tfm: cipher handle
 215  *
 216  * In some cases, algorithms can only perform optimally when operating on
 217  * multiple blocks in parallel. This is reflected by the walksize, which
 218  * must be a multiple of the chunksize (or equal if the concern does not
 219  * apply)
 220  *
 221  * Return: walk size in bytes
 222  */
 223 static inline unsigned int crypto_skcipher_walksize(
 224         struct crypto_skcipher *tfm)
 225 {
 226         return crypto_skcipher_alg_walksize(crypto_skcipher_alg(tfm));
 227 }
 228
 229 /* Helpers for simple block cipher modes of operation */
 230 struct skcipher_ctx_simple {
 231         struct crypto_cipher *cipher;   /* underlying block cipher */
 232 };
 233 static inline struct crypto_cipher *
 234 skcipher_cipher_simple(struct crypto_skcipher *tfm)
 235 {
 236         struct skcipher_ctx_simple *ctx = crypto_skcipher_ctx(tfm);
 237
 238         return ctx->cipher;
 239 }
 240
 241 struct skcipher_instance *skcipher_alloc_instance_simple(
 242         struct crypto_template *tmpl, struct rtattr **tb);
 243
 244 static inline struct crypto_alg *skcipher_ialg_simple(
 245         struct skcipher_instance *inst)
 246 {
 247         struct crypto_cipher_spawn *spawn = skcipher_instance_ctx(inst);
 248
 249         return crypto_spawn_cipher_alg(spawn);
 250 }
 251
 252 #endif  /* _CRYPTO_INTERNAL_SKCIPHER_H */
 253