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