159 lines
3.7 KiB
C
159 lines
3.7 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* SM2 asymmetric public-key algorithm
|
|
* as specified by OSCCA GM/T 0003.1-2012 -- 0003.5-2012 SM2 and
|
|
* described at https://tools.ietf.org/html/draft-shen-sm2-ecdsa-02
|
|
*
|
|
* Copyright (c) 2023 Shanghai Zhaoxin Semiconductor LTD.
|
|
* Authors: YunShen <yunshen@zhaoxin.com>
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/mpi.h>
|
|
#include <crypto/internal/akcipher.h>
|
|
#include <crypto/akcipher.h>
|
|
#include <crypto/sm2.h>
|
|
#include <asm/cpufeature.h>
|
|
#include <asm/processor.h>
|
|
#include <asm/cpu_device_id.h>
|
|
|
|
#define SCRATCH_SIZE (4 * 2048)
|
|
|
|
#define SM2_CWORD_VERIFY 0x8
|
|
#define SM2_VERIFY_PASS 1
|
|
|
|
struct sm2_cipher_data {
|
|
u8 pub_key[65]; /* public key */
|
|
};
|
|
|
|
/* Load supported features of the CPU to see if the SM2 is available. */
|
|
static int zhaoxin_gmi_available(void)
|
|
{
|
|
if (!boot_cpu_has(X86_FEATURE_SM2_EN)) {
|
|
pr_err("can't enable hardware SM2 if Zhaoxin GMI SM2 is not enabled\n");
|
|
return -ENODEV;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Zhaoxin sm2 verify function */
|
|
static inline size_t zhaoxin_gmi_sm2_verify(unsigned char *key, unsigned char *hash,
|
|
unsigned char *sig, unsigned char *scratch)
|
|
{
|
|
size_t result;
|
|
|
|
asm volatile(
|
|
".byte 0xf2, 0x0f, 0xa6, 0xc0"
|
|
: "=c"(result)
|
|
: "a"(hash), "b"(key), "d"(SM2_CWORD_VERIFY), "S"(scratch), "D"(sig)
|
|
: "memory");
|
|
|
|
return result;
|
|
}
|
|
|
|
/* Zhaoxin sm2 verify function */
|
|
static int _zhaoxin_sm2_verify(struct sm2_cipher_data *ec, unsigned char *hash, unsigned char *sig)
|
|
{
|
|
unsigned char *scratch = kzalloc(SCRATCH_SIZE, GFP_KERNEL);
|
|
int ret = -EKEYREJECTED;
|
|
size_t result;
|
|
|
|
result = zhaoxin_gmi_sm2_verify(ec->pub_key, hash, sig, scratch);
|
|
if (result == SM2_VERIFY_PASS)
|
|
ret = 0;
|
|
|
|
kfree(scratch);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int zhaoxin_sm2_verify(struct akcipher_request *req)
|
|
{
|
|
struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
|
|
struct sm2_cipher_data *ec = akcipher_tfm_ctx(tfm);
|
|
unsigned char *buffer;
|
|
int ret, buf_len;
|
|
|
|
buf_len = req->src_len + req->dst_len;
|
|
buffer = kmalloc(buf_len, GFP_KERNEL);
|
|
if (!buffer)
|
|
return -ENOMEM;
|
|
|
|
sg_pcopy_to_buffer(req->src, sg_nents_for_len(req->src, buf_len), buffer, buf_len, 0);
|
|
ret = _zhaoxin_sm2_verify(ec, buffer + req->src_len, buffer);
|
|
|
|
kfree(buffer);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int zhaoxin_sm2_set_pub_key(struct crypto_akcipher *tfm, const void *key,
|
|
unsigned int keylen)
|
|
{
|
|
struct sm2_cipher_data *ec = akcipher_tfm_ctx(tfm);
|
|
|
|
memcpy(ec->pub_key, key, keylen);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static unsigned int zhaoxin_sm2_max_size(struct crypto_akcipher *tfm)
|
|
{
|
|
/* Unlimited max size */
|
|
return PAGE_SIZE;
|
|
}
|
|
|
|
static int zhaoxin_sm2_init_tfm(struct crypto_akcipher *tfm)
|
|
{
|
|
return zhaoxin_gmi_available();
|
|
}
|
|
|
|
static void zhaoxin_sm2_exit_tfm(struct crypto_akcipher *tfm)
|
|
{
|
|
struct sm2_cipher_data *ec = akcipher_tfm_ctx(tfm);
|
|
|
|
memset(ec, 0, sizeof(*ec));
|
|
}
|
|
|
|
static struct akcipher_alg zhaoxin_sm2 = {
|
|
.verify = zhaoxin_sm2_verify,
|
|
.set_pub_key = zhaoxin_sm2_set_pub_key,
|
|
.max_size = zhaoxin_sm2_max_size,
|
|
.init = zhaoxin_sm2_init_tfm,
|
|
.exit = zhaoxin_sm2_exit_tfm,
|
|
.base = {
|
|
.cra_name = "sm2",
|
|
.cra_driver_name = "zhaoxin-gmi-sm2",
|
|
.cra_priority = 150,
|
|
.cra_module = THIS_MODULE,
|
|
.cra_ctxsize = sizeof(struct sm2_cipher_data),
|
|
},
|
|
};
|
|
|
|
static const struct x86_cpu_id zhaoxin_sm2_cpu_ids[] = {
|
|
X86_MATCH_FEATURE(X86_FEATURE_SM2, NULL),
|
|
{}
|
|
};
|
|
MODULE_DEVICE_TABLE(x86cpu, zhaoxin_sm2_cpu_ids);
|
|
|
|
static int __init zhaoxin_sm2_init(void)
|
|
{
|
|
if (!x86_match_cpu(zhaoxin_sm2_cpu_ids))
|
|
return -ENODEV;
|
|
|
|
return crypto_register_akcipher(&zhaoxin_sm2);
|
|
}
|
|
|
|
static void __exit zhaoxin_sm2_exit(void)
|
|
{
|
|
crypto_unregister_akcipher(&zhaoxin_sm2);
|
|
}
|
|
|
|
module_init(zhaoxin_sm2_init);
|
|
module_exit(zhaoxin_sm2_exit);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_AUTHOR("YunShen <yunshen@zhaoxin.com>");
|
|
MODULE_DESCRIPTION("SM2 Zhaoxin GMI Algorithm");
|
|
MODULE_ALIAS_CRYPTO("zhaoxin-gmi-sm2");
|