LXR linux/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
  16struct rtattr;
  17
  18struct 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
  29struct crypto_aead_spawn {
  30        struct crypto_spawn base;
  31};
  32
  33struct aead_queue {
  34        struct crypto_queue base;
  35};
  36
  37static inline void *crypto_aead_ctx(struct crypto_aead *tfm)
  38{
  39        return crypto_tfm_ctx(&tfm->base);
  40}
  41
  42static 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
  48static inline struct aead_instance *aead_instance(struct crypto_instance *inst)
  49{
  50        return container_of(&inst->alg, struct aead_instance, alg.base);
  51}
  52
  53static inline struct aead_instance *aead_alg_instance(struct crypto_aead *aead)
  54{
  55        return aead_instance(crypto_tfm_alg_instance(&aead->base));
  56}
  57
  58static inline void *aead_instance_ctx(struct aead_instance *inst)
  59{
  60        return crypto_instance_ctx(aead_crypto_instance(inst));
  61}
  62
  63static inline void *aead_request_ctx(struct aead_request *req)
  64{
  65        return req->__ctx;
  66}
  67
  68static inline void aead_request_complete(struct aead_request *req, int err)
  69{
  70        req->base.complete(&req->base, err);
  71}
  72
  73static inline u32 aead_request_flags(struct aead_request *req)
  74{
  75        return req->base.flags;
  76}
  77
  78static 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
  84int crypto_grab_aead(struct crypto_aead_spawn *spawn,
  85                     struct crypto_instance *inst,
  86                     const char *name, u32 type, u32 mask);
  87
  88static inline void crypto_drop_aead(struct crypto_aead_spawn *spawn)
  89{
  90        crypto_drop_spawn(&spawn->base);
  91}
  92
  93static 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
  99static inline struct crypto_aead *crypto_spawn_aead(
 100        struct crypto_aead_spawn *spawn)
 101{
 102        return crypto_spawn_tfm2(&spawn->base);
 103}
 104
 105static inline void crypto_aead_set_reqsize(struct crypto_aead *aead,
 106                                           unsigned int reqsize)
 107{
 108        aead->reqsize = reqsize;
 109}
 110
 111static 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
 117static 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
 123static 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
 133static 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
 142static 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 */
 158static inline unsigned int crypto_aead_chunksize(struct crypto_aead *tfm)
 159{
 160        return crypto_aead_alg_chunksize(crypto_aead_alg(tfm));
 161}
 162
 163int crypto_register_aead(struct aead_alg *alg);
 164void crypto_unregister_aead(struct aead_alg *alg);
 165int crypto_register_aeads(struct aead_alg *algs, int count);
 166void crypto_unregister_aeads(struct aead_alg *algs, int count);
 167int aead_register_instance(struct crypto_template *tmpl,
 168                           struct aead_instance *inst);
 169
 170#endif  /* _CRYPTO_INTERNAL_AEAD_H */
 171
 172