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 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
  50 struct crypto_skcipher_spawn {
  51         struct crypto_spawn base;
  52 };
  53
  54 struct crypto_lskcipher_spawn {
  55         struct crypto_spawn base;
  56 };
  57
  58 struct 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
  92 static inline struct crypto_instance *skcipher_crypto_instance(
  93         struct skcipher_instance *inst)
  94 {
  95         return &inst->s.base;
  96 }
  97
  98 static inline struct crypto_instance *lskcipher_crypto_instance(
  99         struct lskcipher_instance *inst)
 100 {
 101         return &inst->s.base;
 102 }
 103
 104 static 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
 111 static 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
 118 static inline void *skcipher_instance_ctx(struct skcipher_instance *inst)
 119 {
 120         return crypto_instance_ctx(skcipher_crypto_instance(inst));
 121 }
 122
 123 static inline void *lskcipher_instance_ctx(struct lskcipher_instance *inst)
 124 {
 125         return crypto_instance_ctx(lskcipher_crypto_instance(inst));
 126 }
 127
 128 static inline void skcipher_request_complete(struct skcipher_request *req, int err)
 129 {
 130         crypto_request_complete(&req->base, err);
 131 }
 132
 133 int crypto_grab_skcipher(struct crypto_skcipher_spawn *spawn,
 134                          struct crypto_instance *inst,
 135                          const char *name, u32 type, u32 mask);
 136
 137 int crypto_grab_lskcipher(struct crypto_lskcipher_spawn *spawn,
 138                           struct crypto_instance *inst,
 139                           const char *name, u32 type, u32 mask);
 140
 141 static inline void crypto_drop_skcipher(struct crypto_skcipher_spawn *spawn)
 142 {
 143         crypto_drop_spawn(&spawn->base);
 144 }
 145
 146 static inline void crypto_drop_lskcipher(struct crypto_lskcipher_spawn *spawn)
 147 {
 148         crypto_drop_spawn(&spawn->base);
 149 }
 150
 151 static 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
 157 static 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
 163 static inline struct lskcipher_alg *crypto_spawn_lskcipher_alg(
 164         struct crypto_lskcipher_spawn *spawn)
 165 {
 166         return crypto_lskcipher_spawn_alg(spawn);
 167 }
 168
 169 static inline struct crypto_skcipher *crypto_spawn_skcipher(
 170         struct crypto_skcipher_spawn *spawn)
 171 {
 172         return crypto_spawn_tfm2(&spawn->base);
 173 }
 174
 175 static inline struct crypto_lskcipher *crypto_spawn_lskcipher(
 176         struct crypto_lskcipher_spawn *spawn)
 177 {
 178         return crypto_spawn_tfm2(&spawn->base);
 179 }
 180
 181 static inline void crypto_skcipher_set_reqsize(
 182         struct crypto_skcipher *skcipher, unsigned int reqsize)
 183 {
 184         skcipher->reqsize = reqsize;
 185 }
 186
 187 static 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
 194 int crypto_register_skcipher(struct skcipher_alg *alg);
 195 void crypto_unregister_skcipher(struct skcipher_alg *alg);
 196 int crypto_register_skciphers(struct skcipher_alg *algs, int count);
 197 void crypto_unregister_skciphers(struct skcipher_alg *algs, int count);
 198 int skcipher_register_instance(struct crypto_template *tmpl,
 199                                struct skcipher_instance *inst);
 200
 201 int crypto_register_lskcipher(struct lskcipher_alg *alg);
 202 void crypto_unregister_lskcipher(struct lskcipher_alg *alg);
 203 int crypto_register_lskciphers(struct lskcipher_alg *algs, int count);
 204 void crypto_unregister_lskciphers(struct lskcipher_alg *algs, int count);
 205 int lskcipher_register_instance(struct crypto_template *tmpl,
 206                                 struct lskcipher_instance *inst);
 207
 208 int skcipher_walk_done(struct skcipher_walk *walk, int err);
 209 int skcipher_walk_virt(struct skcipher_walk *walk,
 210                        struct skcipher_request *req,
 211                        bool atomic);
 212 int skcipher_walk_async(struct skcipher_walk *walk,
 213                         struct skcipher_request *req);
 214 int skcipher_walk_aead_encrypt(struct skcipher_walk *walk,
 215                                struct aead_request *req, bool atomic);
 216 int skcipher_walk_aead_decrypt(struct skcipher_walk *walk,
 217                                struct aead_request *req, bool atomic);
 218 void skcipher_walk_complete(struct skcipher_walk *walk, int err);
 219
 220 static inline void skcipher_walk_abort(struct skcipher_walk *walk)
 221 {
 222         skcipher_walk_done(walk, -ECANCELED);
 223 }
 224
 225 static inline void *crypto_skcipher_ctx(struct crypto_skcipher *tfm)
 226 {
 227         return crypto_tfm_ctx(&tfm->base);
 228 }
 229
 230 static inline void *crypto_lskcipher_ctx(struct crypto_lskcipher *tfm)
 231 {
 232         return crypto_tfm_ctx(&tfm->base);
 233 }
 234
 235 static inline void *crypto_skcipher_ctx_dma(struct crypto_skcipher *tfm)
 236 {
 237         return crypto_tfm_ctx_dma(&tfm->base);
 238 }
 239
 240 static inline void *skcipher_request_ctx(struct skcipher_request *req)
 241 {
 242         return req->__ctx;
 243 }
 244
 245 static 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
 255 static 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 */
 261 struct skcipher_ctx_simple {
 262         struct crypto_cipher *cipher;   /* underlying block cipher */
 263 };
 264 static inline struct crypto_cipher *
 265 skcipher_cipher_simple(struct crypto_skcipher *tfm)
 266 {
 267         struct skcipher_ctx_simple *ctx = crypto_skcipher_ctx(tfm);
 268
 269         return ctx->cipher;
 270 }
 271
 272 struct skcipher_instance *skcipher_alloc_instance_simple(
 273         struct crypto_template *tmpl, struct rtattr **tb);
 274
 275 static 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
 283 static 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
 291 struct lskcipher_instance *lskcipher_alloc_instance_simple(
 292         struct crypto_template *tmpl, struct rtattr **tb);
 293
 294 static 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