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 #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"); 149