include/crypto/algapi.h

   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 <linux/crypto.h>
  11 #include <linux/list.h>
  12 #include <linux/kernel.h>
  13 #include <linux/workqueue.h>
  14
  15 /*
  16  * Maximum values for blocksize and alignmask, used to allocate
  17  * static buffers that are big enough for any combination of
  18  * algs and architectures. Ciphers have a lower maximum size.
  19  */
  20 #define MAX_ALGAPI_BLOCKSIZE            160
  21 #define MAX_ALGAPI_ALIGNMASK            63
  22 #define MAX_CIPHER_BLOCKSIZE            16
  23 #define MAX_CIPHER_ALIGNMASK            15
  24
  25 struct crypto_aead;
  26 struct crypto_instance;
  27 struct module;
  28 struct rtattr;
  29 struct seq_file;
  30 struct sk_buff;
  31
  32 struct crypto_type {
  33         unsigned int (*ctxsize)(struct crypto_alg *alg, u32 type, u32 mask);
  34         unsigned int (*extsize)(struct crypto_alg *alg);
  35         int (*init)(struct crypto_tfm *tfm, u32 type, u32 mask);
  36         int (*init_tfm)(struct crypto_tfm *tfm);
  37         void (*show)(struct seq_file *m, struct crypto_alg *alg);
  38         int (*report)(struct sk_buff *skb, struct crypto_alg *alg);
  39         void (*free)(struct crypto_instance *inst);
  40
  41         unsigned int type;
  42         unsigned int maskclear;
  43         unsigned int maskset;
  44         unsigned int tfmsize;
  45 };
  46
  47 struct crypto_instance {
  48         struct crypto_alg alg;
  49
  50         struct crypto_template *tmpl;
  51
  52         union {
  53                 /* Node in list of instances after registration. */
  54                 struct hlist_node list;
  55                 /* List of attached spawns before registration. */
  56                 struct crypto_spawn *spawns;
  57         };
  58
  59         struct work_struct free_work;
  60
  61         void *__ctx[] CRYPTO_MINALIGN_ATTR;
  62 };
  63
  64 struct crypto_template {
  65         struct list_head list;
  66         struct hlist_head instances;
  67         struct module *module;
  68
  69         int (*create)(struct crypto_template *tmpl, struct rtattr **tb);
  70
  71         char name[CRYPTO_MAX_ALG_NAME];
  72 };
  73
  74 struct crypto_spawn {
  75         struct list_head list;
  76         struct crypto_alg *alg;
  77         union {
  78                 /* Back pointer to instance after registration.*/
  79                 struct crypto_instance *inst;
  80                 /* Spawn list pointer prior to registration. */
  81                 struct crypto_spawn *next;
  82         };
  83         const struct crypto_type *frontend;
  84         u32 mask;
  85         bool dead;
  86         bool registered;
  87 };
  88
  89 struct crypto_queue {
  90         struct list_head list;
  91         struct list_head *backlog;
  92
  93         unsigned int qlen;
  94         unsigned int max_qlen;
  95 };
  96
  97 struct scatter_walk {
  98         struct scatterlist *sg;
  99         unsigned int offset;
 100 };
 101
 102 struct crypto_attr_alg {
 103         char name[CRYPTO_MAX_ALG_NAME];
 104 };
 105
 106 struct crypto_attr_type {
 107         u32 type;
 108         u32 mask;
 109 };
 110
 111 void crypto_mod_put(struct crypto_alg *alg);
 112
 113 int crypto_register_template(struct crypto_template *tmpl);
 114 int crypto_register_templates(struct crypto_template *tmpls, int count);
 115 void crypto_unregister_template(struct crypto_template *tmpl);
 116 void crypto_unregister_templates(struct crypto_template *tmpls, int count);
 117 struct crypto_template *crypto_lookup_template(const char *name);
 118
 119 int crypto_register_instance(struct crypto_template *tmpl,
 120                              struct crypto_instance *inst);
 121 void crypto_unregister_instance(struct crypto_instance *inst);
 122
 123 int crypto_grab_spawn(struct crypto_spawn *spawn, struct crypto_instance *inst,
 124                       const char *name, u32 type, u32 mask);
 125 void crypto_drop_spawn(struct crypto_spawn *spawn);
 126 struct crypto_tfm *crypto_spawn_tfm(struct crypto_spawn *spawn, u32 type,
 127                                     u32 mask);
 128 void *crypto_spawn_tfm2(struct crypto_spawn *spawn);
 129
 130 struct crypto_attr_type *crypto_get_attr_type(struct rtattr **tb);
 131 int crypto_check_attr_type(struct rtattr **tb, u32 type, u32 *mask_ret);
 132 const char *crypto_attr_alg_name(struct rtattr *rta);
 133 int crypto_inst_setname(struct crypto_instance *inst, const char *name,
 134                         struct crypto_alg *alg);
 135
 136 void crypto_init_queue(struct crypto_queue *queue, unsigned int max_qlen);
 137 int crypto_enqueue_request(struct crypto_queue *queue,
 138                            struct crypto_async_request *request);
 139 void crypto_enqueue_request_head(struct crypto_queue *queue,
 140                                  struct crypto_async_request *request);
 141 struct crypto_async_request *crypto_dequeue_request(struct crypto_queue *queue);
 142 static inline unsigned int crypto_queue_len(struct crypto_queue *queue)
 143 {
 144         return queue->qlen;
 145 }
 146
 147 void crypto_inc(u8 *a, unsigned int size);
 148 void __crypto_xor(u8 *dst, const u8 *src1, const u8 *src2, unsigned int size);
 149
 150 static inline void crypto_xor(u8 *dst, const u8 *src, unsigned int size)
 151 {
 152         if (IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) &&
 153             __builtin_constant_p(size) &&
 154             (size % sizeof(unsigned long)) == 0) {
 155                 unsigned long *d = (unsigned long *)dst;
 156                 unsigned long *s = (unsigned long *)src;
 157
 158                 while (size > 0) {
 159                         *d++ ^= *s++;
 160                         size -= sizeof(unsigned long);
 161                 }
 162         } else {
 163                 __crypto_xor(dst, dst, src, size);
 164         }
 165 }
 166
 167 static inline void crypto_xor_cpy(u8 *dst, const u8 *src1, const u8 *src2,
 168                                   unsigned int size)
 169 {
 170         if (IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) &&
 171             __builtin_constant_p(size) &&
 172             (size % sizeof(unsigned long)) == 0) {
 173                 unsigned long *d = (unsigned long *)dst;
 174                 unsigned long *s1 = (unsigned long *)src1;
 175                 unsigned long *s2 = (unsigned long *)src2;
 176
 177                 while (size > 0) {
 178                         *d++ = *s1++ ^ *s2++;
 179                         size -= sizeof(unsigned long);
 180                 }
 181         } else {
 182                 __crypto_xor(dst, src1, src2, size);
 183         }
 184 }
 185
 186 static inline void *crypto_tfm_ctx_aligned(struct crypto_tfm *tfm)
 187 {
 188         return PTR_ALIGN(crypto_tfm_ctx(tfm),
 189                          crypto_tfm_alg_alignmask(tfm) + 1);
 190 }
 191
 192 static inline struct crypto_instance *crypto_tfm_alg_instance(
 193         struct crypto_tfm *tfm)
 194 {
 195         return container_of(tfm->__crt_alg, struct crypto_instance, alg);
 196 }
 197
 198 static inline void *crypto_instance_ctx(struct crypto_instance *inst)
 199 {
 200         return inst->__ctx;
 201 }
 202
 203 static inline struct crypto_async_request *crypto_get_backlog(
 204         struct crypto_queue *queue)
 205 {
 206         return queue->backlog == &queue->list ? NULL :
 207                container_of(queue->backlog, struct crypto_async_request, list);
 208 }
 209
 210 static inline u32 crypto_requires_off(struct crypto_attr_type *algt, u32 off)
 211 {
 212         return (algt->type ^ off) & algt->mask & off;
 213 }
 214
 215 /*
 216  * When an algorithm uses another algorithm (e.g., if it's an instance of a
 217  * template), these are the flags that should always be set on the "outer"
 218  * algorithm if any "inner" algorithm has them set.
 219  */
 220 #define CRYPTO_ALG_INHERITED_FLAGS      \
 221         (CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK |  \
 222          CRYPTO_ALG_ALLOCATES_MEMORY)
 223
 224 /*
 225  * Given the type and mask that specify the flags restrictions on a template
 226  * instance being created, return the mask that should be passed to
 227  * crypto_grab_*() (along with type=0) to honor any request the user made to
 228  * have any of the CRYPTO_ALG_INHERITED_FLAGS clear.
 229  */
 230 static inline u32 crypto_algt_inherited_mask(struct crypto_attr_type *algt)
 231 {
 232         return crypto_requires_off(algt, CRYPTO_ALG_INHERITED_FLAGS);
 233 }
 234
 235 noinline unsigned long __crypto_memneq(const void *a, const void *b, size_t size);
 236
 237 /**
 238  * crypto_memneq - Compare two areas of memory without leaking
 239  *                 timing information.
 240  *
 241  * @a: One area of memory
 242  * @b: Another area of memory
 243  * @size: The size of the area.
 244  *
 245  * Returns 0 when data is equal, 1 otherwise.
 246  */
 247 static inline int crypto_memneq(const void *a, const void *b, size_t size)
 248 {
 249         return __crypto_memneq(a, b, size) != 0UL ? 1 : 0;
 250 }
 251
 252 int crypto_register_notifier(struct notifier_block *nb);
 253 int crypto_unregister_notifier(struct notifier_block *nb);
 254
 255 /* Crypto notification events. */
 256 enum {
 257         CRYPTO_MSG_ALG_REQUEST,
 258         CRYPTO_MSG_ALG_REGISTER,
 259         CRYPTO_MSG_ALG_LOADED,
 260 };
 261
 262 static inline void crypto_request_complete(struct crypto_async_request *req,
 263                                            int err)
 264 {
 265         crypto_completion_t complete = req->complete;
 266         complete(req, err);
 267 }
 268
 269 #endif  /* _CRYPTO_ALGAPI_H */