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