Branch data Line data Source code
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 : 0 : static inline struct crypto_instance *skcipher_crypto_instance( 69 : : struct skcipher_instance *inst) 70 : : { 71 : 0 : return &inst->s.base; 72 : : } 73 : : 74 : 0 : static inline struct skcipher_instance *skcipher_alg_instance( 75 : : struct crypto_skcipher *skcipher) 76 : : { 77 : 0 : return container_of(crypto_skcipher_alg(skcipher), 78 : : struct skcipher_instance, alg); 79 : : } 80 : : 81 : 0 : static inline void *skcipher_instance_ctx(struct skcipher_instance *inst) 82 : : { 83 : 0 : 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 : : int crypto_grab_skcipher(struct crypto_skcipher_spawn *spawn, 92 : : struct crypto_instance *inst, 93 : : const char *name, u32 type, u32 mask); 94 : : 95 : 0 : static inline void crypto_drop_skcipher(struct crypto_skcipher_spawn *spawn) 96 : : { 97 : 0 : crypto_drop_spawn(&spawn->base); 98 : 0 : } 99 : : 100 : 0 : static inline struct skcipher_alg *crypto_skcipher_spawn_alg( 101 : : struct crypto_skcipher_spawn *spawn) 102 : : { 103 : 0 : return container_of(spawn->base.alg, struct skcipher_alg, base); 104 : : } 105 : : 106 : 0 : static inline struct skcipher_alg *crypto_spawn_skcipher_alg( 107 : : struct crypto_skcipher_spawn *spawn) 108 : : { 109 [ # # ]: 0 : return crypto_skcipher_spawn_alg(spawn); 110 : : } 111 : : 112 : 0 : static inline struct crypto_skcipher *crypto_spawn_skcipher( 113 : : struct crypto_skcipher_spawn *spawn) 114 : : { 115 : 0 : return crypto_spawn_tfm2(&spawn->base); 116 : : } 117 : : 118 : 0 : static inline void crypto_skcipher_set_reqsize( 119 : : struct crypto_skcipher *skcipher, unsigned int reqsize) 120 : : { 121 : 0 : skcipher->reqsize = reqsize; 122 : : } 123 : : 124 : : int crypto_register_skcipher(struct skcipher_alg *alg); 125 : : void crypto_unregister_skcipher(struct skcipher_alg *alg); 126 : : int crypto_register_skciphers(struct skcipher_alg *algs, int count); 127 : : void crypto_unregister_skciphers(struct skcipher_alg *algs, int count); 128 : : int skcipher_register_instance(struct crypto_template *tmpl, 129 : : struct skcipher_instance *inst); 130 : : 131 : : int skcipher_walk_done(struct skcipher_walk *walk, int err); 132 : : int skcipher_walk_virt(struct skcipher_walk *walk, 133 : : struct skcipher_request *req, 134 : : bool atomic); 135 : : void skcipher_walk_atomise(struct skcipher_walk *walk); 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 : 0 : static inline void *crypto_skcipher_ctx(struct crypto_skcipher *tfm) 150 : : { 151 [ # # ]: 0 : return crypto_tfm_ctx(&tfm->base); 152 : : } 153 : : 154 : 0 : static inline void *skcipher_request_ctx(struct skcipher_request *req) 155 : : { 156 : 0 : 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 : 0 : static inline unsigned int crypto_skcipher_alg_min_keysize( 165 : : struct skcipher_alg *alg) 166 : : { 167 : 0 : return alg->min_keysize; 168 : : } 169 : : 170 : 0 : static inline unsigned int crypto_skcipher_alg_max_keysize( 171 : : struct skcipher_alg *alg) 172 : : { 173 : 0 : return alg->max_keysize; 174 : : } 175 : : 176 : 0 : static inline unsigned int crypto_skcipher_alg_walksize( 177 : : struct skcipher_alg *alg) 178 : : { 179 : 0 : 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 : 0 : static inline unsigned int crypto_skcipher_walksize( 194 : : struct crypto_skcipher *tfm) 195 : : { 196 : 0 : 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 : 0 : skcipher_cipher_simple(struct crypto_skcipher *tfm) 205 : : { 206 : 0 : struct skcipher_ctx_simple *ctx = crypto_skcipher_ctx(tfm); 207 : : 208 : 0 : return ctx->cipher; 209 : : } 210 : : 211 : : struct skcipher_instance *skcipher_alloc_instance_simple( 212 : : struct crypto_template *tmpl, struct rtattr **tb); 213 : : 214 : 0 : static inline struct crypto_alg *skcipher_ialg_simple( 215 : : struct skcipher_instance *inst) 216 : : { 217 [ # # ]: 0 : struct crypto_cipher_spawn *spawn = skcipher_instance_ctx(inst); 218 : : 219 [ # # ]: 0 : return crypto_spawn_cipher_alg(spawn); 220 : : } 221 : : 222 : : #endif /* _CRYPTO_INTERNAL_SKCIPHER_H */ 223 : :