| 1 | |
| 2 | * Public Key Encryption
|
| 3 | *
|
| 4 | * Copyright (c) 2015, Intel Corporation
|
| 5 | * Authors: Tadeusz Struk <[email protected]>
|
| 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 | #include <linux/errno.h>
|
| 14 | #include <linux/kernel.h>
|
| 15 | #include <linux/module.h>
|
| 16 | #include <linux/seq_file.h>
|
| 17 | #include <linux/slab.h>
|
| 18 | #include <linux/string.h>
|
| 19 | #include <linux/crypto.h>
|
| 20 | #include <crypto/algapi.h>
|
| 21 | #include <linux/cryptouser.h>
|
| 22 | #include <net/netlink.h>
|
| 23 | #include <crypto/akcipher.h>
|
| 24 | #include <crypto/internal/akcipher.h>
|
| 25 | #include "internal.h"
|
| 26 |
|
| 27 | #ifdef CONFIG_NET
|
| 28 | static int crypto_akcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
|
| 29 | {
|
| 30 | struct crypto_report_akcipher rakcipher;
|
| 31 |
|
| 32 | strncpy(rakcipher.type, "akcipher", sizeof(rakcipher.type));
|
| 33 |
|
| 34 | if (nla_put(skb, CRYPTOCFGA_REPORT_AKCIPHER,
|
| 35 | sizeof(struct crypto_report_akcipher), &rakcipher))
|
| 36 | goto nla_put_failure;
|
| 37 | return 0;
|
| 38 |
|
| 39 | nla_put_failure:
|
| 40 | return -EMSGSIZE;
|
| 41 | }
|
| 42 | #else
|
| 43 | static int crypto_akcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
|
| 44 | {
|
| 45 | return -ENOSYS;
|
| 46 | }
|
| 47 | #endif
|
| 48 |
|
| 49 | static void crypto_akcipher_show(struct seq_file *m, struct crypto_alg *alg)
|
| 50 | __attribute__ ((unused));
|
| 51 |
|
| 52 | static void crypto_akcipher_show(struct seq_file *m, struct crypto_alg *alg)
|
| 53 | {
|
| 54 | seq_puts(m, "type : akcipher\n");
|
| 55 | }
|
| 56 |
|
| 57 | static void crypto_akcipher_exit_tfm(struct crypto_tfm *tfm)
|
| 58 | {
|
| 59 | struct crypto_akcipher *akcipher = __crypto_akcipher_tfm(tfm);
|
| 60 | struct akcipher_alg *alg = crypto_akcipher_alg(akcipher);
|
| 61 |
|
| 62 | alg->exit(akcipher);
|
| 63 | }
|
| 64 |
|
| 65 | static int crypto_akcipher_init_tfm(struct crypto_tfm *tfm)
|
| 66 | {
|
| 67 | struct crypto_akcipher *akcipher = __crypto_akcipher_tfm(tfm);
|
| 68 | struct akcipher_alg *alg = crypto_akcipher_alg(akcipher);
|
| 69 |
|
| 70 | if (alg->exit)
|
| 71 | akcipher->base.exit = crypto_akcipher_exit_tfm;
|
| 72 |
|
| 73 | if (alg->init)
|
| 74 | return alg->init(akcipher);
|
| 75 |
|
| 76 | return 0;
|
| 77 | }
|
| 78 |
|
| 79 | static void crypto_akcipher_free_instance(struct crypto_instance *inst)
|
| 80 | {
|
| 81 | struct akcipher_instance *akcipher = akcipher_instance(inst);
|
| 82 |
|
| 83 | akcipher->free(akcipher);
|
| 84 | }
|
| 85 |
|
| 86 | static const struct crypto_type crypto_akcipher_type = {
|
| 87 | .extsize = crypto_alg_extsize,
|
| 88 | .init_tfm = crypto_akcipher_init_tfm,
|
| 89 | .free = crypto_akcipher_free_instance,
|
| 90 | #ifdef CONFIG_PROC_FS
|
| 91 | .show = crypto_akcipher_show,
|
| 92 | #endif
|
| 93 | .report = crypto_akcipher_report,
|
| 94 | .maskclear = ~CRYPTO_ALG_TYPE_MASK,
|
| 95 | .maskset = CRYPTO_ALG_TYPE_MASK,
|
| 96 | .type = CRYPTO_ALG_TYPE_AKCIPHER,
|
| 97 | .tfmsize = offsetof(struct crypto_akcipher, base),
|
| 98 | };
|
| 99 |
|
| 100 | int crypto_grab_akcipher(struct crypto_akcipher_spawn *spawn, const char *name,
|
| 101 | u32 type, u32 mask)
|
| 102 | {
|
| 103 | spawn->base.frontend = &crypto_akcipher_type;
|
| 104 | return crypto_grab_spawn(&spawn->base, name, type, mask);
|
| 105 | }
|
| 106 | EXPORT_SYMBOL_GPL(crypto_grab_akcipher);
|
| 107 |
|
| 108 | struct crypto_akcipher *crypto_alloc_akcipher(const char *alg_name, u32 type,
|
| 109 | u32 mask)
|
| 110 | {
|
| 111 | return crypto_alloc_tfm(alg_name, &crypto_akcipher_type, type, mask);
|
| 112 | }
|
| 113 | EXPORT_SYMBOL_GPL(crypto_alloc_akcipher);
|
| 114 |
|
| 115 | static void akcipher_prepare_alg(struct akcipher_alg *alg)
|
| 116 | {
|
| 117 | struct crypto_alg *base = &alg->base;
|
| 118 |
|
| 119 | base->cra_type = &crypto_akcipher_type;
|
| 120 | base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
|
| 121 | base->cra_flags |= CRYPTO_ALG_TYPE_AKCIPHER;
|
| 122 | }
|
| 123 |
|
| 124 | int crypto_register_akcipher(struct akcipher_alg *alg)
|
| 125 | {
|
| 126 | struct crypto_alg *base = &alg->base;
|
| 127 |
|
| 128 | akcipher_prepare_alg(alg);
|
| 129 | return crypto_register_alg(base);
|
| 130 | }
|
| 131 | EXPORT_SYMBOL_GPL(crypto_register_akcipher);
|
| 132 |
|
| 133 | void crypto_unregister_akcipher(struct akcipher_alg *alg)
|
| 134 | {
|
| 135 | crypto_unregister_alg(&alg->base);
|
| 136 | }
|
| 137 | EXPORT_SYMBOL_GPL(crypto_unregister_akcipher);
|
| 138 |
|
| 139 | int akcipher_register_instance(struct crypto_template *tmpl,
|
| 140 | struct akcipher_instance *inst)
|
| 141 | {
|
| 142 | akcipher_prepare_alg(&inst->alg);
|
| 143 | return crypto_register_instance(tmpl, akcipher_crypto_instance(inst));
|
| 144 | }
|
| 145 | EXPORT_SYMBOL_GPL(akcipher_register_instance);
|
| 146 |
|
| 147 | MODULE_LICENSE("GPL");
|
| 148 | MODULE_DESCRIPTION("Generic public key cipher type");
|