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  
crypto_aead_ctx(struct crypto_aead * tfm)37  static inline void *crypto_aead_ctx(struct crypto_aead *tfm)
38  {
39  	return crypto_tfm_ctx(&tfm->base);
40  }
41  
crypto_aead_ctx_dma(struct crypto_aead * tfm)42  static inline void *crypto_aead_ctx_dma(struct crypto_aead *tfm)
43  {
44  	return crypto_tfm_ctx_dma(&tfm->base);
45  }
46  
aead_crypto_instance(struct aead_instance * inst)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  
aead_instance(struct crypto_instance * inst)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  
aead_alg_instance(struct crypto_aead * aead)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  
aead_instance_ctx(struct aead_instance * inst)63  static inline void *aead_instance_ctx(struct aead_instance *inst)
64  {
65  	return crypto_instance_ctx(aead_crypto_instance(inst));
66  }
67  
aead_request_ctx(struct aead_request * req)68  static inline void *aead_request_ctx(struct aead_request *req)
69  {
70  	return req->__ctx;
71  }
72  
aead_request_ctx_dma(struct aead_request * req)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  
aead_request_complete(struct aead_request * req,int err)83  static inline void aead_request_complete(struct aead_request *req, int err)
84  {
85  	crypto_request_complete(&req->base, err);
86  }
87  
aead_request_flags(struct aead_request * req)88  static inline u32 aead_request_flags(struct aead_request *req)
89  {
90  	return req->base.flags;
91  }
92  
aead_request_cast(struct crypto_async_request * req)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  
crypto_drop_aead(struct crypto_aead_spawn * spawn)103  static inline void crypto_drop_aead(struct crypto_aead_spawn *spawn)
104  {
105  	crypto_drop_spawn(&spawn->base);
106  }
107  
crypto_spawn_aead_alg(struct crypto_aead_spawn * spawn)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  
crypto_spawn_aead(struct crypto_aead_spawn * spawn)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  
crypto_aead_set_reqsize(struct crypto_aead * aead,unsigned int reqsize)120  static inline void crypto_aead_set_reqsize(struct crypto_aead *aead,
121  					   unsigned int reqsize)
122  {
123  	aead->reqsize = reqsize;
124  }
125  
crypto_aead_set_reqsize_dma(struct crypto_aead * aead,unsigned int reqsize)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  
aead_init_queue(struct aead_queue * queue,unsigned int max_qlen)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  
crypto_aead_alg_chunksize(struct aead_alg * alg)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   */
crypto_aead_chunksize(struct crypto_aead * tfm)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  
169