1 /* SPDX-License-Identifier: GPL-2.0-or-later */ 2 /* 3 * Public Key Signature Algorithm 4 * 5 * Copyright (c) 2023 Herbert Xu <herbert@gondor.apana.org.au> 6 */ 7 8 #include <crypto/akcipher.h> 9 #include <crypto/internal/sig.h> 10 #include <linux/cryptouser.h> 11 #include <linux/kernel.h> 12 #include <linux/module.h> 13 #include <linux/scatterlist.h> 14 #include <linux/seq_file.h> 15 #include <linux/string.h> 16 #include <net/netlink.h> 17 18 #include "internal.h" 19 20 #define CRYPTO_ALG_TYPE_SIG_MASK 0x0000000e 21 22 static const struct crypto_type crypto_sig_type; 23 24 static int crypto_sig_init_tfm(struct crypto_tfm *tfm) 25 { 26 if (tfm->__crt_alg->cra_type != &crypto_sig_type) 27 return crypto_init_akcipher_ops_sig(tfm); 28 29 return 0; 30 } 31 32 static void __maybe_unused crypto_sig_show(struct seq_file *m, 33 struct crypto_alg *alg) 34 { 35 seq_puts(m, "type : sig\n"); 36 } 37 38 static int __maybe_unused crypto_sig_report(struct sk_buff *skb, 39 struct crypto_alg *alg) 40 { 41 struct crypto_report_akcipher rsig = {}; 42 43 strscpy(rsig.type, "sig", sizeof(rsig.type)); 44 45 return nla_put(skb, CRYPTOCFGA_REPORT_AKCIPHER, sizeof(rsig), &rsig); 46 } 47 48 static const struct crypto_type crypto_sig_type = { 49 .extsize = crypto_alg_extsize, 50 .init_tfm = crypto_sig_init_tfm, 51 #ifdef CONFIG_PROC_FS 52 .show = crypto_sig_show, 53 #endif 54 #if IS_ENABLED(CONFIG_CRYPTO_USER) 55 .report = crypto_sig_report, 56 #endif 57 .maskclear = ~CRYPTO_ALG_TYPE_MASK, 58 .maskset = CRYPTO_ALG_TYPE_SIG_MASK, 59 .type = CRYPTO_ALG_TYPE_SIG, 60 .tfmsize = offsetof(struct crypto_sig, base), 61 }; 62 63 struct crypto_sig *crypto_alloc_sig(const char *alg_name, u32 type, u32 mask) 64 { 65 return crypto_alloc_tfm(alg_name, &crypto_sig_type, type, mask); 66 } 67 EXPORT_SYMBOL_GPL(crypto_alloc_sig); 68 69 int crypto_sig_maxsize(struct crypto_sig *tfm) 70 { 71 struct crypto_akcipher **ctx = crypto_sig_ctx(tfm); 72 73 return crypto_akcipher_maxsize(*ctx); 74 } 75 EXPORT_SYMBOL_GPL(crypto_sig_maxsize); 76 77 int crypto_sig_sign(struct crypto_sig *tfm, 78 const void *src, unsigned int slen, 79 void *dst, unsigned int dlen) 80 { 81 struct crypto_akcipher **ctx = crypto_sig_ctx(tfm); 82 struct crypto_akcipher_sync_data data = { 83 .tfm = *ctx, 84 .src = src, 85 .dst = dst, 86 .slen = slen, 87 .dlen = dlen, 88 }; 89 90 return crypto_akcipher_sync_prep(&data) ?: 91 crypto_akcipher_sync_post(&data, 92 crypto_akcipher_sign(data.req)); 93 } 94 EXPORT_SYMBOL_GPL(crypto_sig_sign); 95 96 int crypto_sig_verify(struct crypto_sig *tfm, 97 const void *src, unsigned int slen, 98 const void *digest, unsigned int dlen) 99 { 100 struct crypto_akcipher **ctx = crypto_sig_ctx(tfm); 101 struct crypto_akcipher_sync_data data = { 102 .tfm = *ctx, 103 .src = src, 104 .slen = slen, 105 .dlen = dlen, 106 }; 107 int err; 108 109 err = crypto_akcipher_sync_prep(&data); 110 if (err) 111 return err; 112 113 memcpy(data.buf + slen, digest, dlen); 114 115 return crypto_akcipher_sync_post(&data, 116 crypto_akcipher_verify(data.req)); 117 } 118 EXPORT_SYMBOL_GPL(crypto_sig_verify); 119 120 int crypto_sig_set_pubkey(struct crypto_sig *tfm, 121 const void *key, unsigned int keylen) 122 { 123 struct crypto_akcipher **ctx = crypto_sig_ctx(tfm); 124 125 return crypto_akcipher_set_pub_key(*ctx, key, keylen); 126 } 127 EXPORT_SYMBOL_GPL(crypto_sig_set_pubkey); 128 129 int crypto_sig_set_privkey(struct crypto_sig *tfm, 130 const void *key, unsigned int keylen) 131 { 132 struct crypto_akcipher **ctx = crypto_sig_ctx(tfm); 133 134 return crypto_akcipher_set_priv_key(*ctx, key, keylen); 135 } 136 EXPORT_SYMBOL_GPL(crypto_sig_set_privkey); 137 138 MODULE_LICENSE("GPL"); 139 MODULE_DESCRIPTION("Public Key Signature Algorithms"); 140