include/crypto/internal/aead.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  * AEAD: Authenticated Encryption with Associated Data
   4  *
   5  * Copyright (c) 2007-2015 Herbert Xu <herbert@gondor.apana.org.au>
   6  */
   7
   8 #ifndef _CRYPTO_INTERNAL_AEAD_H
   9 #define _CRYPTO_INTERNAL_AEAD_H
  10
  11 #include <crypto/aead.h>
  12 #include <crypto/algapi.h>
  13 #include <linux/stddef.h>
  14 #include <linux/types.h>
  15
  16 struct rtattr;
  17
  18 struct aead_instance {
  19         void (*free)(struct aead_instance *inst);
  20         union {
  21                 struct {
  22                         char head[offsetof(struct aead_alg, base)];
  23                         struct crypto_instance base;
  24                 } s;
  25                 struct aead_alg alg;
  26         };
  27 };
  28
  29 struct crypto_aead_spawn {
  30         struct crypto_spawn base;
  31 };
  32
  33 struct aead_queue {
  34         struct crypto_queue base;
  35 };
  36
  37 static inline void *crypto_aead_ctx(struct crypto_aead *tfm)
  38 {
  39         return crypto_tfm_ctx(&tfm->base);
  40 }
  41
  42 static inline struct crypto_instance *aead_crypto_instance(
  43         struct aead_instance *inst)
  44 {
  45         return container_of(&inst->alg.base, struct crypto_instance, alg);
  46 }
  47
  48 static inline struct aead_instance *aead_instance(struct crypto_instance *inst)
  49 {
  50         return container_of(&inst->alg, struct aead_instance, alg.base);
  51 }
  52
  53 static inline struct aead_instance *aead_alg_instance(struct crypto_aead *aead)
  54 {
  55         return aead_instance(crypto_tfm_alg_instance(&aead->base));
  56 }
  57
  58 static inline void *aead_instance_ctx(struct aead_instance *inst)
  59 {
  60         return crypto_instance_ctx(aead_crypto_instance(inst));
  61 }
  62
  63 static inline void *aead_request_ctx(struct aead_request *req)
  64 {
  65         return req->__ctx;
  66 }
  67
  68 static inline void aead_request_complete(struct aead_request *req, int err)
  69 {
  70         req->base.complete(&req->base, err);
  71 }
  72
  73 static inline u32 aead_request_flags(struct aead_request *req)
  74 {
  75         return req->base.flags;
  76 }
  77
  78 static inline struct aead_request *aead_request_cast(
  79         struct crypto_async_request *req)
  80 {
  81         return container_of(req, struct aead_request, base);
  82 }
  83
  84 static inline void crypto_set_aead_spawn(
  85         struct crypto_aead_spawn *spawn, struct crypto_instance *inst)
  86 {
  87         crypto_set_spawn(&spawn->base, inst);
  88 }
  89
  90 int crypto_grab_aead(struct crypto_aead_spawn *spawn, const char *name,
  91                      u32 type, u32 mask);
  92
  93 static inline void crypto_drop_aead(struct crypto_aead_spawn *spawn)
  94 {
  95         crypto_drop_spawn(&spawn->base);
  96 }
  97
  98 static inline struct aead_alg *crypto_spawn_aead_alg(
  99         struct crypto_aead_spawn *spawn)
 100 {
 101         return container_of(spawn->base.alg, struct aead_alg, base);
 102 }
 103
 104 static inline struct crypto_aead *crypto_spawn_aead(
 105         struct crypto_aead_spawn *spawn)
 106 {
 107         return crypto_spawn_tfm2(&spawn->base);
 108 }
 109
 110 static inline void crypto_aead_set_reqsize(struct crypto_aead *aead,
 111                                            unsigned int reqsize)
 112 {
 113         aead->reqsize = reqsize;
 114 }
 115
 116 static inline unsigned int crypto_aead_alg_maxauthsize(struct aead_alg *alg)
 117 {
 118         return alg->maxauthsize;
 119 }
 120
 121 static inline unsigned int crypto_aead_maxauthsize(struct crypto_aead *aead)
 122 {
 123         return crypto_aead_alg_maxauthsize(crypto_aead_alg(aead));
 124 }
 125
 126 static inline void aead_init_queue(struct aead_queue *queue,
 127                                    unsigned int max_qlen)
 128 {
 129         crypto_init_queue(&queue->base, max_qlen);
 130 }
 131
 132 static inline int aead_enqueue_request(struct aead_queue *queue,
 133                                        struct aead_request *request)
 134 {
 135         return crypto_enqueue_request(&queue->base, &request->base);
 136 }
 137
 138 static inline struct aead_request *aead_dequeue_request(
 139         struct aead_queue *queue)
 140 {
 141         struct crypto_async_request *req;
 142
 143         req = crypto_dequeue_request(&queue->base);
 144
 145         return req ? container_of(req, struct aead_request, base) : NULL;
 146 }
 147
 148 static inline struct aead_request *aead_get_backlog(struct aead_queue *queue)
 149 {
 150         struct crypto_async_request *req;
 151
 152         req = crypto_get_backlog(&queue->base);
 153
 154         return req ? container_of(req, struct aead_request, base) : NULL;
 155 }
 156
 157 static inline unsigned int crypto_aead_alg_chunksize(struct aead_alg *alg)
 158 {
 159         return alg->chunksize;
 160 }
 161
 162 /**
 163  * crypto_aead_chunksize() - obtain chunk size
 164  * @tfm: cipher handle
 165  *
 166  * The block size is set to one for ciphers such as CCM.  However,
 167  * you still need to provide incremental updates in multiples of
 168  * the underlying block size as the IV does not have sub-block
 169  * granularity.  This is known in this API as the chunk size.
 170  *
 171  * Return: chunk size in bytes
 172  */
 173 static inline unsigned int crypto_aead_chunksize(struct crypto_aead *tfm)
 174 {
 175         return crypto_aead_alg_chunksize(crypto_aead_alg(tfm));
 176 }
 177
 178 int crypto_register_aead(struct aead_alg *alg);
 179 void crypto_unregister_aead(struct aead_alg *alg);
 180 int crypto_register_aeads(struct aead_alg *algs, int count);
 181 void crypto_unregister_aeads(struct aead_alg *algs, int count);
 182 int aead_register_instance(struct crypto_template *tmpl,
 183                            struct aead_instance *inst);
 184
 185 #endif  /* _CRYPTO_INTERNAL_AEAD_H */
 186