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 304