1 /* SPDX-License-Identifier: GPL-2.0-or-later */ 2 /* 3 * Cryptographic API for algorithms (i.e., low-level API). 4 * 5 * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au> 6 */ 7 #ifndef _CRYPTO_ALGAPI_H 8 #define _CRYPTO_ALGAPI_H 9 10 #include <crypto/utils.h> 11 #include <linux/align.h> 12 #include <linux/cache.h> 13 #include <linux/crypto.h> 14 #include <linux/types.h> 15 16 /* 17 * Maximum values for blocksize and alignmask, used to allocate 18 * static buffers that are big enough for any combination of 19 * algs and architectures. Ciphers have a lower maximum size. 20 */ 21 #define MAX_ALGAPI_BLOCKSIZE 160 22 #define MAX_ALGAPI_ALIGNMASK 127 23 #define MAX_CIPHER_BLOCKSIZE 16 24 #define MAX_CIPHER_ALIGNMASK 15 25 26 #ifdef ARCH_DMA_MINALIGN 27 #define CRYPTO_DMA_ALIGN ARCH_DMA_MINALIGN 28 #else 29 #define CRYPTO_DMA_ALIGN CRYPTO_MINALIGN 30 #endif 31 32 #define CRYPTO_DMA_PADDING ((CRYPTO_DMA_ALIGN - 1) & ~(CRYPTO_MINALIGN - 1)) 33 34 /* 35 * Autoloaded crypto modules should only use a prefixed name to avoid allowing 36 * arbitrary modules to be loaded. Loading from userspace may still need the 37 * unprefixed names, so retains those aliases as well. 38 * This uses __MODULE_INFO directly instead of MODULE_ALIAS because pre-4.3 39 * gcc (e.g. avr32 toolchain) uses __LINE__ for uniqueness, and this macro 40 * expands twice on the same line. Instead, use a separate base name for the 41 * alias. 42 */ 43 #define MODULE_ALIAS_CRYPTO(name) \ 44 __MODULE_INFO(alias, alias_userspace, name); \ 45 __MODULE_INFO(alias, alias_crypto, "crypto-" name) 46 47 struct crypto_aead; 48 struct crypto_instance; 49 struct module; 50 struct notifier_block; 51 struct rtattr; 52 struct scatterlist; 53 struct seq_file; 54 struct sk_buff; 55 56 struct crypto_type { 57 unsigned int (*ctxsize)(struct crypto_alg *alg, u32 type, u32 mask); 58 unsigned int (*extsize)(struct crypto_alg *alg); 59 int (*init_tfm)(struct crypto_tfm *tfm); 60 void (*show)(struct seq_file *m, struct crypto_alg *alg); 61 int (*report)(struct sk_buff *skb, struct crypto_alg *alg); 62 void (*free)(struct crypto_instance *inst); 63 #ifdef CONFIG_CRYPTO_STATS 64 int (*report_stat)(struct sk_buff *skb, struct crypto_alg *alg); 65 #endif 66 67 unsigned int type; 68 unsigned int maskclear; 69 unsigned int maskset; 70 unsigned int tfmsize; 71 }; 72 73 struct crypto_instance { 74 struct crypto_alg alg; 75 76 struct crypto_template *tmpl; 77 78 union { 79 /* Node in list of instances after registration. */ 80 struct hlist_node list; 81 /* List of attached spawns before registration. */ 82 struct crypto_spawn *spawns; 83 }; 84 85 void *__ctx[] CRYPTO_MINALIGN_ATTR; 86 }; 87 88 struct crypto_template { 89 struct list_head list; 90 struct hlist_head instances; 91 struct module *module; 92 93 int (*create)(struct crypto_template *tmpl, struct rtattr **tb); 94 95 char name[CRYPTO_MAX_ALG_NAME]; 96 }; 97 98 struct crypto_spawn { 99 struct list_head list; 100 struct crypto_alg *alg; 101 union { 102 /* Back pointer to instance after registration.*/ 103 struct crypto_instance *inst; 104 /* Spawn list pointer prior to registration. */ 105 struct crypto_spawn *next; 106 }; 107 const struct crypto_type *frontend; 108 u32 mask; 109 bool dead; 110 bool registered; 111 }; 112 113 struct crypto_queue { 114 struct list_head list; 115 struct list_head *backlog; 116 117 unsigned int qlen; 118 unsigned int max_qlen; 119 }; 120 121 struct scatter_walk { 122 struct scatterlist *sg; 123 unsigned int offset; 124 }; 125 126 struct crypto_attr_alg { 127 char name[CRYPTO_MAX_ALG_NAME]; 128 }; 129 130 struct crypto_attr_type { 131 u32 type; 132 u32 mask; 133 }; 134 135 /* 136 * Algorithm registration interface. 137 */ 138 int crypto_register_alg(struct crypto_alg *alg); 139 void crypto_unregister_alg(struct crypto_alg *alg); 140 int crypto_register_algs(struct crypto_alg *algs, int count); 141 void crypto_unregister_algs(struct crypto_alg *algs, int count); 142 143 void crypto_mod_put(struct crypto_alg *alg); 144 145 int crypto_register_template(struct crypto_template *tmpl); 146 int crypto_register_templates(struct crypto_template *tmpls, int count); 147 void crypto_unregister_template(struct crypto_template *tmpl); 148 void crypto_unregister_templates(struct crypto_template *tmpls, int count); 149 struct crypto_template *crypto_lookup_template(const char *name); 150 151 int crypto_register_instance(struct crypto_template *tmpl, 152 struct crypto_instance *inst); 153 void crypto_unregister_instance(struct crypto_instance *inst); 154 155 int crypto_grab_spawn(struct crypto_spawn *spawn, struct crypto_instance *inst, 156 const char *name, u32 type, u32 mask); 157 void crypto_drop_spawn(struct crypto_spawn *spawn); 158 struct crypto_tfm *crypto_spawn_tfm(struct crypto_spawn *spawn, u32 type, 159 u32 mask); 160 void *crypto_spawn_tfm2(struct crypto_spawn *spawn); 161 162 struct crypto_attr_type *crypto_get_attr_type(struct rtattr **tb); 163 int crypto_check_attr_type(struct rtattr **tb, u32 type, u32 *mask_ret); 164 const char *crypto_attr_alg_name(struct rtattr *rta); 165 int crypto_inst_setname(struct crypto_instance *inst, const char *name, 166 struct crypto_alg *alg); 167 168 void crypto_init_queue(struct crypto_queue *queue, unsigned int max_qlen); 169 int crypto_enqueue_request(struct crypto_queue *queue, 170 struct crypto_async_request *request); 171 void crypto_enqueue_request_head(struct crypto_queue *queue, 172 struct crypto_async_request *request); 173 struct crypto_async_request *crypto_dequeue_request(struct crypto_queue *queue); 174 static inline unsigned int crypto_queue_len(struct crypto_queue *queue) 175 { 176 return queue->qlen; 177 } 178 179 void crypto_inc(u8 *a, unsigned int size); 180 181 static inline void *crypto_tfm_ctx(struct crypto_tfm *tfm) 182 { 183 return tfm->__crt_ctx; 184 } 185 186 static inline void *crypto_tfm_ctx_align(struct crypto_tfm *tfm, 187 unsigned int align) 188 { 189 if (align <= crypto_tfm_ctx_alignment()) 190 align = 1; 191 192 return PTR_ALIGN(crypto_tfm_ctx(tfm), align); 193 } 194 195 static inline void *crypto_tfm_ctx_aligned(struct crypto_tfm *tfm) 196 { 197 return crypto_tfm_ctx_align(tfm, crypto_tfm_alg_alignmask(tfm) + 1); 198 } 199 200 static inline unsigned int crypto_dma_align(void) 201 { 202 return CRYPTO_DMA_ALIGN; 203 } 204 205 static inline unsigned int crypto_dma_padding(void) 206 { 207 return (crypto_dma_align() - 1) & ~(crypto_tfm_ctx_alignment() - 1); 208 } 209 210 static inline void *crypto_tfm_ctx_dma(struct crypto_tfm *tfm) 211 { 212 return crypto_tfm_ctx_align(tfm, crypto_dma_align()); 213 } 214 215 static inline struct crypto_instance *crypto_tfm_alg_instance( 216 struct crypto_tfm *tfm) 217 { 218 return container_of(tfm->__crt_alg, struct crypto_instance, alg); 219 } 220 221 static inline void *crypto_instance_ctx(struct crypto_instance *inst) 222 { 223 return inst->__ctx; 224 } 225 226 static inline struct crypto_async_request *crypto_get_backlog( 227 struct crypto_queue *queue) 228 { 229 return queue->backlog == &queue->list ? NULL : 230 container_of(queue->backlog, struct crypto_async_request, list); 231 } 232 233 static inline u32 crypto_requires_off(struct crypto_attr_type *algt, u32 off) 234 { 235 return (algt->type ^ off) & algt->mask & off; 236 } 237 238 /* 239 * When an algorithm uses another algorithm (e.g., if it's an instance of a 240 * template), these are the flags that should always be set on the "outer" 241 * algorithm if any "inner" algorithm has them set. 242 */ 243 #define CRYPTO_ALG_INHERITED_FLAGS \ 244 (CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK | \ 245 CRYPTO_ALG_ALLOCATES_MEMORY) 246 247 /* 248 * Given the type and mask that specify the flags restrictions on a template 249 * instance being created, return the mask that should be passed to 250 * crypto_grab_*() (along with type=0) to honor any request the user made to 251 * have any of the CRYPTO_ALG_INHERITED_FLAGS clear. 252 */ 253 static inline u32 crypto_algt_inherited_mask(struct crypto_attr_type *algt) 254 { 255 return crypto_requires_off(algt, CRYPTO_ALG_INHERITED_FLAGS); 256 } 257 258 int crypto_register_notifier(struct notifier_block *nb); 259 int crypto_unregister_notifier(struct notifier_block *nb); 260 261 /* Crypto notification events. */ 262 enum { 263 CRYPTO_MSG_ALG_REQUEST, 264 CRYPTO_MSG_ALG_REGISTER, 265 CRYPTO_MSG_ALG_LOADED, 266 }; 267 268 static inline void crypto_request_complete(struct crypto_async_request *req, 269 int err) 270 { 271 req->complete(req->data, err); 272 } 273 274 static inline u32 crypto_tfm_alg_type(struct crypto_tfm *tfm) 275 { 276 return tfm->__crt_alg->cra_flags & CRYPTO_ALG_TYPE_MASK; 277 } 278 279 #endif /* _CRYPTO_ALGAPI_H */ 280