abc/GmSSL
1
0
Fork 0
mirror of https://github.com/guanzhi/GmSSL.git synced 2026-08-10 07:53:57 +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
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};