include/crypto/internal/akcipher.h

   1 /*
   2  * Public Key Encryption
   3  *
   4  * Copyright (c) 2015, Intel Corporation
   5  * Authors: Tadeusz Struk <tadeusz.struk@intel.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the Free
   9  * Software Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  */
  13 #ifndef _CRYPTO_AKCIPHER_INT_H
  14 #define _CRYPTO_AKCIPHER_INT_H
  15 #include <crypto/akcipher.h>
  16 #include <crypto/algapi.h>
  17
  18 struct akcipher_instance {
  19         void (*free)(struct akcipher_instance *inst);
  20         union {
  21                 struct {
  22                         char head[offsetof(struct akcipher_alg, base)];
  23                         struct crypto_instance base;
  24                 } s;
  25                 struct akcipher_alg alg;
  26         };
  27 };
  28
  29 struct crypto_akcipher_spawn {
  30         struct crypto_spawn base;
  31 };
  32
  33 /*
  34  * Transform internal helpers.
  35  */
  36 static inline void *akcipher_request_ctx(struct akcipher_request *req)
  37 {
  38         return req->__ctx;
  39 }
  40
  41 static inline void akcipher_set_reqsize(struct crypto_akcipher *akcipher,
  42                                         unsigned int reqsize)
  43 {
  44         crypto_akcipher_alg(akcipher)->reqsize = reqsize;
  45 }
  46
  47 static inline void *akcipher_tfm_ctx(struct crypto_akcipher *tfm)
  48 {
  49         return tfm->base.__crt_ctx;
  50 }
  51
  52 static inline void akcipher_request_complete(struct akcipher_request *req,
  53                                              int err)
  54 {
  55         req->base.complete(&req->base, err);
  56 }
  57
  58 static inline const char *akcipher_alg_name(struct crypto_akcipher *tfm)
  59 {
  60         return crypto_akcipher_tfm(tfm)->__crt_alg->cra_name;
  61 }
  62
  63 static inline struct crypto_instance *akcipher_crypto_instance(
  64                 struct akcipher_instance *inst)
  65 {
  66         return container_of(&inst->alg.base, struct crypto_instance, alg);
  67 }
  68
  69 static inline struct akcipher_instance *akcipher_instance(
  70                 struct crypto_instance *inst)
  71 {
  72         return container_of(&inst->alg, struct akcipher_instance, alg.base);
  73 }
  74
  75 static inline struct akcipher_instance *akcipher_alg_instance(
  76                 struct crypto_akcipher *akcipher)
  77 {
  78         return akcipher_instance(crypto_tfm_alg_instance(&akcipher->base));
  79 }
  80
  81 static inline void *akcipher_instance_ctx(struct akcipher_instance *inst)
  82 {
  83         return crypto_instance_ctx(akcipher_crypto_instance(inst));
  84 }
  85
  86 static inline void crypto_set_akcipher_spawn(
  87                 struct crypto_akcipher_spawn *spawn,
  88                 struct crypto_instance *inst)
  89 {
  90         crypto_set_spawn(&spawn->base, inst);
  91 }
  92
  93 int crypto_grab_akcipher(struct crypto_akcipher_spawn *spawn, const char *name,
  94                 u32 type, u32 mask);
  95
  96 static inline struct crypto_akcipher *crypto_spawn_akcipher(
  97                 struct crypto_akcipher_spawn *spawn)
  98 {
  99         return crypto_spawn_tfm2(&spawn->base);
 100 }
 101
 102 static inline void crypto_drop_akcipher(struct crypto_akcipher_spawn *spawn)
 103 {
 104         crypto_drop_spawn(&spawn->base);
 105 }
 106
 107 static inline struct akcipher_alg *crypto_spawn_akcipher_alg(
 108                 struct crypto_akcipher_spawn *spawn)
 109 {
 110         return container_of(spawn->base.alg, struct akcipher_alg, base);
 111 }
 112
 113 /**
 114  * crypto_register_akcipher() -- Register public key algorithm
 115  *
 116  * Function registers an implementation of a public key verify algorithm
 117  *
 118  * @alg:        algorithm definition
 119  *
 120  * Return: zero on success; error code in case of error
 121  */
 122 int crypto_register_akcipher(struct akcipher_alg *alg);
 123
 124 /**
 125  * crypto_unregister_akcipher() -- Unregister public key algorithm
 126  *
 127  * Function unregisters an implementation of a public key verify algorithm
 128  *
 129  * @alg:        algorithm definition
 130  */
 131 void crypto_unregister_akcipher(struct akcipher_alg *alg);
 132
 133 /**
 134  * akcipher_register_instance() -- Unregister public key template instance
 135  *
 136  * Function registers an implementation of an asymmetric key algorithm
 137  * created from a template
 138  *
 139  * @tmpl:       the template from which the algorithm was created
 140  * @inst:       the template instance
 141  */
 142 int akcipher_register_instance(struct crypto_template *tmpl,
 143                 struct akcipher_instance *inst);
 144 #endif