abc/GmSSL
1
0
Fork 0
mirror of https://github.com/guanzhi/GmSSL.git synced 2026-06-17 02:14:01 +08:00
Code Issues Packages Projects Releases Wiki Activity

update pmeth/ameth

Browse Source
This commit is contained in:
Zhi Guan
2018-11-28 16:15:06 +08:00
parent 9fe7aa1280
commit 5f3bb5c346
22 changed files with 1065 additions and 5223 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
apps/pkeyutl.c
View File

@@ -336,7 +336,6 @@ int pkeyutl_main(int argc, char **argv)
BIO_write(out, buf_out, buf_outlen);
end:
/*
EVP_PKEY_CTX_free(ctx);
release_engine(e);
BIO_free(in);
@@ -346,7 +345,6 @@ int pkeyutl_main(int argc, char **argv)
OPENSSL_free(sig);
sk_OPENSSL_STRING_free(pkeyopts);
NCONF_free(conf);
*/
return ret;
}

9
crypto/evp/pmeth_lib.c
View File

@@ -47,7 +47,14 @@ static const EVP_PKEY_METHOD *standard_methods[] = {
#ifndef OPENSSL_NO_EC
&ecx25519_pkey_meth,
#endif
&hkdf_pkey_meth
&hkdf_pkey_meth,
#ifndef OPENSSL_NO_SM9
&sm9_pkey_meth,
&sm9_master_pkey_meth,
#endif
#ifndef OPENSSL_NO_PAILLIER
&paillier_pkey_meth,
#endif
};
DECLARE_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_METHOD *, const EVP_PKEY_METHOD *,

2
crypto/gmapi/gmapi_skf_ec.c
View File

@@ -620,7 +620,7 @@ int i2d_ECCCIPHERBLOB(ECCCIPHERBLOB *a, unsigned char **pp)
return 0;
}
ret = i2d_SM2CiphertextValue(cv, pp));
ret = i2d_SM2CiphertextValue(cv, pp);
SM2CiphertextValue_free(cv);
return ret;
}

7
crypto/include/internal/evp_int.h
View File

@@ -84,6 +84,13 @@ extern const EVP_PKEY_METHOD hmac_pkey_meth;
extern const EVP_PKEY_METHOD rsa_pkey_meth;
extern const EVP_PKEY_METHOD tls1_prf_pkey_meth;
extern const EVP_PKEY_METHOD hkdf_pkey_meth;
#ifndef OPENSSL_NO_SM9
extern const EVP_PKEY_METHOD sm9_pkey_meth;
extern const EVP_PKEY_METHOD sm9_master_pkey_meth;
#endif
#ifndef OPENSSL_NO_PAILLIER
extern const EVP_PKEY_METHOD paillier_pkey_meth;
#endif
struct evp_md_st {
int type;

3
crypto/paillier/build.info
View File

@@ -1,2 +1,3 @@
LIBS=../../libcrypto
SOURCE[../../libcrypto]=pai_lib.c pai_err.c pai_asn1.c pai_ameth.c
SOURCE[../../libcrypto]=pai_lib.c pai_err.c pai_asn1.c pai_ameth.c \
pai_pmeth.c

55
crypto/paillier/pai_ameth.c
View File

@@ -225,31 +225,32 @@ static int old_paillier_priv_encode(const EVP_PKEY *pkey, unsigned char **pder)
}
const EVP_PKEY_ASN1_METHOD paillier_asn1_meth = {
EVP_PKEY_PAILLIER,
EVP_PKEY_PAILLIER,
0, //FIXME
"PAILLIER",
"OpenSSL PAILLIER algorithm",
paillier_pub_decode,
paillier_pub_encode,
paillier_pub_cmp,
paillier_pub_print,
paillier_priv_decode,
paillier_priv_encode,
paillier_priv_print,
int_paillier_size,
paillier_bits,
paillier_security_bits,
0, 0, 0, 0, 0, 0,
0,
int_paillier_free,
paillier_pkey_ctrl,
old_paillier_priv_decode,
old_paillier_priv_encode
EVP_PKEY_PAILLIER, /* pkey_id */
EVP_PKEY_PAILLIER, /* pkey_base_id */
0, /* pkey_flags */
"PAILLIER", /* pem_str */
"GmSSL Paillier algorithm", /* info */
paillier_pub_decode, /* pub_decode */
paillier_pub_encode, /* pub_encode */
paillier_pub_cmp, /* pub_cmp */
paillier_pub_print, /* pub_print */
paillier_priv_decode, /* priv_decode */
paillier_priv_encode, /* priv_encode */
paillier_priv_print, /* priv_print */
int_paillier_size, /* pkey_size */
paillier_bits, /* pkey_bits */
paillier_security_bits, /* pkey_security_bits */
NULL, /* param_decode */
NULL, /* param_encode */
NULL, /* param_missing */
NULL, /* param_copy */
NULL, /* param_cmp */
NULL, /* param_print */
NULL, /* sig_print */
int_paillier_free, /* pkey_free */
paillier_pkey_ctrl, /* pkey_ctrl */
old_paillier_priv_decode, /* old_priv_decode */
old_paillier_priv_encode, /* old_priv_encode */
NULL, /* item_verify */
NULL, /* item_sign */
};

6
crypto/paillier/pai_err.c
View File

@@ -32,8 +32,12 @@ static ERR_STRING_DATA PAILLIER_str_functs[] = {
{ERR_FUNC(PAILLIER_F_PAILLIER_PRIV_DECODE), "paillier_priv_decode"},
{ERR_FUNC(PAILLIER_F_PAILLIER_PRIV_ENCODE), "paillier_priv_encode"},
{ERR_FUNC(PAILLIER_F_PAILLIER_PUB_DECODE), "paillier_pub_decode"},
{ERR_FUNC(PAILLIER_F_PKEY_PAILLIER_CTRL), "pkey_paillier_ctrl"},
{ERR_FUNC(PAILLIER_F_PKEY_PAILLIER_CTRL_STR), "pkey_paillier_ctrl_str"},
{ERR_FUNC(PAILLIER_F_PKEY_PAILLIER_DECRYPT), "pkey_paillier_decrypt"},
{ERR_FUNC(PAILLIER_F_PKEY_PAILLIER_ENCRYPT), "pkey_paillier_encrypt"},
{ERR_FUNC(PAILLIER_F_PKEY_PAILLIER_INIT), "pkey_paillier_init"},
{ERR_FUNC(PAILLIER_F_PKEY_PAILLIER_KEYGEN), "pkey_paillier_keygen"},
{0, NULL}
};
@@ -42,8 +46,10 @@ static ERR_STRING_DATA PAILLIER_str_reasons[] = {
{ERR_REASON(PAILLIER_R_DECODE_ERROR), "decode error"},
{ERR_REASON(PAILLIER_R_GENERATE_PRIME_FAILED), "generate prime failed"},
{ERR_REASON(PAILLIER_R_INVALID_PLAINTEXT), "invalid plaintext"},
{ERR_REASON(PAILLIER_R_KEY_SIZE_TOO_SMALL), "key size too small"},
{ERR_REASON(PAILLIER_R_MALLOC_FAILED), "malloc failed"},
{ERR_REASON(PAILLIER_R_NOT_IMPLEMENTED), "not implemented"},
{ERR_REASON(PAILLIER_R_VALUE_MISSING), "value missing"},
{0, NULL}
};

1
crypto/paillier/pai_lcl.h
View File

@@ -67,4 +67,3 @@ struct paillier_st {
};
#endif

98
crypto/paillier/pai_lib.c
View File

