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 int crypto_grab_aead(struct crypto_aead_spawn *spawn,
  85                      struct crypto_instance *inst,
  86                      const char *name, u32 type, u32 mask);
  87
  88 static inline void crypto_drop_aead(struct crypto_aead_spawn *spawn)
  89 {
  90         crypto_drop_spawn(&spawn->base);
  91 }
  92
  93 static inline struct aead_alg *crypto_spawn_aead_alg(
  94         struct crypto_aead_spawn *spawn)
  95 {
  96         return container_of(spawn->base.alg, struct aead_alg, base);
  97 }
  98
  99 static inline struct crypto_aead *crypto_spawn_aead(
 100         struct crypto_aead_spawn *spawn)
 101 {
 102         return crypto_spawn_tfm2(&spawn->base);
 103 }
 104
 105 static inline void crypto_aead_set_reqsize(struct crypto_aead *aead,
 106                                            unsigned int reqsize)
 107 {
 108         aead->reqsize = reqsize;
 109 }
 110
 111 static inline void aead_init_queue(struct aead_queue *queue,
 112                                    unsigned int max_qlen)
 113 {
 114         crypto_init_queue(&queue->base, max_qlen);
 115 }
 116
 117 static inline int aead_enqueue_request(struct aead_queue *queue,
 118                                        struct aead_request *request)
 119 {
 120         return crypto_enqueue_request(&queue->base, &request->base);
 121 }
 122
 123 static inline struct aead_request *aead_dequeue_request(
 124         struct aead_queue *queue)
 125 {
 126         struct crypto_async_request *req;
 127
 128         req = crypto_dequeue_request(&queue->base);
 129
 130         return req ? container_of(req, struct aead_request, base) : NULL;
 131 }
 132
 133 static inline struct aead_request *aead_get_backlog(struct aead_queue *queue)
 134 {
 135         struct crypto_async_request *req;
 136
 137         req = crypto_get_backlog(&queue->base);
 138
 139         return req ? container_of(req, struct aead_request, base) : NULL;
 140 }
 141
 142 static inline unsigned int crypto_aead_alg_chunksize(struct aead_alg *alg)
 143 {
 144         return alg->chunksize;
 145 }
 146
 147 /**
 148  * crypto_aead_chunksize() - obtain chunk size
 149  * @tfm: cipher handle
 150  *
 151  * The block size is set to one for ciphers such as CCM.  However,
 152  * you still need to provide incremental updates in multiples of
 153  * the underlying block size as the IV does not have sub-block
 154  * granularity.  This is known in this API as the chunk size.
 155  *
 156  * Return: chunk size in bytes
 157  */
 158 static inline unsigned int crypto_aead_chunksize(struct crypto_aead *tfm)
 159 {
 160         return crypto_aead_alg_chunksize(crypto_aead_alg(tfm));
 161 }
 162
 163 int crypto_register_aead(struct aead_alg *alg);
 164 void crypto_unregister_aead(struct aead_alg *alg);
 165 int crypto_register_aeads(struct aead_alg *algs, int count);
 166 void crypto_unregister_aeads(struct aead_alg *algs, int count);
 167 int aead_register_instance(struct crypto_template *tmpl,
 168                            struct aead_instance *inst);
 169
 170 #endif  /* _CRYPTO_INTERNAL_AEAD_H */
 171