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 void *crypto_aead_ctx_dma(struct crypto_aead *tfm)
  43 {
  44         return crypto_tfm_ctx_dma(&tfm->base);
  45 }
  46
  47 static inline struct crypto_instance *aead_crypto_instance(
  48         struct aead_instance *inst)
  49 {
  50         return container_of(&inst->alg.base, struct crypto_instance, alg);
  51 }
  52
  53 static inline struct aead_instance *aead_instance(struct crypto_instance *inst)
  54 {
  55         return container_of(&inst->alg, struct aead_instance, alg.base);
  56 }
  57
  58 static inline struct aead_instance *aead_alg_instance(struct crypto_aead *aead)
  59 {
  60         return aead_instance(crypto_tfm_alg_instance(&aead->base));
  61 }
  62
  63 static inline void *aead_instance_ctx(struct aead_instance *inst)
  64 {
  65         return crypto_instance_ctx(aead_crypto_instance(inst));
  66 }
  67
  68 static inline void *aead_request_ctx(struct aead_request *req)
  69 {
  70         return req->__ctx;
  71 }
  72
  73 static inline void *aead_request_ctx_dma(struct aead_request *req)
  74 {
  75         unsigned int align = crypto_dma_align();
  76
  77         if (align <= crypto_tfm_ctx_alignment())
  78                 align = 1;
  79
  80         return PTR_ALIGN(aead_request_ctx(req), align);
  81 }
  82
  83 static inline void aead_request_complete(struct aead_request *req, int err)
  84 {
  85         crypto_request_complete(&req->base, err);
  86 }
  87
  88 static inline u32 aead_request_flags(struct aead_request *req)
  89 {
  90         return req->base.flags;
  91 }
  92
  93 static inline struct aead_request *aead_request_cast(
  94         struct crypto_async_request *req)
  95 {
  96         return container_of(req, struct aead_request, base);
  97 }
  98
  99 int crypto_grab_aead(struct crypto_aead_spawn *spawn,
 100                      struct crypto_instance *inst,
 101                      const char *name, u32 type, u32 mask);
 102
 103 static inline void crypto_drop_aead(struct crypto_aead_spawn *spawn)
 104 {
 105         crypto_drop_spawn(&spawn->base);
 106 }
 107
 108 static inline struct aead_alg *crypto_spawn_aead_alg(
 109         struct crypto_aead_spawn *spawn)
 110 {
 111         return container_of(spawn->base.alg, struct aead_alg, base);
 112 }
 113
 114 static inline struct crypto_aead *crypto_spawn_aead(
 115         struct crypto_aead_spawn *spawn)
 116 {
 117         return crypto_spawn_tfm2(&spawn->base);
 118 }
 119
 120 static inline void crypto_aead_set_reqsize(struct crypto_aead *aead,
 121                                            unsigned int reqsize)
 122 {
 123         aead->reqsize = reqsize;
 124 }
 125
 126 static inline void crypto_aead_set_reqsize_dma(struct crypto_aead *aead,
 127                                                unsigned int reqsize)
 128 {
 129         reqsize += crypto_dma_align() & ~(crypto_tfm_ctx_alignment() - 1);
 130         aead->reqsize = reqsize;
 131 }
 132
 133 static inline void aead_init_queue(struct aead_queue *queue,
 134                                    unsigned int max_qlen)
 135 {
 136         crypto_init_queue(&queue->base, max_qlen);
 137 }
 138
 139 static inline unsigned int crypto_aead_alg_chunksize(struct aead_alg *alg)
 140 {
 141         return alg->chunksize;
 142 }
 143
 144 /**
 145  * crypto_aead_chunksize() - obtain chunk size
 146  * @tfm: cipher handle
 147  *
 148  * The block size is set to one for ciphers such as CCM.  However,
 149  * you still need to provide incremental updates in multiples of
 150  * the underlying block size as the IV does not have sub-block
 151  * granularity.  This is known in this API as the chunk size.
 152  *
 153  * Return: chunk size in bytes
 154  */
 155 static inline unsigned int crypto_aead_chunksize(struct crypto_aead *tfm)
 156 {
 157         return crypto_aead_alg_chunksize(crypto_aead_alg(tfm));
 158 }
 159
 160 int crypto_register_aead(struct aead_alg *alg);
 161 void crypto_unregister_aead(struct aead_alg *alg);
 162 int crypto_register_aeads(struct aead_alg *algs, int count);
 163 void crypto_unregister_aeads(struct aead_alg *algs, int count);
 164 int aead_register_instance(struct crypto_template *tmpl,
 165                            struct aead_instance *inst);
 166
 167 #endif  /* _CRYPTO_INTERNAL_AEAD_H */
 168