@@ -81,7 +81,7 @@ void PAILLIER_free(PAILLIER *key)
int PAILLIER_size(const PAILLIER *key)
{
return BN_num_bits(key->n)/8;
return (BN_num_bits(key->n) * 2)/8;
}
int PAILLIER_security_bits(const PAILLIER *key)
@@ -100,57 +100,60 @@ int PAILLIER_generate_key(PAILLIER *key, int bits)
q = BN_new();
bn_ctx = BN_CTX_new();
if (!key->n) key->n = BN_new();
if (!key->lambda) key->lambda = BN_new();
if (!key->n_squared) key->n_squared = BN_new();
if (!key->n_plusone) key->n_plusone = BN_new();
if (!key->x) key->x = BN_new();
if (!key->n)
key->n = BN_new();
if (!key->lambda)
key->lambda = BN_new();
if (!key->n_squared)
key->n_squared = BN_new();
if (!key->n_plusone)
key->n_plusone = BN_new();
if (!key->x)
key->x = BN_new();
if (!p || !q || !bn_ctx || !key->n || !key->lambda ||
!key->n_squared || !key->n_plusone || !key->x) {
PAILLIERerr(PAILLIER_F_PAILLIER_GENERATE_KEY, ERR_R_MALLOC_FAILURE);
goto end;
}
key->bits = bits;
do {
if (!BN_generate_prime_ex(p, bits, 0, NULL, NULL, NULL)) {
if (!BN_generate_prime_ex(p, bits/2, 0, NULL, NULL, NULL)) {
PAILLIERerr(PAILLIER_F_PAILLIER_GENERATE_KEY,
PAILLIER_R_GENERATE_PRIME_FAILED);
goto end;
}
if (!BN_generate_prime_ex(q, bits, 0, NULL, NULL, NULL)) {
if (!BN_generate_prime_ex(q, bits/2, 0, NULL, NULL, NULL)) {
PAILLIERerr(PAILLIER_F_PAILLIER_GENERATE_KEY,
PAILLIER_R_GENERATE_PRIME_FAILED);
goto end;
}
if (!BN_mul(key->n, p, q, bn_ctx)) {
if (!BN_mul(key->n, p, q, bn_ctx)
|| !BN_sub_word(p, 1)
|| !BN_sub_word(q, 1)
/* lambda = (p - 1)*(q - 1) */
|| !BN_mul(key->lambda, p, q, bn_ctx)
/* n_squared = n^2 */
|| !BN_sqr(key->n_squared, key->n, bn_ctx)
/* n_plusone = n + 1 */
|| !BN_copy(key->n_plusone, key->n)
|| !BN_add_word(key->n_plusone, 1)
#if 0
/* x = (((g^lambda mod n^2) - 1)/n)^-1 mod n */
|| !BN_mod_exp(key->x, key->n_plusone, key->lambda, key->n_squared, bn_ctx)
|| !BN_sub_word(key->x, 1)
|| !BN_div(key->x, key->x, key->n)
|| !BN_mod_inverse(key->x, key->x, key->n, bn_ctx)
#endif
) {
PAILLIERerr(PAILLIER_F_PAILLIER_GENERATE_KEY, ERR_R_BN_LIB);
goto end;
}
if (!BN_sub_word(p, 1)) {
goto end;
}
if (!BN_sub_word(q, 1)) {
goto end;
}
if (!BN_mul(key->lambda, p, q, bn_ctx)) {
goto end;
}
BN_sqr(key->n_squared, key->n, bn_ctx);
BN_copy(key->n_plusone, key->n);
BN_add_word(key->n_plusone, 1);
/*
BN_mod_exp(key->x, key->n_plusone, key->lambda, key->n_squared, bn_ctx);
BN_sub_word(key->x, 1);
BN_div(key->x, key->x, key->n);
BN_mod_inverse(key->x, key->x, key->n, bn_ctx);
*/
} while (0);
ret = 1;
@@ -173,6 +176,9 @@ int PAILLIER_encrypt(BIGNUM *c, const BIGNUM *m, PAILLIER *pub_key)
BIGNUM *r = NULL;
BN_CTX *bn_ctx = NULL;
fprintf(stderr, "%s %d: m = %s\n", __FILE__, __LINE__, BN_bn2hex(m));
if (BN_cmp(m, pub_key->n) >= 0) {
PAILLIERerr(PAILLIER_F_PAILLIER_ENCRYPT, PAILLIER_R_INVALID_PLAINTEXT);
goto end;
@@ -249,22 +255,54 @@ int PAILLIER_decrypt(BIGNUM *m, const BIGNUM *c, PAILLIER *key)
PAILLIERerr(PAILLIER_F_PAILLIER_DECRYPT, ERR_R_BN_LIB);
goto end;
}
/*
printf("m = %s\n", BN_bn2hex(m));
printf("c = %s\n", BN_bn2hex(c));
printf("lambda = %s\n", BN_bn2hex(key->lambda));
printf("n^2 = %s\n", BN_bn2hex(key->n_squared));
*/
if (!key->n_squared) {
if (!(key->n_squared = BN_new())) {
PAILLIERerr(PAILLIER_F_PAILLIER_DECRYPT, ERR_R_MALLOC_FAILURE);
goto end;
}
if (!BN_sqr(key->n_squared, key->n, bn_ctx)) {
PAILLIERerr(PAILLIER_F_PAILLIER_DECRYPT, ERR_R_BN_LIB);
goto end;
}
}
fprintf(stderr, "%s %d: m = %s\n", __FILE__, __LINE__, BN_bn2hex(m));
if (!BN_mod_exp(m, c, key->lambda, key->n_squared, bn_ctx)) {
PAILLIERerr(PAILLIER_F_PAILLIER_DECRYPT, ERR_R_BN_LIB);
goto end;
}
fprintf(stderr, "%s %d: m = %s\n", __FILE__, __LINE__, BN_bn2hex(m));
if (!BN_sub_word(m, 1)) {
PAILLIERerr(PAILLIER_F_PAILLIER_DECRYPT, ERR_R_BN_LIB);
goto end;
}
fprintf(stderr, "%s %d: m = %s\n", __FILE__, __LINE__, BN_bn2hex(m));
if (!BN_div(m, NULL, m, key->n, bn_ctx)) {
PAILLIERerr(PAILLIER_F_PAILLIER_DECRYPT, ERR_R_BN_LIB);
goto end;
}
fprintf(stderr, "%s %d: m = %s\n", __FILE__, __LINE__, BN_bn2hex(m));
if (!BN_mod_mul(m, m, key->x, key->n, bn_ctx)) {
PAILLIERerr(PAILLIER_F_PAILLIER_DECRYPT, ERR_R_BN_LIB);
goto end;
}
printf("m = %s\n", BN_bn2hex(m));
ret = 1;
end:
BN_CTX_free(bn_ctx);

137
crypto/paillier/pai_pmeth.c
View File

@@ -49,37 +49,76 @@
#include <stdio.h>
#include <openssl/evp.h>
#include <openssl/err.h>
#include <openssl/paillier.h>
#include "internal/evp_int.h"
#include "pai_lcl.h"
typedef struct {
int flags;
int bits;
} PAILLIER_PKEY_CTX;
static int pkey_paillier_init(EVP_PKEY_CTX *ctx)
{
PAILLIER_PKEY_CTX *dctx;
if (!(dctx = OPENSSL_zalloc(sizeof(*dctx)))) {
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_INIT, ERR_R_MALLOC_FAILURE);
return 0;
}
dctx->bits = 4096;
(void)EVP_PKEY_CTX_set_data(ctx, dctx);
return 1;
}
static int pkey_paillier_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
{
PAILLIER_PKEY_CTX *dctx;
PAILLIER_PKEY_CTX *sctx;
if (!pkey_paillier_init(dst))
return 0;
dctx = EVP_PKEY_CTX_get_data(dst);
sctx = EVP_PKEY_CTX_get_data(src);
OPENSSL_assert(sctx);
*dctx = *sctx;
return 1;
}
static void pkey_paillier_cleanup(EVP_PKEY_CTX *ctx)
{
PAILLIER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
if (dctx) {
OPENSSL_free(dctx);
}
}
static int pkey_paillier_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
{
PAILLIER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
PAILLIER *pai = NULL;
if (!(pai = PAILLIER_new())) {
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_KEYGEN, ERR_R_MALLOC_FAILURE);
return 0;
}
if (!EVP_PKEY_assign_PAILLIER(pkey, pai)) {
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_KEYGEN, ERR_R_EVP_LIB);
PAILLIER_free(pai);
return 0;
}
if (!PAILLIER_generate_key(EVP_PKEY_get0_PAILLIER(pkey), dctx->bits)) {
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_KEYGEN, ERR_R_PAILLIER_LIB);
return 0;
}
return 1;
}
static int pkey_paillier_encrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
const unsigned char *in, size_t inlen)
{
int ret = 0;
PAILLIER *key = ctx->pkey->pkey.paillier;
PAILLIER *key = EVP_PKEY_get0_PAILLIER(EVP_PKEY_CTX_get0_pkey(ctx));
BIGNUM *m = NULL;
BIGNUM *c = NULL;
//FIXME: check inlen
if (!out) {
*outlen = PAILLIER_size(key);
return 1;
@@ -92,20 +131,21 @@ static int pkey_paillier_encrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_ENCRYPT, ERR_R_MALLOC_FAILURE);
goto end;
}
if (!BN_bin2bn(in, (int)inlen, m)) {
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_ENCRYPT, ERR_R_BN_LIB);
goto end;
}
if (!PAILLIER_encrypt(c, m, key)) {
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_ENCRYPT, ERR_R_PAILLIER_LIB);
goto end;
}
/* the ciphertext has no prefix zeros */
*outlen = BN_bn2bin(c, out);
ret = 1;
end:
BN_free(m);
BN_clear_free(m);
BN_free(c);
return ret;
}
@@ -114,7 +154,7 @@ static int pkey_paillier_decrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *
const unsigned char *in, size_t inlen)
{
int ret = 0;
PAILLIER *key = ctx->pkey->pkey.paillier;
PAILLIER *key = EVP_PKEY_get0_PAILLIER(EVP_PKEY_CTX_get0_pkey(ctx));
BIGNUM *m = NULL;
BIGNUM *c = NULL;
@@ -130,15 +170,16 @@ static int pkey_paillier_decrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_DECRYPT, ERR_R_MALLOC_FAILURE);
goto end;
}
if (!BN_bin2bn(in, (int)inlen, c)) {
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_DECRYPT, ERR_R_BN_LIB);
goto end;
}
if (!PAILLIER_decrypt(m, c, key)) {
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_DECRYPT, ERR_R_PAILLIER_LIB);
goto end;
}
/* the plaintext has no prefix zeros */
*outlen = BN_bn2bin(m, out);
ret = 1;
end:
@@ -149,43 +190,61 @@ end:
static int pkey_paillier_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
{
return 0;
PAILLIER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
switch (type) {
case EVP_PKEY_CTRL_PAILLIER_KEYGEN_BITS:
if (p1 < PAILLIER_MIN_KEY_BITS) {
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_CTRL, PAILLIER_R_KEY_SIZE_TOO_SMALL);
return -2;
}
dctx->bits = p1;
return 1;
}
return -2;
}
static int pkey_paillier_ctrl_str(EVP_PKEY_CTX *ctx,
const char *type, const char *value)
static int pkey_paillier_ctrl_str(EVP_PKEY_CTX *ctx, const char *type, const char *value)
{
return 0;
if (!value) {
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_CTRL_STR, PAILLIER_R_VALUE_MISSING);
return 0;
}
if (!strcmp(type, "bits")) {
int nbits = atoi(value);
return EVP_PKEY_CTX_set_paillier_keygen_bits(ctx, nbits);
}
return -2;
}
#define EVP_PKEY_PAILLIER NID_paillier
const EVP_PKEY_METHOD paillier_pmeth = {
EVP_PKEY_PAILLIER,
0,
pkey_paillier_init,
pkey_paillier_copy,
pkey_paillier_cleanup,
0, 0,
0,
pkey_paillier_keygen,
0, 0,
0, 0,
0, 0,
0, 0, 0, 0,
0,
pkey_paillier_encrypt,
0,
pkey_paillier_decrypt,
0, 0,
pkey_paillier_ctrl,
pkey_paillier_ctrl_str
const EVP_PKEY_METHOD paillier_pkey_meth = {
EVP_PKEY_PAILLIER, /* pkey_id */
0, /* flags */
pkey_paillier_init, /* init */
pkey_paillier_copy, /* copy */
pkey_paillier_cleanup, /* cleanup */
NULL, /* paramgen_init */
NULL, /* paramgen */
NULL, /* keygen_init */
pkey_paillier_keygen, /* keygen */
NULL, /* sign_init */
NULL, /* sign */
NULL, /* verify_init */
NULL, /* verify */
NULL, /* verify_recover_init */
NULL, /* verify_recover */
NULL, /* signctx_init */
NULL, /* signctx */
NULL, /* verifyctx_init */
NULL, /* verifyctx */
NULL, /* encrypt_init */
pkey_paillier_encrypt, /* encrypt */
NULL, /* decrypt_init */
pkey_paillier_decrypt, /* decrypt */
NULL, /* derive_init */
NULL, /* derive */
pkey_paillier_ctrl, /* ctrl */
pkey_paillier_ctrl_str /* ctrl_str */
};

6
crypto/skf/skf_meth.c
View File

@@ -128,7 +128,6 @@ SKF_METHOD *SKF_METHOD_load_library(const char *so_path)
SKF_METHOD_BIND_FUNCTION(ECCExportSessionKey);
SKF_METHOD_BIND_FUNCTION(ExtECCEncrypt);
SKF_METHOD_BIND_FUNCTION(ExtECCDecrypt);
SKF_METHOD_BIND_FUNCTION(ECCDecrypt);
SKF_METHOD_BIND_FUNCTION(ExtECCSign);
SKF_METHOD_BIND_FUNCTION(ExtECCVerify);
SKF_METHOD_BIND_FUNCTION(GenerateAgreementDataWithECC);
@@ -154,6 +153,11 @@ SKF_METHOD *SKF_METHOD_load_library(const char *so_path)
SKF_METHOD_BIND_FUNCTION(MacFinal);
SKF_METHOD_BIND_FUNCTION(CloseHandle);
#ifdef SKF_SUPPORT_ECCDECRYPT
/* wisectech usb-key support ECCDecrypt */
SKF_METHOD_BIND_FUNCTION(ECCDecrypt);
#endif
ret = skf;
skf = NULL;

2
crypto/sm9/build.info
View File

@@ -1,4 +1,4 @@
LIBS=../../libcrypto
SOURCE[../../libcrypto]=sm9_lib.c sm9_err.c sm9_asn1.c sm9_params.c \
sm9_setup.c sm9_keygen.c sm9_sign.c sm9_enc.c sm9_exch.c sm9_rate.c \
sm9_ameth.c
sm9_pmeth.c sm9_ameth.c

15
crypto/sm9/sm9_ameth.c
View File

@@ -68,10 +68,6 @@ static int sm9_params_encode(X509_PUBKEY *pubkey, const EVP_PKEY *pkey)
if ((penclen = i2d_SM9PublicParameters(pkey->pkey.sm9_master, &penc)) <= 0) {
return 0;
}
printf("penclen = %d\n", penclen);
printf("penc == NULL: %d\n", penc == NULL);
printf("%lu\n", OBJ_nid2obj(EVP_PKEY_SM9_MASTER));
OPENSSL_assert(pubkey);
if (X509_PUBKEY_set0_param(pubkey, OBJ_nid2obj(EVP_PKEY_SM9_MASTER),
@@ -152,7 +148,6 @@ static int sm9_master_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
{
unsigned char *rk = NULL;
int rklen;
fprintf(stderr, "%s %d: %s\n", __FILE__, __LINE__, __FUNCTION__);
if ((rklen = i2d_SM9MasterSecret(pkey->pkey.sm9_master, &rk)) <= 0) {
SM9err(SM9_F_SM9_MASTER_ENCODE, ERR_R_MALLOC_FAILURE);
@@ -207,7 +202,6 @@ static int old_sm9_master_decode(EVP_PKEY *pkey,
static int old_sm9_master_encode(const EVP_PKEY *pkey, unsigned char **pder)
{
fprintf(stderr, "%s %d: %s\n", __FILE__, __LINE__, __FUNCTION__);
return i2d_SM9MasterSecret(pkey->pkey.sm9_master, pder);
}
@@ -216,7 +210,7 @@ const EVP_PKEY_ASN1_METHOD sm9_master_asn1_meth = {
EVP_PKEY_SM9_MASTER, /* pkey_base_id */
0, /* pkey_flags */
"SM9 MASTER", /* pem_str */
"GmSSL SM9 algorithm", /* info */
"GmSSL SM9 system algorithm", /* info */
sm9_params_decode, /* pub_decode */
sm9_params_encode, /* pub_encode */
sm9_params_cmp, /* pub_cmp */
@@ -242,7 +236,6 @@ const EVP_PKEY_ASN1_METHOD sm9_master_asn1_meth = {
NULL, /* item_sign */
};
static int sm9_pub_encode(X509_PUBKEY *pubkey, const EVP_PKEY *pkey)
{
unsigned char *penc = NULL;
@@ -332,11 +325,6 @@ static int sm9_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
unsigned char *rk = NULL;
int rklen;
/*
fprintf(stderr, "%s %d: %s\n", __FILE__, __LINE__, __FUNCTION__);
fprintf(stderr, "%s %s: %d\n", __FILE__, __LINE__, pkey->pkey.sm9->privatePoint != NULL);
*/
if ((rklen = i2d_SM9PrivateKey(pkey->pkey.sm9, &rk)) <= 0) {
SM9err(SM9_F_SM9_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
return 0;
@@ -375,7 +363,6 @@ static int old_sm9_priv_decode(EVP_PKEY *pkey,
static int old_sm9_priv_encode(const EVP_PKEY *pkey, unsigned char **pder)
{
fprintf(stderr, "%s %d: %s\n", __FILE__, __LINE__, __FUNCTION__);
return i2d_SM9PrivateKey(pkey->pkey.sm9, pder);
}

50
crypto/sm9/sm9_err.c
View File

@@ -21,22 +21,26 @@
static ERR_STRING_DATA SM9_str_functs[] = {
{ERR_FUNC(SM9_F_OLD_SM9_MASTER_DECODE), "old_sm9_master_decode"},
{ERR_FUNC(SM9_F_OLD_SM9_PRIV_DECODE), "old_sm9_priv_decode"},
{ERR_FUNC(SM9_F_SM9CIPHERTEXT_CHECK), "SM9Ciphertext_check"},
{ERR_FUNC(SM9_F_SM9ENCPARAMETERS_DECRYPT), "SM9EncParameters_decrypt"},
{ERR_FUNC(SM9_F_SM9ENCPARAMETERS_ENCRYPT), "SM9EncParameters_encrypt"},
{ERR_FUNC(SM9_F_SM9ENCPARAMETERS_GENERATE_MAC),
"SM9EncParameters_generate_mac"},
{ERR_FUNC(SM9_F_SM9ENCPARAMETERS_GET_KEY_LENGTH),
"SM9EncParameters_get_key_length"},
{ERR_FUNC(SM9_F_SM9PUBLICPARAMETERS_GET_POINT_SIZE),
"SM9PublicParameters_get_point_size"},
{ERR_FUNC(SM9_F_PKEY_SM9_COPY), "pkey_sm9_copy"},
{ERR_FUNC(SM9_F_PKEY_SM9_CTRL), "pkey_sm9_ctrl"},
{ERR_FUNC(SM9_F_PKEY_SM9_CTRL_STR), "pkey_sm9_ctrl_str"},
{ERR_FUNC(SM9_F_PKEY_SM9_DECRYPT), "pkey_sm9_decrypt"},
{ERR_FUNC(SM9_F_PKEY_SM9_ENCRYPT), "pkey_sm9_encrypt"},
{ERR_FUNC(SM9_F_PKEY_SM9_INIT), "pkey_sm9_init"},
{ERR_FUNC(SM9_F_PKEY_SM9_KEYGEN), "pkey_sm9_keygen"},
{ERR_FUNC(SM9_F_PKEY_SM9_MASTER_COPY), "pkey_sm9_master_copy"},
{ERR_FUNC(SM9_F_PKEY_SM9_MASTER_CTRL), "pkey_sm9_master_ctrl"},
{ERR_FUNC(SM9_F_PKEY_SM9_MASTER_CTRL_STR), "pkey_sm9_master_ctrl_str"},
{ERR_FUNC(SM9_F_PKEY_SM9_MASTER_ENCRYPT), "pkey_sm9_master_encrypt"},
{ERR_FUNC(SM9_F_PKEY_SM9_MASTER_INIT), "pkey_sm9_master_init"},
{ERR_FUNC(SM9_F_PKEY_SM9_MASTER_KEYGEN), "pkey_sm9_master_keygen"},
{ERR_FUNC(SM9_F_PKEY_SM9_MASTER_VERIFY), "pkey_sm9_master_verify"},
{ERR_FUNC(SM9_F_PKEY_SM9_SIGN), "pkey_sm9_sign"},
{ERR_FUNC(SM9_F_PKEY_SM9_VERIFY), "pkey_sm9_verify"},
{ERR_FUNC(SM9_F_SM9_COMPUTE_SHARE_KEY_A), "SM9_compute_share_key_A"},
{ERR_FUNC(SM9_F_SM9_COMPUTE_SHARE_KEY_B), "SM9_compute_share_key_B"},
{ERR_FUNC(SM9_F_SM9_DECRYPT), "SM9_decrypt"},
{ERR_FUNC(SM9_F_SM9_DO_DECRYPT), "SM9_do_decrypt"},
{ERR_FUNC(SM9_F_SM9_DO_ENCRYPT), "SM9_do_encrypt"},
{ERR_FUNC(SM9_F_SM9_ENCRYPT), "SM9_encrypt"},
{ERR_FUNC(SM9_F_SM9_EXTRACT_PRIVATE_KEY), "SM9_extract_private_key"},
{ERR_FUNC(SM9_F_SM9_EXTRACT_PUBLIC_PARAMETERS),
"SM9_extract_public_parameters"},
{ERR_FUNC(SM9_F_SM9_GENERATE_KEY_EXCHANGE), "SM9_generate_key_exchange"},
@@ -64,38 +68,36 @@ static ERR_STRING_DATA SM9_str_functs[] = {
};
static ERR_STRING_DATA SM9_str_reasons[] = {
{ERR_REASON(SM9_R_BUFFER_TOO_SMALL), "buffer too small"},
{ERR_REASON(SM9_R_DECODE_ERROR), "decode error"},
{ERR_REASON(SM9_R_DIGEST_FAILURE), "digest failure"},
{ERR_REASON(SM9_R_EC_LIB), "ec lib"},
{ERR_REASON(SM9_R_EXTENSION_FIELD_ERROR), "extension field error"},
{ERR_REASON(SM9_R_GENERATE_MAC_FAILURE), "generate mac failure"},
{ERR_REASON(SM9_R_HASH_FAILURE), "hash failure"},
{ERR_REASON(SM9_R_INVALID_CIPHERTEXT), "invalid ciphertext"},
{ERR_REASON(SM9_R_IDENTITY_REQUIRED), "identity required"},
{ERR_REASON(SM9_R_ID_OR_MASTER_SECRET_REQUIRED),
"id or master secret required"},
{ERR_REASON(SM9_R_INVALID_DIGEST_TYPE), "invalid digest type"},
{ERR_REASON(SM9_R_INVALID_ENCPARAMETERS), "invalid encparameters"},
{ERR_REASON(SM9_R_INVALID_ENCRYPT_SCHEME), "invalid encrypt scheme"},
{ERR_REASON(SM9_R_INVALID_HASH1), "invalid hash1"},
{ERR_REASON(SM9_R_INVALID_HASH2_DIGEST), "invalid hash2 digest"},
{ERR_REASON(SM9_R_INVALID_ID), "invalid id"},
{ERR_REASON(SM9_R_INVALID_ID_LENGTH), "invalid id length"},
{ERR_REASON(SM9_R_INVALID_INPUT), "invalid input"},
{ERR_REASON(SM9_R_INVALID_KEM_KEY_LENGTH), "invalid kem key length"},
{ERR_REASON(SM9_R_INVALID_KEY_AGREEMENT_CHECKSUM),
"invalid key agreement checksum"},
{ERR_REASON(SM9_R_INVALID_KEY_LENGTH), "invalid key length"},
{ERR_REASON(SM9_R_INVALID_MD), "invalid md"},
{ERR_REASON(SM9_R_INVALID_KEY_USAGE), "invalid key usage"},
{ERR_REASON(SM9_R_INVALID_PAIRING), "invalid pairing"},
{ERR_REASON(SM9_R_INVALID_PAIRING_TYPE), "invalid pairing type"},
{ERR_REASON(SM9_R_INVALID_PARAMETER), "invalid parameter"},
{ERR_REASON(SM9_R_INVALID_POINTPPUB), "invalid pointppub"},
{ERR_REASON(SM9_R_INVALID_PRIVATE_POINT), "invalid private point"},
{ERR_REASON(SM9_R_INVALID_SCHEME), "invalid scheme"},
{ERR_REASON(SM9_R_INVALID_SIGNATURE), "invalid signature"},
{ERR_REASON(SM9_R_INVALID_SIGNATURE_FORMAT), "invalid signature format"},
{ERR_REASON(SM9_R_INVALID_TYPE1CURVE), "invalid type1curve"},
{ERR_REASON(SM9_R_KDF_FAILURE), "kdf failure"},
{ERR_REASON(SM9_R_INVALID_SIGN_MD), "invalid sign md"},
{ERR_REASON(SM9_R_INVALID_SIGN_SCHEME), "invalid sign scheme"},
{ERR_REASON(SM9_R_INVALID_SM9_SCHEME), "invalid sm9 scheme"},
{ERR_REASON(SM9_R_NO_MASTER_SECRET), "no master secret"},
{ERR_REASON(SM9_R_PAIRING_ERROR), "pairing error"},
{ERR_REASON(SM9_R_RATE_PAIRING_ERROR), "rate pairing error"},
{ERR_REASON(SM9_R_SIGNER_ID_REQUIRED), "signer id required"},
{ERR_REASON(SM9_R_TWIST_CURVE_ERROR), "twist curve error"},
{ERR_REASON(SM9_R_VERIFY_FAILURE), "verify failure"},
{ERR_REASON(SM9_R_ZERO_ID), "zero id"},

5
crypto/sm9/sm9_lcl.h
View File

@@ -181,6 +181,11 @@ void point_cleanup(point_t *P);
int rate_pairing(fp12_t r, const point_t *Q, const EC_POINT *P, BN_CTX *ctx);
int sm9_check_pairing(int nid);
int sm9_check_scheme(int nid);
int sm9_check_hash1(int nid);
int sm9_check_encrypt_scheme(int nid);
int sm9_check_sign_scheme(int nid);
#ifdef __cplusplus
}

25
crypto/sm9/sm9_lib.c
View File

@@ -173,3 +173,28 @@ int SM9_KEY_up_ref(SM9_KEY *sk)
REF_ASSERT_ISNT(i < 2);
return ((i > 1) ? 1 : 0);
}
int sm9_check_pairing(int nid)
{
return 1;
}
int sm9_check_scheme(int nid)
{
return 1;
}
int sm9_check_hash1(int nid)
{
return 1;
}
int sm9_check_encrypt_scheme(int nid)
{
return 1;
}
int sm9_check_sign_scheme(int nid)
{
return 1;
}

510
crypto/sm9/sm9_pmeth.c Normal file
View File

@@ -0,0 +1,510 @@
/* ====================================================================
* Copyright (c) 2015 - 2018 The GmSSL Project. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. All advertising materials mentioning features or use of this
* software must display the following acknowledgment:
* "This product includes software developed by the GmSSL Project.
* (http://gmssl.org/)"
*
* 4. The name "GmSSL Project" must not be used to endorse or promote
* products derived from this software without prior written
* permission. For written permission, please contact
* guanzhi1980@gmail.com.
*
* 5. Products derived from this software may not be called "GmSSL"
* nor may "GmSSL" appear in their names without prior written
* permission of the GmSSL Project.
*
* 6. Redistributions of any form whatsoever must retain the following
* acknowledgment:
* "This product includes software developed by the GmSSL Project
* (http://gmssl.org/)"
*
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
* ====================================================================
*/
#include <stdio.h>
#include <openssl/sm9.h>
#include <openssl/err.h>
#include <openssl/evp.h>
#include <openssl/x509.h>
#include <openssl/asn1t.h>
#include <openssl/objects.h>
#include "internal/cryptlib.h"
#include "internal/asn1_int.h"
#include "internal/evp_int.h"
#include "sm9_lcl.h"
typedef struct {
int pairing; /* NID_sm9bn256v1 */
int scheme; /* NID_sm9[sign|encrypt|keyagreement] */
int hash1; /* NID_sm9hash1_with_[sm3|sha256] */
int sign_scheme; /* NID_sm9sign_with_[sm3|sha256] */
int encrypt_scheme; /*NID_sm9encrypt */
char *id;
} SM9_MASTER_PKEY_CTX;
static int pkey_sm9_master_init(EVP_PKEY_CTX *ctx)
{
SM9_MASTER_PKEY_CTX *dctx;
if (!(dctx = OPENSSL_zalloc(sizeof(*dctx)))) {
SM9err(SM9_F_PKEY_SM9_MASTER_INIT, ERR_R_MALLOC_FAILURE);
return 0;
}
dctx->pairing = NID_sm9bn256v1;
dctx->scheme = NID_sm9encrypt;
dctx->hash1 = NID_sm9hash1_with_sm3;
dctx->sign_scheme = NID_sm3;
dctx->encrypt_scheme = NID_sm9encrypt_with_sm3_xor;
dctx->id = NULL;
ctx->data = dctx;
return 1;
}
static int pkey_sm9_master_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
{
SM9_MASTER_PKEY_CTX *dctx, *sctx;
if (!pkey_sm9_master_init(dst))
return 0;
sctx = src->data;
dctx = dst->data;
*dctx = *sctx;
if (!(dctx->id = OPENSSL_strdup(sctx->id))) {
SM9err(SM9_F_PKEY_SM9_MASTER_COPY, ERR_R_MALLOC_FAILURE);
return 0;
}
return 1;
}
static void pkey_sm9_master_cleanup(EVP_PKEY_CTX *ctx)
{
SM9_MASTER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
if (dctx) {
OPENSSL_free(dctx->id);
OPENSSL_free(dctx);
}
}
static int pkey_sm9_master_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
{
SM9_MASTER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
SM9_MASTER_KEY *sm9_master;
if (!(sm9_master = SM9_generate_master_secret(dctx->pairing,
dctx->scheme, dctx->hash1))) {
SM9err(SM9_F_PKEY_SM9_MASTER_KEYGEN, ERR_R_SM9_LIB);
return 0;
}
if (!EVP_PKEY_assign_SM9_MASTER(pkey, sm9_master)) {
SM9err(SM9_F_PKEY_SM9_MASTER_KEYGEN, ERR_R_EVP_LIB);
SM9_MASTER_KEY_free(sm9_master);
return 0;
}
return 1;
}
static int pkey_sm9_master_verify(EVP_PKEY_CTX *ctx,
const unsigned char *sig, size_t siglen,
const unsigned char *tbs, size_t tbslen)
{
int ret;
SM9_MASTER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
SM9_MASTER_KEY *sm9_master = EVP_PKEY_get0_SM9_MASTER(
EVP_PKEY_CTX_get0_pkey(ctx));
if (OBJ_obj2nid(sm9_master->scheme) != NID_sm9sign) {
SM9err(SM9_F_PKEY_SM9_MASTER_VERIFY, SM9_R_INVALID_KEY_USAGE);
return 0;
}
if (!dctx->id) {
SM9err(SM9_F_PKEY_SM9_MASTER_VERIFY, SM9_R_SIGNER_ID_REQUIRED);
return 0;
}
if ((ret = SM9_verify(dctx->sign_scheme, tbs, tbslen, sig, siglen,
sm9_master, dctx->id, strlen(dctx->id))) < 0) {
SM9err(SM9_F_PKEY_SM9_MASTER_VERIFY, ERR_R_SM9_LIB);
}
return ret;
}
static int pkey_sm9_master_encrypt(EVP_PKEY_CTX *ctx,
unsigned char *out, size_t *outlen,
const unsigned char *in, size_t inlen)
{
SM9_MASTER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
SM9_MASTER_KEY *sm9_master = EVP_PKEY_get0_SM9_MASTER(
EVP_PKEY_CTX_get0_pkey(ctx));
if (OBJ_obj2nid(sm9_master->scheme) != NID_sm9encrypt) {
SM9err(SM9_F_PKEY_SM9_MASTER_ENCRYPT, SM9_R_INVALID_KEY_USAGE);
return 0;
}
if (!dctx->id) {
SM9err(SM9_F_PKEY_SM9_MASTER_ENCRYPT, SM9_R_IDENTITY_REQUIRED);
return 0;
}
if (!SM9_encrypt(dctx->encrypt_scheme, in, inlen, out, outlen,
sm9_master, dctx->id, strlen(dctx->id))) {
SM9err(SM9_F_PKEY_SM9_MASTER_ENCRYPT, ERR_R_SM9_LIB);
return 0;
}
return 1;
}
static int pkey_sm9_master_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen)
{
SM9_MASTER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
SM9_MASTER_KEY *sm9_master = EVP_PKEY_get0_SM9_MASTER(
EVP_PKEY_CTX_get0_pkey(ctx));
return -2;
}
static int pkey_sm9_master_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
{
SM9_MASTER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
switch (type) {
case EVP_PKEY_CTRL_SM9_PAIRING:
if (p1 == -2)
return dctx->pairing;
if (!sm9_check_pairing(p1)) {
}
dctx->pairing = p1;
return 1;
case EVP_PKEY_CTRL_SM9_SCHEME:
if (p1 == -2)
return dctx->scheme;
if (!sm9_check_scheme(p1)) {
SM9err(SM9_F_PKEY_SM9_MASTER_CTRL, SM9_R_INVALID_SCHEME);
return 0;
}
dctx->scheme = p1;
return 1;
case EVP_PKEY_CTRL_SM9_HASH1:
if (p1 == -2)
return dctx->hash1;
if (!sm9_check_hash1(p1)) {
SM9err(SM9_F_PKEY_SM9_MASTER_CTRL, SM9_R_INVALID_HASH1);
return 0;
}
dctx->hash1 = p1;
return 1;
case EVP_PKEY_CTRL_SM9_ID:
if (!p2 || !strlen((char *)p2) || strlen((char *)p2) > SM9_MAX_ID_LENGTH) {
SM9err(SM9_F_PKEY_SM9_MASTER_CTRL, SM9_R_INVALID_ID);
return 0;
} else {
char *id = NULL;
if (!(id = OPENSSL_strdup((char *)p2))) {
SM9err(SM9_F_PKEY_SM9_MASTER_CTRL, ERR_R_MALLOC_FAILURE);
}
if (dctx->id) {
OPENSSL_free(dctx->id);
}
dctx->id = id;
}
return 1;
case EVP_PKEY_CTRL_GET_SM9_ID:
*(const char **)p2 = dctx->id;
return 1;
}
return -2;
}
static int pkey_sm9_master_ctrl_str(EVP_PKEY_CTX *ctx, const char *type, const char *value)
{
if (!strcmp(type, "pairing")) {
int nid = OBJ_txt2nid(value);
if (!sm9_check_pairing(nid)) {
SM9err(SM9_F_PKEY_SM9_MASTER_CTRL_STR, SM9_R_INVALID_PAIRING);
return 0;
}
return EVP_PKEY_CTX_set_sm9_pairing(ctx, nid);
} else if (!strcmp(type, "scheme")) {
int nid = OBJ_txt2nid(value);
if (!sm9_check_scheme(nid)) {
SM9err(SM9_F_PKEY_SM9_MASTER_CTRL_STR, SM9_R_INVALID_SM9_SCHEME);
return 0;
}
return EVP_PKEY_CTX_set_sm9_scheme(ctx, nid);
} else if (!strcmp(type, "hash1")) {
int nid = OBJ_txt2nid(value);
if (!sm9_check_hash1(nid)) {
SM9err(SM9_F_PKEY_SM9_MASTER_CTRL_STR, SM9_R_INVALID_SM9_SCHEME);
return 0;
}
return EVP_PKEY_CTX_set_sm9_hash1(ctx, nid);
} else if (!strcmp(type, "id")) {
return EVP_PKEY_CTX_set_sm9_id(ctx, value);
}
return -2;
}
const EVP_PKEY_METHOD sm9_master_pkey_meth = {
EVP_PKEY_SM9_MASTER, /* pkey_id */
0, /* flags */
pkey_sm9_master_init, /* init */
pkey_sm9_master_copy, /* copy */
pkey_sm9_master_cleanup,/* cleanup */
NULL, /* paramgen_init */
NULL, /* paramgen */
NULL, /* keygen_init */
pkey_sm9_master_keygen, /* keygen */
NULL, /* sign_init */
NULL, /* sign */
NULL, /* verify_init */
pkey_sm9_master_verify, /* verify */
NULL, /* verify_recover_init */
NULL, /* verify_recover */
NULL, /* signctx_init */
NULL, /* signctx */
NULL, /* verifyctx_init */
NULL, /* verifyctx */
NULL, /* encrypt_init */
pkey_sm9_master_encrypt,/* encrypt */
NULL, /* decrypt_init */
NULL, /* decrypt */
NULL, /* derive_init */
pkey_sm9_master_derive, /* derive */
pkey_sm9_master_ctrl, /* ctrl */
pkey_sm9_master_ctrl_str,/* ctrl_str */
};
typedef struct {
int sign_scheme;
int encrypt_scheme;
char *id;
} SM9_PKEY_CTX;
static int pkey_sm9_init(EVP_PKEY_CTX *ctx)
{
SM9_PKEY_CTX *dctx;
if (!(dctx = OPENSSL_zalloc(sizeof(*dctx)))) {
SM9err(SM9_F_PKEY_SM9_INIT, ERR_R_MALLOC_FAILURE);
return 0;
}
dctx->sign_scheme = NID_sm3; // FIXME: some like NID_sm9sign_sm3
dctx->encrypt_scheme = NID_sm9encrypt_with_sm3_xor;
dctx->id = NULL;
OPENSSL_assert(EVP_PKEY_CTX_get_data(ctx) == NULL);
(void)EVP_PKEY_CTX_set_data(ctx, dctx);
return 1;
}
static int pkey_sm9_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
{
SM9_PKEY_CTX *dctx, *sctx;
if (!pkey_sm9_init(dst)) {
SM9err(SM9_F_PKEY_SM9_COPY, ERR_R_SM9_LIB);
return 0;
}
sctx = EVP_PKEY_CTX_get_data(src);
dctx = EVP_PKEY_CTX_get_data(dst);
*dctx = *sctx;
if (!(dctx->id = OPENSSL_strdup(sctx->id))) {
return 0;
}
return 1;
}
static void pkey_sm9_cleanup(EVP_PKEY_CTX *ctx)
{
SM9_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
if (dctx) {
OPENSSL_free(dctx->id);
OPENSSL_free(dctx);
}
}
static int pkey_sm9_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
{
/*
SM9_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
SM9_KEY *sm9;
if (!dctx->master_secret || !dctx->id) {
SM9err(SM9_F_PKEY_SM9_KEYGEN, SM9_R_ID_OR_MASTER_SECRET_REQUIRED);
return 0;
}
if (!(sm9 = SM9_extract_private_key(dctx->master,
dctx->id, strlen(dctx->id)))) {
SM9err(SM9_F_PKEY_SM9_KEYGEN, ERR_R_SM9_LIB);
return 0;
}
if (EVP_PKEY_assign_SM9(pkey, sm9) <= 0) {
SM9err(SM9_F_PKEY_SM9_KEYGEN, ERR_R_EVP_LIB);
SM9_KEY_free(sm9);
return 0;
}
*/
return 1;
}
static int pkey_sm9_sign(EVP_PKEY_CTX *ctx,
unsigned char *sig, size_t *siglen,
const unsigned char *tbs, size_t tbslen)
{
SM9_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
SM9_KEY *sm9 = EVP_PKEY_get0_SM9(EVP_PKEY_CTX_get0_pkey(ctx));
if (!SM9_sign(dctx->sign_scheme, tbs, tbslen, sig, siglen, sm9)) {
SM9err(SM9_F_PKEY_SM9_SIGN, ERR_R_SM9_LIB);
return 0;
}
return 1;
}
static int pkey_sm9_decrypt(EVP_PKEY_CTX *ctx,
unsigned char *out, size_t *outlen,
const unsigned char *in, size_t inlen)
{
SM9_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
SM9_KEY *sm9 = EVP_PKEY_get0_SM9(EVP_PKEY_CTX_get0_pkey(ctx));
if (!SM9_decrypt(dctx->encrypt_scheme, in, inlen,
out, outlen, sm9)) {
SM9err(SM9_F_PKEY_SM9_DECRYPT, ERR_R_SM9_LIB);
return 0;
}
return 1;
}
static int pkey_sm9_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen)
{
return -2;
}
static int pkey_sm9_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
{
SM9_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
switch (type) {
case EVP_PKEY_CTRL_SM9_SIGN_SCHEME:
if (p1 == -2)
return dctx->sign_scheme;
if (!sm9_check_sign_scheme(p1)) {
SM9err(SM9_F_PKEY_SM9_CTRL, SM9_R_INVALID_SIGN_SCHEME);
return 0;
}
dctx->sign_scheme = p1;
return 1;
case EVP_PKEY_CTRL_SM9_ENCRYPT_SCHEME:
if (p1 == -2)
return dctx->encrypt_scheme;
if (!sm9_check_encrypt_scheme(p1)) {
SM9err(SM9_F_PKEY_SM9_CTRL, SM9_R_INVALID_ENCRYPT_SCHEME);
return 0;
}
dctx->encrypt_scheme = p1;
return 1;
case EVP_PKEY_CTRL_SM9_ID:
if (!p2 || !strlen((char *)p2) || strlen((char *)p2) > SM9_MAX_ID_LENGTH) {
return 0;
} else {
}
return 1;
case EVP_PKEY_CTRL_GET_SM9_ID:
*(const char **)p2 = dctx->id;
return 1;
default:
return -2;
}
return -2;
}
static int pkey_sm9_ctrl_str(EVP_PKEY_CTX *ctx, const char *type, const char *value)
{
if (!strcmp(type, "sign_scheme")) {
int nid = OBJ_txt2nid(value);
if (!sm9_check_sign_scheme(nid)) {
SM9err(SM9_F_PKEY_SM9_CTRL_STR, SM9_R_INVALID_SIGN_MD);
return 0;
}
return EVP_PKEY_CTX_set_sm9_sign_scheme(ctx, nid);
} else if (!strcmp(type, "encrypt_scheme")) {
int nid = OBJ_txt2nid(value);
if (!sm9_check_encrypt_scheme(nid)) {
SM9err(SM9_F_PKEY_SM9_CTRL_STR, SM9_R_INVALID_ENCRYPT_SCHEME);
return 0;
}
return EVP_PKEY_CTX_set_sm9_encrypt_scheme(ctx, nid);
} else if (!strcmp(type, "id")) {
return EVP_PKEY_CTX_set_sm9_id(ctx, value);
}
return -2;
}
const EVP_PKEY_METHOD sm9_pkey_meth = {
EVP_PKEY_SM9, /* pkey_id */
0, /* flags */
pkey_sm9_init, /* init */
pkey_sm9_copy, /* copy */
pkey_sm9_cleanup, /* cleanup */
NULL, /* paramgen_init */
NULL, /* paramgen */
NULL, /* keygen_init */
pkey_sm9_keygen, /* keygen */
NULL, /* sign_init */
pkey_sm9_sign, /* sign */
NULL, /* verify_init */
NULL, /* verify */
NULL, /* verify_recover_init */
NULL, /* verify_recover */
NULL, /* signctx_init */
NULL, /* signctx */
NULL, /* verifyctx_init */
NULL, /* verifyctx */
NULL, /* encrypt_init */
NULL, /* encrypt */
NULL, /* decrypt_init */
pkey_sm9_decrypt, /* decrypt */
NULL, /* derive_init */
pkey_sm9_derive, /* derive */
pkey_sm9_ctrl, /* ctrl */
pkey_sm9_ctrl_str, /* ctrl_str */
};

11
crypto/sm9/sm9_sign.c
View File

@@ -61,6 +61,17 @@ int SM9_signature_size(SM9PublicParameters *mpk)
return 105;
}
SM9Signature *SM9_do_sign(const unsigned char *dgst, int dgstlen, SM9_KEY *sm9)
{
return NULL;
}
int SM9_do_verify(const unsigned char *dgst, int dgstlen,
const SM9Signature *sig, SM9_KEY *sm9)
{
return -1;
}
int SM9_SignInit(EVP_MD_CTX *ctx, const EVP_MD *md, ENGINE *eng)
{
unsigned char prefix[1] = {0x02};

24
include/openssl/paillier.h
View File

@@ -59,6 +59,9 @@
#include <openssl/bn.h>
#include <openssl/asn1.h>
#define PAILLIER_MIN_KEY_BITS 2048
#ifdef __cplusplus
extern "C" {
#endif
@@ -72,7 +75,7 @@ void PAILLIER_free(PAILLIER *key);
int PAILLIER_size(const PAILLIER *key);
int PAILLIER_security_bits(const PAILLIER *key);
int PAILLIER_generate_key(PAILLIER *key, int bits);
int PAILLIER_generate_key(PAILLIER *key, int bits/* as RSA N */);
int PAILLIER_check_key(PAILLIER *key);
int PAILLIER_encrypt(BIGNUM *out, const BIGNUM *in, PAILLIER *key);
int PAILLIER_decrypt(BIGNUM *out, const BIGNUM *in, PAILLIER *key);
@@ -84,6 +87,19 @@ int PAILLIER_up_ref(PAILLIER *key);
DECLARE_ASN1_ENCODE_FUNCTIONS_const(PAILLIER, PaillierPrivateKey)
DECLARE_ASN1_ENCODE_FUNCTIONS_const(PAILLIER, PaillierPublicKey)
# define EVP_PKEY_CTRL_PAILLIER_KEYGEN_BITS (EVP_PKEY_ALG_CTRL + 1)
# define EVP_PKEY_CTX_set_paillier_keygen_bits(ctx, nbits) \
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_PAILLIER, \
EVP_PKEY_OP_KEYGEN, \
EVP_PKEY_CTRL_PAILLIER_KEYGEN_BITS, nbits, NULL)
# define EVP_PKEY_CTX_get_paillier_keygen_bits(ctx) \
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_PAILLIER, \
EVP_PKEY_OP_KEYGEN, \
EVP_PKEY_CTRL_PAILLIER_KEYGEN_BITS, -2, NULL)
/* BEGIN ERROR CODES */
/*
* The following lines are auto generated by the script mkerr.pl. Any changes
@@ -106,16 +122,22 @@ int ERR_load_PAILLIER_strings(void);
# define PAILLIER_F_PAILLIER_PRIV_DECODE 111
# define PAILLIER_F_PAILLIER_PRIV_ENCODE 112
# define PAILLIER_F_PAILLIER_PUB_DECODE 107
# define PAILLIER_F_PKEY_PAILLIER_CTRL 113
# define PAILLIER_F_PKEY_PAILLIER_CTRL_STR 114
# define PAILLIER_F_PKEY_PAILLIER_DECRYPT 108
# define PAILLIER_F_PKEY_PAILLIER_ENCRYPT 109
# define PAILLIER_F_PKEY_PAILLIER_INIT 115
# define PAILLIER_F_PKEY_PAILLIER_KEYGEN 116
/* Reason codes. */
# define PAILLIER_R_BUFFER_TOO_SMALL 104
# define PAILLIER_R_DECODE_ERROR 105
# define PAILLIER_R_GENERATE_PRIME_FAILED 100
# define PAILLIER_R_INVALID_PLAINTEXT 101
# define PAILLIER_R_KEY_SIZE_TOO_SMALL 106
# define PAILLIER_R_MALLOC_FAILED 102
# define PAILLIER_R_NOT_IMPLEMENTED 103
# define PAILLIER_R_VALUE_MISSING 107
# ifdef __cplusplus
}

118
include/openssl/skf.h
View File

@@ -155,44 +155,56 @@ typedef struct Struct_FILEATTRIBUTE {
} FILEATTRIBUTE, *PFILEATTRIBUTE;
#pragma pack()
/* 7.1.2 */
ULONG DEVAPI SKF_WaitForDevEvent(
LPSTR szDevName,
ULONG *pulDevNameLen,
ULONG *pulEvent);
/* 7.1.3 */
ULONG DEVAPI SKF_CancelWaitForDevEvent(
void);
ULONG DEVAPI SKF_EnumDev(BOOL bPresent,
/* 7.1.4 */
ULONG DEVAPI SKF_EnumDev(
BOOL bPresent,
LPSTR szNameList,
ULONG *pulSize);
/* 7.1.5 */
ULONG DEVAPI SKF_ConnectDev(
LPSTR szName,
DEVHANDLE *phDev);
/* 7.1.6 */
ULONG DEVAPI SKF_DisConnectDev(
DEVHANDLE hDev);
/* 7.1.7 */
ULONG DEVAPI SKF_GetDevState(
LPSTR szDevName,
ULONG *pulDevState);
/* 7.1.8 */
ULONG DEVAPI SKF_SetLabel(
DEVHANDLE hDev,
LPSTR szLabel);
/* 7.1.9 */
ULONG DEVAPI SKF_GetDevInfo(
DEVHANDLE hDev,
DEVINFO *pDevInfo);
/* 7.1.10 */
ULONG DEVAPI SKF_LockDev(
DEVHANDLE hDev,
ULONG ulTimeOut);
/* 7.1.11 */
ULONG DEVAPI SKF_UnlockDev(
DEVHANDLE hDev);
/* 7.1.12 */
ULONG DEVAPI SKF_Transmit(
DEVHANDLE hDev,
BYTE *pbCommand,
@@ -200,16 +212,19 @@ ULONG DEVAPI SKF_Transmit(
BYTE *pbData,
ULONG *pulDataLen);
/* 7.2.2 */
ULONG DEVAPI SKF_ChangeDevAuthKey(
DEVHANDLE hDev,
BYTE *pbKeyValue,
ULONG ulKeyLen);
/* 7.2.3 */
ULONG DEVAPI SKF_DevAuth(
DEVHANDLE hDev,
BYTE *pbAuthData,
ULONG ulLen);
/* 7.2.4 */
ULONG DEVAPI SKF_ChangePIN(
HAPPLICATION hApplication,
ULONG ulPINType,
@@ -217,6 +232,7 @@ ULONG DEVAPI SKF_ChangePIN(
LPSTR szNewPin,
ULONG *pulRetryCount);
/* 7.2.5 */
LONG DEVAPI SKF_GetPINInfo(
HAPPLICATION hApplication,
ULONG ulPINType,
@@ -224,21 +240,25 @@ LONG DEVAPI SKF_GetPINInfo(
ULONG *pulRemainRetryCount,
BOOL *pbDefaultPin);
/* 7.2.6 */
ULONG DEVAPI SKF_VerifyPIN(
HAPPLICATION hApplication,
ULONG ulPINType,
LPSTR szPIN,
ULONG *pulRetryCount);
/* 7.2.7 */
ULONG DEVAPI SKF_UnblockPIN(
HAPPLICATION hApplication,
LPSTR szAdminPIN,
LPSTR szNewUserPIN,
ULONG *pulRetryCount);
/* 7.2.8 */
ULONG DEVAPI SKF_ClearSecureState(
HAPPLICATION hApplication);
/* 7.3.2 */
ULONG DEVAPI SKF_CreateApplication(
DEVHANDLE hDev,
LPSTR szAppName,
@@ -249,22 +269,28 @@ ULONG DEVAPI SKF_CreateApplication(
DWORD dwCreateFileRights,
HAPPLICATION *phApplication);
ULONG DEVAPI SKF_EnumApplication(DEVHANDLE hDev,
/* 7.3.3 */
ULONG DEVAPI SKF_EnumApplication(
DEVHANDLE hDev,
LPSTR szAppName,
ULONG *pulSize);
/* 7.3.4 */
ULONG DEVAPI SKF_DeleteApplication(
DEVHANDLE hDev,
LPSTR szAppName);
/* 7.3.5 */
ULONG DEVAPI SKF_OpenApplication(
DEVHANDLE hDev,
LPSTR szAppName,
HAPPLICATION *phApplication);
/* 7.3.6 */
ULONG DEVAPI SKF_CloseApplication(
HAPPLICATION hApplication);
/* 7.4.2 */
ULONG DEVAPI SKF_CreateFile(
HAPPLICATION hApplication,
LPSTR szFileName,
@@ -272,20 +298,24 @@ ULONG DEVAPI SKF_CreateFile(
ULONG ulReadRights,
ULONG ulWriteRights);
/* 7.4.3 */
ULONG DEVAPI SKF_DeleteFile(
HAPPLICATION hApplication,
LPSTR szFileName);
/* 7.4.4 */
ULONG DEVAPI SKF_EnumFiles(
HAPPLICATION hApplication,
LPSTR szFileList,
ULONG *pulSize);
/* 7.4.5 */
ULONG DEVAPI SKF_GetFileInfo(
HAPPLICATION hApplication,
LPSTR szFileName,
FILEATTRIBUTE *pFileInfo);
/* 7.4.6 */
ULONG DEVAPI SKF_ReadFile(
HAPPLICATION hApplication,
LPSTR szFileName,
@@ -294,6 +324,7 @@ ULONG DEVAPI SKF_ReadFile(
BYTE *pbOutData,
ULONG *pulOutLen);
/* 7.4.7 */
ULONG DEVAPI SKF_WriteFile(
HAPPLICATION hApplication,
LPSTR szFileName,
@@ -301,65 +332,71 @@ ULONG DEVAPI SKF_WriteFile(
BYTE *pbData,
ULONG ulSize);
/* 7.5.2 */
ULONG DEVAPI SKF_CreateContainer(
HAPPLICATION hApplication,
LPSTR szContainerName,
HCONTAINER *phContainer);
/* 7.5.3 */
ULONG DEVAPI SKF_DeleteContainer(
HAPPLICATION hApplication,
LPSTR szContainerName);
ULONG DEVAPI SKF_EnumContainer(
HAPPLICATION hApplication,
LPSTR szContainerName,
ULONG *pulSize);
/* 7.5.4 */
ULONG DEVAPI SKF_OpenContainer(
HAPPLICATION hApplication,
LPSTR szContainerName,
HCONTAINER *phContainer);
/* 7.5.5 */
ULONG DEVAPI SKF_CloseContainer(
HCONTAINER hContainer);
/* 7.5.6 */
ULONG DEVAPI SKF_EnumContainer(
HAPPLICATION hApplication,
LPSTR szContainerName,
ULONG *pulSize);
/* 7.5.7 */
ULONG DEVAPI SKF_GetContainerType(
HCONTAINER hContainer,
ULONG *pulContainerType);
/* 7.5.8 */
ULONG DEVAPI SKF_ImportCertificate(
HCONTAINER hContainer,
BOOL bExportSignKey,
BYTE *pbCert,
ULONG ulCertLen);
/* 7.5.9 */
ULONG DEVAPI SKF_ExportCertificate(
HCONTAINER hContainer,
BOOL bSignFlag,
BYTE *pbCert,
ULONG *pulCertLen);
ULONG DEVAPI SKF_ExportPublicKey(
HCONTAINER hContainer,
BOOL bSignFlag,
BYTE *pbBlob,
ULONG *pulBlobLen);
/* 7.6.2 */
ULONG DEVAPI SKF_GenRandom(
DEVHANDLE hDev,
BYTE *pbRandom,
ULONG ulRandomLen);
ULONG DEVAPI SKF_GenRSAKeyPair(
HCONTAINER hContainer,
ULONG ulBitsLen,
RSAPUBLICKEYBLOB *pBlob);
/* 7.6.3 */
ULONG DEVAPI SKF_GenExtRSAKey(
DEVHANDLE hDev,
ULONG ulBitsLen,
RSAPRIVATEKEYBLOB *pBlob);
/* 7.6.4 */
ULONG DEVAPI SKF_GenRSAKeyPair(
HCONTAINER hContainer,
ULONG ulBitsLen,
RSAPUBLICKEYBLOB *pBlob);
/* 7.6.5 */
ULONG DEVAPI SKF_ImportRSAKeyPair(
HCONTAINER hContainer,
ULONG ulSymAlgId,
@@ -368,6 +405,7 @@ ULONG DEVAPI SKF_ImportRSAKeyPair(
BYTE *pbEncryptedData,
ULONG ulEncryptedDataLen);
/* 7.6.6 */
ULONG DEVAPI SKF_RSASignData(
HCONTAINER hContainer,
BYTE *pbData,
@@ -375,6 +413,7 @@ ULONG DEVAPI SKF_RSASignData(
BYTE *pbSignature,
ULONG *pulSignLen);
/* 7.6.7 */
ULONG DEVAPI SKF_RSAVerify(
DEVHANDLE hDev,
RSAPUBLICKEYBLOB *pRSAPubKeyBlob,
@@ -383,6 +422,7 @@ ULONG DEVAPI SKF_RSAVerify(
BYTE *pbSignature,
ULONG ulSignLen);
/* 7.6.8 */
ULONG DEVAPI SKF_RSAExportSessionKey(
HCONTAINER hContainer,
ULONG ulAlgId,
@@ -391,6 +431,7 @@ ULONG DEVAPI SKF_RSAExportSessionKey(
ULONG *pulDataLen,
HANDLE *phSessionKey);
/* 7.6.9 */
ULONG DEVAPI SKF_ExtRSAPubKeyOperation(
DEVHANDLE hDev,
RSAPUBLICKEYBLOB *pRSAPubKeyBlob,
@@ -399,6 +440,7 @@ ULONG DEVAPI SKF_ExtRSAPubKeyOperation(
BYTE *pbOutput,
ULONG *pulOutputLen);
/* 7.6.10 */
ULONG DEVAPI SKF_ExtRSAPriKeyOperation(
DEVHANDLE hDev,
RSAPRIVATEKEYBLOB *pRSAPriKeyBlob,
@@ -407,28 +449,32 @@ ULONG DEVAPI SKF_ExtRSAPriKeyOperation(
BYTE *pbOutput,
ULONG *pulOutputLen);
/* 7.6.11 */
ULONG DEVAPI SKF_GenECCKeyPair(
HCONTAINER hContainer,
ULONG ulAlgId,
ECCPUBLICKEYBLOB *pBlob);
/* 7.6.12 */
ULONG DEVAPI SKF_ImportECCKeyPair(
HCONTAINER hContainer,
ENVELOPEDKEYBLOB *pEnvelopedKeyBlob);
/* 7.6.13 */
ULONG DEVAPI SKF_ECCSignData(
HCONTAINER hContainer,
BYTE *pbDigest,
ULONG ulDigestLen,
ECCSIGNATUREBLOB *pSignature);
/* Extension */
/* Extension */
ULONG DEVAPI SKF_ECCDecrypt(
HCONTAINER hContainer,
ECCCIPHERBLOB *pCipherBlob,
BYTE *pbPlainText,
ULONG *pulPlainTextLen);
/* 7.6.14 */
ULONG DEVAPI SKF_ECCVerify(
DEVHANDLE hDev,
ECCPUBLICKEYBLOB *pECCPubKeyBlob,
@@ -436,6 +482,7 @@ ULONG DEVAPI SKF_ECCVerify(
ULONG ulDataLen,
ECCSIGNATUREBLOB *pSignature);
/* 7.6.15 */
ULONG DEVAPI SKF_ECCExportSessionKey(
HCONTAINER hContainer,
ULONG ulAlgId,
@@ -443,6 +490,7 @@ ULONG DEVAPI SKF_ECCExportSessionKey(
ECCCIPHERBLOB *pData,
HANDLE *phSessionKey);
/* 7.6.16 */
ULONG DEVAPI SKF_ExtECCEncrypt(
DEVHANDLE hDev,
ECCPUBLICKEYBLOB *pECCPubKeyBlob,
@@ -450,6 +498,7 @@ ULONG DEVAPI SKF_ExtECCEncrypt(
ULONG ulPlainTextLen,
ECCCIPHERBLOB *pCipherText);
/* 7.6.17 */
ULONG DEVAPI SKF_ExtECCDecrypt(
DEVHANDLE hDev,
ECCPRIVATEKEYBLOB *pECCPriKeyBlob,
@@ -457,6 +506,7 @@ ULONG DEVAPI SKF_ExtECCDecrypt(
BYTE *pbPlainText,
ULONG *pulPlainTextLen);
/* 7.6.18 */
ULONG DEVAPI SKF_ExtECCSign(
DEVHANDLE hDev,
ECCPRIVATEKEYBLOB *pECCPriKeyBlob,
@@ -464,6 +514,7 @@ ULONG DEVAPI SKF_ExtECCSign(
ULONG ulDataLen,
ECCSIGNATUREBLOB *pSignature);
/* 7.6.19 */
ULONG DEVAPI SKF_ExtECCVerify(
DEVHANDLE hDev,
ECCPUBLICKEYBLOB *pECCPubKeyBlob,
@@ -471,6 +522,7 @@ ULONG DEVAPI SKF_ExtECCVerify(
ULONG ulDataLen,
ECCSIGNATUREBLOB *pSignature);
/* 7.6.20 */
ULONG DEVAPI SKF_GenerateAgreementDataWithECC(
HCONTAINER hContainer,
ULONG ulAlgId,
@@ -479,6 +531,7 @@ ULONG DEVAPI SKF_GenerateAgreementDataWithECC(
ULONG ulIDLen,
HANDLE *phAgreementHandle);
/* 7.6.21 */
ULONG DEVAPI SKF_GenerateAgreementDataAndKeyWithECC(
HANDLE hContainer,
ULONG ulAlgId,
@@ -491,6 +544,7 @@ ULONG DEVAPI SKF_GenerateAgreementDataAndKeyWithECC(
ULONG ulSponsorIDLen,
HANDLE *phKeyHandle);
/* 7.6.22 */
ULONG DEVAPI SKF_GenerateKeyWithECC(
HANDLE hAgreementHandle,
ECCPUBLICKEYBLOB *pECCPubKeyBlob,
@@ -499,6 +553,14 @@ ULONG DEVAPI SKF_GenerateKeyWithECC(
ULONG ulIDLen,
HANDLE *phKeyHandle);
/* 7.6.23 */
ULONG DEVAPI SKF_ExportPublicKey(
HCONTAINER hContainer,
BOOL bSignFlag,
BYTE *pbBlob,
ULONG *pulBlobLen);
/* 7.6.24 */
ULONG DEVAPI SKF_ImportSessionKey(
HCONTAINER hContainer,
ULONG ulAlgId,
@@ -506,16 +568,19 @@ ULONG DEVAPI SKF_ImportSessionKey(
ULONG ulWrapedLen,
HANDLE *phKey);
/* 7.6.25 */
ULONG DEVAPI SKF_SetSymmKey(
DEVHANDLE hDev,
BYTE *pbKey,
ULONG ulAlgID,
HANDLE *phKey);
/* 7.6.26 */
ULONG DEVAPI SKF_EncryptInit(
HANDLE hKey,
BLOCKCIPHERPARAM EncryptParam);
/* 7.6.27 */
ULONG DEVAPI SKF_Encrypt(
HANDLE hKey,
BYTE *pbData,
@@ -523,6 +588,7 @@ ULONG DEVAPI SKF_Encrypt(
BYTE *pbEncryptedData,
ULONG *pulEncryptedLen);
/* 7.6.28 */
ULONG DEVAPI SKF_EncryptUpdate(
HANDLE hKey,
BYTE *pbData,
@@ -530,15 +596,18 @@ ULONG DEVAPI SKF_EncryptUpdate(
BYTE *pbEncryptedData,
ULONG *pulEncryptedLen);
/* 7.6.29 */
ULONG DEVAPI SKF_EncryptFinal(
HANDLE hKey,
BYTE *pbEncryptedData,
ULONG *pulEncryptedDataLen);
/* 7.6.30 */
ULONG DEVAPI SKF_DecryptInit(
HANDLE hKey,
BLOCKCIPHERPARAM DecryptParam);
/* 7.6.31 */
ULONG DEVAPI SKF_Decrypt(
HANDLE hKey,
BYTE *pbEncryptedData,
@@ -546,6 +615,7 @@ ULONG DEVAPI SKF_Decrypt(
BYTE *pbData,
ULONG *pulDataLen);
/* 7.6.32 */
ULONG DEVAPI SKF_DecryptUpdate(
HANDLE hKey,
BYTE *pbEncryptedData,
@@ -553,11 +623,13 @@ ULONG DEVAPI SKF_DecryptUpdate(
BYTE *pbData,
ULONG *pulDataLen);
/* 7.6.33 */
ULONG DEVAPI SKF_DecryptFinal(
HANDLE hKey,
BYTE *pbDecryptedData,
ULONG *pulDecryptedDataLen);
/* 7.6.34 */
ULONG DEVAPI SKF_DigestInit(
DEVHANDLE hDev,
ULONG ulAlgID,
@@ -566,6 +638,7 @@ ULONG DEVAPI SKF_DigestInit(
ULONG ulIDLen,
HANDLE *phHash);
/* 7.6.35 */
ULONG DEVAPI SKF_Digest(
HANDLE hHash,
BYTE *pbData,
@@ -573,21 +646,25 @@ ULONG DEVAPI SKF_Digest(
BYTE *pbHashData,
ULONG *pulHashLen);
/* 7.6.36 */
ULONG DEVAPI SKF_DigestUpdate(
HANDLE hHash,
BYTE *pbData,
ULONG ulDataLen);
/* 7.6.37 */
ULONG DEVAPI SKF_DigestFinal(
HANDLE hHash,
BYTE *pHashData,
ULONG *pulHashLen);
/* 7.6.38 */
ULONG DEVAPI SKF_MacInit(
HANDLE hKey,
BLOCKCIPHERPARAM *pMacParam,
HANDLE *phMac);
/* 7.6.39 */
ULONG DEVAPI SKF_Mac(
HANDLE hMac,
BYTE *pbData,
@@ -595,16 +672,19 @@ ULONG DEVAPI SKF_Mac(
BYTE *pbMacData,
ULONG *pulMacLen);
/* 7.6.40 */
ULONG DEVAPI SKF_MacUpdate(
HANDLE hMac,
BYTE *pbData,
ULONG ulDataLen);
/* 7.6.41 */
ULONG DEVAPI SKF_MacFinal(
HANDLE hMac,
BYTE *pbMacData,
ULONG *pulMacDataLen);
/* 7.6.42 */
ULONG DEVAPI SKF_CloseHandle(
HANDLE hHandle);

212
include/openssl/sm9.h
View File

@@ -106,6 +106,10 @@ int SM9PublicKey_get_gmtls_encoded(SM9PublicParameters *mpk,
int SM9_signature_size(SM9PublicParameters *mpk);
SM9Signature *SM9_do_sign(const unsigned char *dgst, int dgstlen, SM9_KEY *sm9);
int SM9_do_verify(const unsigned char *dgst, int dgstlen,
const SM9Signature *sig, SM9_KEY *sm9);
int SM9_sign(int type,
const unsigned char *data, size_t datalen,
unsigned char *sig, size_t *siglen,
@@ -174,18 +178,15 @@ int SM9_compute_share_key_B(int type,
#ifndef OPENSSL_NO_STDIO
SM9MasterSecret *d2i_SM9MasterSecret_fp(FILE *fp, SM9MasterSecret **pp);
SM9PublicParameters *d2i_SM9PublicParameters_fp(FILE *fp, SM9PublicParameters **pp);
SM9PrivateKey *d2i_SM9PrivateKey_fp(FILE *fp, SM9PrivateKey **pp);
SM9PublicKey *d2i_SM9PublicKey_fp(FILE *fp, SM9PublicKey **pp);
SM9Signature *d2i_SM9Signature_fp(FILE *fp, SM9Signature **pp);
SM9Ciphertext *d2i_SM9Ciphertext_fp(FILE *fp, SM9Ciphertext **pp);
int i2d_SM9MasterSecret_fp(FILE *fp, SM9MasterSecret *a);
int i2d_PublicParameters_fp(FILE *fp, SM9PublicParameters *a);
int i2d_SM9PublicParameters_fp(FILE *fp, SM9PublicParameters *a);
int i2d_SM9PrivateKey_fp(FILE *fp, SM9PrivateKey *a);
int i2d_SM9PublicKey_fp(FILE *fp, SM9PublicKey *a);
int i2d_SM9Signature_fp(FILE *fp, SM9Signature *a);
int i2d_SM9Ciphertext_fp(FILE *fp, SM9Ciphertext *a);
#endif
@@ -209,7 +210,72 @@ DECLARE_ASN1_FUNCTIONS(SM9Ciphertext)
#define SM9PublicKey_new() SM9_KEY_new()
#define SM9PublicKey_free(a) SM9_KEY_free(a)
# define EVP_PKEY_CTRL_SM9_PAIRING (EVP_PKEY_ALG_CTRL + 1)
# define EVP_PKEY_CTRL_SM9_SCHEME (EVP_PKEY_ALG_CTRL + 2)
# define EVP_PKEY_CTRL_SM9_HASH1 (EVP_PKEY_ALG_CTRL + 3)
# define EVP_PKEY_CTRL_SM9_SIGN_SCHEME (EVP_PKEY_ALG_CTRL + 4)
# define EVP_PKEY_CTRL_SM9_ENCRYPT_SCHEME (EVP_PKEY_ALG_CTRL + 5)
# define EVP_PKEY_CTRL_SM9_ID (EVP_PKEY_ALG_CTRL + 6)
# define EVP_PKEY_CTRL_GET_SM9_ID (EVP_PKEY_ALG_CTRL + 7)
# define EVP_PKEY_CTX_set_sm9_pairing(ctx, nid) \
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9_MASTER, \
EVP_PKEY_OP_KEYGEN, \
EVP_PKEY_CTRL_SM9_PAIRING, nid, NULL)
# define EVP_PKEY_CTX_get_sm9_pairing(ctx) \
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9_MASTER, \
EVP_PKEY_OP_KEYGEN, \
EVP_PKEY_CTRL_SM9_PAIRING, -2, NULL)
# define EVP_PKEY_CTX_set_sm9_scheme(ctx, nid) \
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9_MASTER, \
EVP_PKEY_OP_KEYGEN, \
EVP_PKEY_CTRL_SM9_SCHEME, nid, NULL)
# define EVP_PKEY_CTX_get_sm9_scheme(ctx) \
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9_MASTER, \
EVP_PKEY_OP_KEYGEN, \
EVP_PKEY_CTRL_SM9_SCHEME, -2, NULL)
# define EVP_PKEY_CTX_set_sm9_hash1(ctx, nid) \
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9_MASTER, \
EVP_PKEY_OP_KEYGEN, EVP_PKEY_CTRL_SM9_HASH1, nid, NULL)
# define EVP_PKEY_CTX_get_sm9_hash1(ctx) \
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9_MASTER, \
EVP_PKEY_OP_KEYGEN, EVP_PKEY_CTRL_SM9_HASH1, -2, NULL)
# define EVP_PKEY_CTX_set_sm9_encrypt_scheme(ctx, nid) \
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9_MASTER, \
EVP_PKEY_OP_ENCRYPT, \
EVP_PKEY_CTRL_SM9_ENCRYPT_SCHEME, nid, NULL)
# define EVP_PKEY_CTX_set_sm9_decrypt_scheme(ctx, nid) \
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9, \
EVP_PKEY_OP_DECRYPT|EVP_PKEY_OP_ENCRYPT, \
EVP_PKEY_CTRL_SM9_ENCRYPT_SCHEME, nid, NULL)
# define EVP_PKEY_CTX_set_sm9_sign_scheme(ctx, nid) \
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9, \
EVP_PKEY_OP_SIGN|EVP_PKEY_OP_SIGNCTX| \
EVP_PKEY_OP_VERIFY|EVP_PKEY_OP_VERIFYCTX, \
EVP_PKEY_CTRL_SM9_SIGN_SCHEME, nid, NULL)
# define EVP_PKEY_CTX_set_sm9_verify_scheme(ctx, nid) \
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9_MASTER, \
EVP_PKEY_OP_VERIFY|EVP_PKEY_OP_VERIFYCTX, \
EVP_PKEY_CTRL_SM9_SIGN_SCHEME, nid, NULL)
# define EVP_PKEY_CTX_set_sm9_id(ctx, id) \
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9_MASTER, \
EVP_PKEY_OP_KEYGEN, \
EVP_PKEY_CTRL_SM9_ID, 0, (void *)id)
# define EVP_PKEY_CTX_get_sm9_id(ctx, pid) \
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9_MASTER, \
EVP_PKEY_OP_KEYGEN, \
EVP_PKEY_CTRL_GET_SM9_ID, 0, (void *)pid)
/* BEGIN ERROR CODES */
/*
@@ -222,77 +288,81 @@ int ERR_load_SM9_strings(void);
/* Error codes for the SM9 functions. */
/* Function codes. */
# define SM9_F_OLD_SM9_MASTER_DECODE 124
# define SM9_F_OLD_SM9_PRIV_DECODE 125
# define SM9_F_SM9CIPHERTEXT_CHECK 100
# define SM9_F_SM9ENCPARAMETERS_DECRYPT 101
# define SM9_F_SM9ENCPARAMETERS_ENCRYPT 102
# define SM9_F_SM9ENCPARAMETERS_GENERATE_MAC 103
# define SM9_F_SM9ENCPARAMETERS_GET_KEY_LENGTH 104
# define SM9_F_SM9PUBLICPARAMETERS_GET_POINT_SIZE 105
# define SM9_F_SM9_COMPUTE_SHARE_KEY_A 122
# define SM9_F_SM9_COMPUTE_SHARE_KEY_B 123
# define SM9_F_SM9_DECRYPT 106
# define SM9_F_SM9_DO_DECRYPT 107
# define SM9_F_SM9_DO_ENCRYPT 108
# define SM9_F_SM9_ENCRYPT 109
# define SM9_F_SM9_EXTRACT_PRIVATE_KEY 110
# define SM9_F_SM9_EXTRACT_PUBLIC_PARAMETERS 111
# define SM9_F_SM9_GENERATE_KEY_EXCHANGE 121
# define SM9_F_SM9_GENERATE_MASTER_SECRET 112
# define SM9_F_SM9_KEY_NEW 132
# define SM9_F_OLD_SM9_MASTER_DECODE 100
# define SM9_F_OLD_SM9_PRIV_DECODE 101
# define SM9_F_PKEY_SM9_COPY 102
# define SM9_F_PKEY_SM9_CTRL 103
# define SM9_F_PKEY_SM9_CTRL_STR 104
# define SM9_F_PKEY_SM9_DECRYPT 105
# define SM9_F_PKEY_SM9_ENCRYPT 106
# define SM9_F_PKEY_SM9_INIT 107
# define SM9_F_PKEY_SM9_KEYGEN 108
# define SM9_F_PKEY_SM9_MASTER_COPY 109
# define SM9_F_PKEY_SM9_MASTER_CTRL 110
# define SM9_F_PKEY_SM9_MASTER_CTRL_STR 111
# define SM9_F_PKEY_SM9_MASTER_ENCRYPT 112
# define SM9_F_PKEY_SM9_MASTER_INIT 113
# define SM9_F_PKEY_SM9_MASTER_KEYGEN 114
# define SM9_F_PKEY_SM9_MASTER_VERIFY 115
# define SM9_F_PKEY_SM9_SIGN 116
# define SM9_F_PKEY_SM9_VERIFY 117
# define SM9_F_SM9_COMPUTE_SHARE_KEY_A 118
# define SM9_F_SM9_COMPUTE_SHARE_KEY_B 119
# define SM9_F_SM9_DECRYPT 120
# define SM9_F_SM9_ENCRYPT 121
# define SM9_F_SM9_EXTRACT_PUBLIC_PARAMETERS 122
# define SM9_F_SM9_GENERATE_KEY_EXCHANGE 123
# define SM9_F_SM9_GENERATE_MASTER_SECRET 124
# define SM9_F_SM9_KEY_NEW 125
# define SM9_F_SM9_MASTER_DECODE 126
# define SM9_F_SM9_MASTER_ENCODE 127
# define SM9_F_SM9_MASTER_KEY_EXTRACT_KEY 134
# define SM9_F_SM9_MASTER_KEY_NEW 133
# define SM9_F_SM9_PARAMS_DECODE 128
# define SM9_F_SM9_PRIV_DECODE 129
# define SM9_F_SM9_PRIV_ENCODE 130
# define SM9_F_SM9_PUB_DECODE 131
# define SM9_F_SM9_SIGN 119
# define SM9_F_SM9_SIGNFINAL 115
# define SM9_F_SM9_SIGNINIT 116
# define SM9_F_SM9_UNWRAP_KEY 113
# define SM9_F_SM9_VERIFY 120
# define SM9_F_SM9_VERIFYFINAL 117
# define SM9_F_SM9_VERIFYINIT 118
# define SM9_F_SM9_WRAP_KEY 114
# define SM9_F_SM9_MASTER_KEY_EXTRACT_KEY 128
# define SM9_F_SM9_MASTER_KEY_NEW 129
# define SM9_F_SM9_PARAMS_DECODE 130
# define SM9_F_SM9_PRIV_DECODE 131
# define SM9_F_SM9_PRIV_ENCODE 132
# define SM9_F_SM9_PUB_DECODE 133
# define SM9_F_SM9_SIGN 134
# define SM9_F_SM9_SIGNFINAL 135
# define SM9_F_SM9_SIGNINIT 136
# define SM9_F_SM9_UNWRAP_KEY 137
# define SM9_F_SM9_VERIFY 138
# define SM9_F_SM9_VERIFYFINAL 139
# define SM9_F_SM9_VERIFYINIT 140
# define SM9_F_SM9_WRAP_KEY 141
/* Reason codes. */
# define SM9_R_BUFFER_TOO_SMALL 100
# define SM9_R_DECODE_ERROR 132
# define SM9_R_DIGEST_FAILURE 119
# define SM9_R_EC_LIB 101
# define SM9_R_EXTENSION_FIELD_ERROR 120
# define SM9_R_GENERATE_MAC_FAILURE 102
# define SM9_R_HASH_FAILURE 103
# define SM9_R_INVALID_CIPHERTEXT 104
# define SM9_R_INVALID_DIGEST_TYPE 130
# define SM9_R_INVALID_ENCPARAMETERS 105
# define SM9_R_INVALID_HASH1 106
# define SM9_R_INVALID_HASH2_DIGEST 126
# define SM9_R_INVALID_ID 107
# define SM9_R_INVALID_ID_LENGTH 108
# define SM9_R_INVALID_INPUT 109
# define SM9_R_INVALID_KEM_KEY_LENGTH 128
# define SM9_R_INVALID_KEY_AGREEMENT_CHECKSUM 131
# define SM9_R_INVALID_KEY_LENGTH 110
# define SM9_R_INVALID_MD 111
# define SM9_R_INVALID_PAIRING_TYPE 112
# define SM9_R_INVALID_PARAMETER 113
# define SM9_R_INVALID_POINTPPUB 121
# define SM9_R_INVALID_PRIVATE_POINT 122
# define SM9_R_INVALID_SCHEME 114
# define SM9_R_INVALID_SIGNATURE 123
# define SM9_R_INVALID_SIGNATURE_FORMAT 127
# define SM9_R_INVALID_TYPE1CURVE 115
# define SM9_R_KDF_FAILURE 116
# define SM9_R_NO_MASTER_SECRET 133
# define SM9_R_PAIRING_ERROR 124
# define SM9_R_RATE_PAIRING_ERROR 129
# define SM9_R_TWIST_CURVE_ERROR 117
# define SM9_R_VERIFY_FAILURE 125
# define SM9_R_ZERO_ID 118
# define SM9_R_DECODE_ERROR 100
# define SM9_R_DIGEST_FAILURE 101
# define SM9_R_EC_LIB 102
# define SM9_R_EXTENSION_FIELD_ERROR 103
# define SM9_R_IDENTITY_REQUIRED 104
# define SM9_R_ID_OR_MASTER_SECRET_REQUIRED 105
# define SM9_R_INVALID_DIGEST_TYPE 106
# define SM9_R_INVALID_ENCRYPT_SCHEME 107
# define SM9_R_INVALID_HASH1 108
# define SM9_R_INVALID_HASH2_DIGEST 109
# define SM9_R_INVALID_ID 110
# define SM9_R_INVALID_KEM_KEY_LENGTH 111
# define SM9_R_INVALID_KEY_AGREEMENT_CHECKSUM 112
# define SM9_R_INVALID_KEY_USAGE 113
# define SM9_R_INVALID_PAIRING 114
# define SM9_R_INVALID_PAIRING_TYPE 115
# define SM9_R_INVALID_POINTPPUB 116
# define SM9_R_INVALID_PRIVATE_POINT 117
# define SM9_R_INVALID_SCHEME 118
# define SM9_R_INVALID_SIGNATURE 119
# define SM9_R_INVALID_SIGNATURE_FORMAT 120
# define SM9_R_INVALID_SIGN_MD 121
# define SM9_R_INVALID_SIGN_SCHEME 122
# define SM9_R_INVALID_SM9_SCHEME 123
# define SM9_R_NO_MASTER_SECRET 124
# define SM9_R_PAIRING_ERROR 125
# define SM9_R_RATE_PAIRING_ERROR 126
# define SM9_R_SIGNER_ID_REQUIRED 127
# define SM9_R_TWIST_CURVE_ERROR 128
# define SM9_R_VERIFY_FAILURE 129
# define SM9_R_ZERO_ID 130
# ifdef __cplusplus
}

4990
util/libcrypto.num
View File

File diff suppressed because it is too large Load Diff