include/crypto/internal/kpp.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  * Key-agreement Protocol Primitives (KPP)
   4  *
   5  * Copyright (c) 2016, Intel Corporation
   6  * Authors: Salvatore Benedetto <salvatore.benedetto@intel.com>
   7  */
   8 #ifndef _CRYPTO_KPP_INT_H
   9 #define _CRYPTO_KPP_INT_H
  10 #include <crypto/kpp.h>
  11 #include <crypto/algapi.h>
  12
  13 /**
  14  * struct kpp_instance - KPP template instance
  15  * @free: Callback getting invoked upon instance destruction. Must be set.
  16  * @s: Internal. Generic crypto core instance state properly layout
  17  *     to alias with @alg as needed.
  18  * @alg: The &struct kpp_alg implementation provided by the instance.
  19  */
  20 struct kpp_instance {
  21         void (*free)(struct kpp_instance *inst);
  22         union {
  23                 struct {
  24                         char head[offsetof(struct kpp_alg, base)];
  25                         struct crypto_instance base;
  26                 } s;
  27                 struct kpp_alg alg;
  28         };
  29 };
  30
  31 /**
  32  * struct crypto_kpp_spawn - KPP algorithm spawn
  33  * @base: Internal. Generic crypto core spawn state.
  34  *
  35  * Template instances can get a hold on some inner KPP algorithm by
  36  * binding a &struct crypto_kpp_spawn via
  37  * crypto_grab_kpp(). Transforms may subsequently get instantiated
  38  * from the referenced inner &struct kpp_alg by means of
  39  * crypto_spawn_kpp().
  40  */
  41 struct crypto_kpp_spawn {
  42         struct crypto_spawn base;
  43 };
  44
  45 /*
  46  * Transform internal helpers.
  47  */
  48 static inline void *kpp_request_ctx(struct kpp_request *req)
  49 {
  50         return req->__ctx;
  51 }
  52
  53 static inline void *kpp_request_ctx_dma(struct kpp_request *req)
  54 {
  55         unsigned int align = crypto_dma_align();
  56
  57         if (align <= crypto_tfm_ctx_alignment())
  58                 align = 1;
  59
  60         return PTR_ALIGN(kpp_request_ctx(req), align);
  61 }
  62
  63 static inline void kpp_set_reqsize(struct crypto_kpp *kpp,
  64                                    unsigned int reqsize)
  65 {
  66         kpp->reqsize = reqsize;
  67 }
  68
  69 static inline void kpp_set_reqsize_dma(struct crypto_kpp *kpp,
  70                                        unsigned int reqsize)
  71 {
  72         reqsize += crypto_dma_align() & ~(crypto_tfm_ctx_alignment() - 1);
  73         kpp->reqsize = reqsize;
  74 }
  75
  76 static inline void *kpp_tfm_ctx(struct crypto_kpp *tfm)
  77 {
  78         return crypto_tfm_ctx(&tfm->base);
  79 }
  80
  81 static inline void *kpp_tfm_ctx_dma(struct crypto_kpp *tfm)
  82 {
  83         return crypto_tfm_ctx_dma(&tfm->base);
  84 }
  85
  86 static inline void kpp_request_complete(struct kpp_request *req, int err)
  87 {
  88         crypto_request_complete(&req->base, err);
  89 }
  90
  91 static inline const char *kpp_alg_name(struct crypto_kpp *tfm)
  92 {
  93         return crypto_kpp_tfm(tfm)->__crt_alg->cra_name;
  94 }
  95
  96 /*
  97  * Template instance internal helpers.
  98  */
  99 /**
 100  * kpp_crypto_instance() - Cast a &struct kpp_instance to the corresponding
 101  *                         generic &struct crypto_instance.
 102  * @inst: Pointer to the &struct kpp_instance to be cast.
 103  * Return: A pointer to the &struct crypto_instance embedded in @inst.
 104  */
 105 static inline struct crypto_instance *kpp_crypto_instance(
 106         struct kpp_instance *inst)
 107 {
 108         return &inst->s.base;
 109 }
 110
 111 /**
 112  * kpp_instance() - Cast a generic &struct crypto_instance to the corresponding
 113  *                  &struct kpp_instance.
 114  * @inst: Pointer to the &struct crypto_instance to be cast.
 115  * Return: A pointer to the &struct kpp_instance @inst is embedded in.
 116  */
 117 static inline struct kpp_instance *kpp_instance(struct crypto_instance *inst)
 118 {
 119         return container_of(inst, struct kpp_instance, s.base);
 120 }
 121
 122 /**
 123  * kpp_alg_instance() - Get the &struct kpp_instance a given KPP transform has
 124  *                      been instantiated from.
 125  * @kpp: The KPP transform instantiated from some &struct kpp_instance.
 126  * Return: The &struct kpp_instance associated with @kpp.
 127  */
 128 static inline struct kpp_instance *kpp_alg_instance(struct crypto_kpp *kpp)
 129 {
 130         return kpp_instance(crypto_tfm_alg_instance(&kpp->base));
 131 }
 132
 133 /**
 134  * kpp_instance_ctx() - Get a pointer to a &struct kpp_instance's implementation
 135  *                      specific context data.
 136  * @inst: The &struct kpp_instance whose context data to access.
 137  *
 138  * A KPP template implementation may allocate extra memory beyond the
 139  * end of a &struct kpp_instance instantiated from &crypto_template.create().
 140  * This function provides a means to obtain a pointer to this area.
 141  *
 142  * Return: A pointer to the implementation specific context data.
 143  */
 144 static inline void *kpp_instance_ctx(struct kpp_instance *inst)
 145 {
 146         return crypto_instance_ctx(kpp_crypto_instance(inst));
 147 }
 148
 149 /*
 150  * KPP algorithm (un)registration functions.
 151  */
 152 /**
 153  * crypto_register_kpp() -- Register key-agreement protocol primitives algorithm
 154  *
 155  * Function registers an implementation of a key-agreement protocol primitive
 156  * algorithm
 157  *
 158  * @alg:        algorithm definition
 159  *
 160  * Return: zero on success; error code in case of error
 161  */
 162 int crypto_register_kpp(struct kpp_alg *alg);
 163
 164 /**
 165  * crypto_unregister_kpp() -- Unregister key-agreement protocol primitive
 166  * algorithm
 167  *
 168  * Function unregisters an implementation of a key-agreement protocol primitive
 169  * algorithm
 170  *
 171  * @alg:        algorithm definition
 172  */
 173 void crypto_unregister_kpp(struct kpp_alg *alg);
 174
 175 /**
 176  * kpp_register_instance() - Register a KPP template instance.
 177  * @tmpl: The instantiating template.
 178  * @inst: The KPP template instance to be registered.
 179  * Return: %0 on success, negative error code otherwise.
 180  */
 181 int kpp_register_instance(struct crypto_template *tmpl,
 182                           struct kpp_instance *inst);
 183
 184 /*
 185  * KPP spawn related functions.
 186  */
 187 /**
 188  * crypto_grab_kpp() - Look up a KPP algorithm and bind a spawn to it.
 189  * @spawn: The KPP spawn to bind.
 190  * @inst: The template instance owning @spawn.
 191  * @name: The KPP algorithm name to look up.
 192  * @type: The type bitset to pass on to the lookup.
 193  * @mask: The mask bismask to pass on to the lookup.
 194  * Return: %0 on success, a negative error code otherwise.
 195  */
 196 int crypto_grab_kpp(struct crypto_kpp_spawn *spawn,
 197                     struct crypto_instance *inst,
 198                     const char *name, u32 type, u32 mask);
 199
 200 /**
 201  * crypto_drop_kpp() - Release a spawn previously bound via crypto_grab_kpp().
 202  * @spawn: The spawn to release.
 203  */
 204 static inline void crypto_drop_kpp(struct crypto_kpp_spawn *spawn)
 205 {
 206         crypto_drop_spawn(&spawn->base);
 207 }
 208
 209 /**
 210  * crypto_spawn_kpp_alg() - Get the algorithm a KPP spawn has been bound to.
 211  * @spawn: The spawn to get the referenced &struct kpp_alg for.
 212  *
 213  * This function as well as the returned result are safe to use only
 214  * after @spawn has been successfully bound via crypto_grab_kpp() and
 215  * up to until the template instance owning @spawn has either been
 216  * registered successfully or the spawn has been released again via
 217  * crypto_drop_spawn().
 218  *
 219  * Return: A pointer to the &struct kpp_alg referenced from the spawn.
 220  */
 221 static inline struct kpp_alg *crypto_spawn_kpp_alg(
 222         struct crypto_kpp_spawn *spawn)
 223 {
 224         return container_of(spawn->base.alg, struct kpp_alg, base);
 225 }
 226
 227 /**
 228  * crypto_spawn_kpp() - Create a transform from a KPP spawn.
 229  * @spawn: The spawn previously bound to some &struct kpp_alg via
 230  *         crypto_grab_kpp().
 231  *
 232  * Once a &struct crypto_kpp_spawn has been successfully bound to a
 233  * &struct kpp_alg via crypto_grab_kpp(), transforms for the latter
 234  * may get instantiated from the former by means of this function.
 235  *
 236  * Return: A pointer to the freshly created KPP transform on success
 237  * or an ``ERR_PTR()`` otherwise.
 238  */
 239 static inline struct crypto_kpp *crypto_spawn_kpp(
 240         struct crypto_kpp_spawn *spawn)
 241 {
 242         return crypto_spawn_tfm2(&spawn->base);
 243 }
 244
 245 #endif