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

first step of v2 final release

Browse Source
This commit is contained in:
Zhi Guan
2017-11-05 21:00:36 +08:00
parent 480b9e8d88
commit 27bde477a5
395 changed files with 26341 additions and 31364 deletions
Download Patch File Download Diff File Expand all files Collapse all files

171
crypto/gmapi/gmapi_err.c
View File

@@ -19,6 +19,16 @@
# define ERR_REASON(reason) ERR_PACK(ERR_LIB_GMAPI,0,reason)
static ERR_STRING_DATA GMAPI_str_functs[] = {
{ERR_FUNC(GMAPI_F_D2I_ECCCIPHER), "d2i_ECCCipher"},
{ERR_FUNC(GMAPI_F_D2I_ECCCIPHERBLOB), "d2i_ECCCIPHERBLOB"},
{ERR_FUNC(GMAPI_F_D2I_ECCCIPHERBLOB_BIO), "d2i_ECCCIPHERBLOB_bio"},
{ERR_FUNC(GMAPI_F_D2I_ECCCIPHERBLOB_FP), "d2i_ECCCIPHERBLOB_fp"},
{ERR_FUNC(GMAPI_F_D2I_ECCSIGNATURE), "d2i_ECCSignature"},
{ERR_FUNC(GMAPI_F_D2I_ECCSIGNATUREBLOB), "d2i_ECCSIGNATUREBLOB"},
{ERR_FUNC(GMAPI_F_D2I_ECCSIGNATUREBLOB_BIO), "d2i_ECCSIGNATUREBLOB_bio"},
{ERR_FUNC(GMAPI_F_D2I_ECCSIGNATUREBLOB_FP), "d2i_ECCSIGNATUREBLOB_fp"},
{ERR_FUNC(GMAPI_F_ECCPRIVATEKEYBLOB_SET_PRIVATE_KEY),
"ECCPRIVATEKEYBLOB_set_private_key"},
{ERR_FUNC(GMAPI_F_ECDSA_SIG_GET_ECCSIGNATURE),
"ECDSA_SIG_get_ECCSignature"},
{ERR_FUNC(GMAPI_F_ECDSA_SIG_GET_ECCSIGNATUREBLOB),
@@ -31,6 +41,18 @@ static ERR_STRING_DATA GMAPI_str_functs[] = {
"ECDSA_SIG_set_ECCSignature"},
{ERR_FUNC(GMAPI_F_ECDSA_SIG_SET_ECCSIGNATUREBLOB),
"ECDSA_SIG_set_ECCSIGNATUREBLOB"},
{ERR_FUNC(GMAPI_F_ECIES_CIPHERTEXT_VALUE_GET_ECCCIPHER),
"ECIES_CIPHERTEXT_VALUE_get_ECCCipher"},
{ERR_FUNC(GMAPI_F_ECIES_CIPHERTEXT_VALUE_GET_ECCCIPHERBLOB),
"ECIES_CIPHERTEXT_VALUE_get_ECCCIPHERBLOB"},
{ERR_FUNC(GMAPI_F_ECIES_CIPHERTEXT_VALUE_NEW_FROM_ECCCIPHER),
"ECIES_CIPHERTEXT_VALUE_new_from_ECCCipher"},
{ERR_FUNC(GMAPI_F_ECIES_CIPHERTEXT_VALUE_NEW_FROM_ECCCIPHERBLOB),
"ECIES_CIPHERTEXT_VALUE_new_from_ECCCIPHERBLOB"},
{ERR_FUNC(GMAPI_F_ECIES_CIPHERTEXT_VALUE_SET_ECCCIPHER),
"ECIES_CIPHERTEXT_VALUE_set_ECCCipher"},
{ERR_FUNC(GMAPI_F_ECIES_CIPHERTEXT_VALUE_SET_ECCCIPHERBLOB),
"ECIES_CIPHERTEXT_VALUE_set_ECCCIPHERBLOB"},
{ERR_FUNC(GMAPI_F_EC_KEY_GET_ECCPRIVATEKEYBLOB),
"EC_KEY_get_ECCPRIVATEKEYBLOB"},
{ERR_FUNC(GMAPI_F_EC_KEY_GET_ECCPUBLICKEYBLOB),
@@ -55,6 +77,18 @@ static ERR_STRING_DATA GMAPI_str_functs[] = {
"EC_KEY_set_ECCrefPrivateKey"},
{ERR_FUNC(GMAPI_F_EC_KEY_SET_ECCREFPUBLICKEY),
"EC_KEY_set_ECCrefPublicKey"},
{ERR_FUNC(GMAPI_F_EVP_CIPHER_CTX_GET_SGD), "EVP_CIPHER_CTX_get_sgd"},
{ERR_FUNC(GMAPI_F_EVP_CIPHER_GET_SGD), "EVP_CIPHER_get_sgd"},
{ERR_FUNC(GMAPI_F_EVP_MD_GET_SGD), "EVP_MD_get_sgd"},
{ERR_FUNC(GMAPI_F_EVP_PKEY_GET_SGD), "EVP_PKEY_get_sgd"},
{ERR_FUNC(GMAPI_F_I2D_ECCCIPHER), "i2d_ECCCipher"},
{ERR_FUNC(GMAPI_F_I2D_ECCCIPHERBLOB), "i2d_ECCCIPHERBLOB"},
{ERR_FUNC(GMAPI_F_I2D_ECCCIPHERBLOB_BIO), "i2d_ECCCIPHERBLOB_bio"},
{ERR_FUNC(GMAPI_F_I2D_ECCCIPHERBLOB_FP), "i2d_ECCCIPHERBLOB_fp"},
{ERR_FUNC(GMAPI_F_I2D_ECCSIGNATURE), "i2d_ECCSignature"},
{ERR_FUNC(GMAPI_F_I2D_ECCSIGNATUREBLOB), "i2d_ECCSIGNATUREBLOB"},
{ERR_FUNC(GMAPI_F_I2D_ECCSIGNATUREBLOB_BIO), "i2d_ECCSIGNATUREBLOB_bio"},
{ERR_FUNC(GMAPI_F_I2D_ECCSIGNATUREBLOB_FP), "i2d_ECCSIGNATUREBLOB_fp"},
{ERR_FUNC(GMAPI_F_RSA_GET_RSAPRIVATEKEYBLOB),
"RSA_get_RSAPRIVATEKEYBLOB"},
{ERR_FUNC(GMAPI_F_RSA_GET_RSAPUBLICKEYBLOB), "RSA_get_RSAPUBLICKEYBLOB"},
@@ -73,72 +107,6 @@ static ERR_STRING_DATA GMAPI_str_functs[] = {
{ERR_FUNC(GMAPI_F_RSA_SET_RSAPUBLICKEYBLOB), "RSA_set_RSAPUBLICKEYBLOB"},
{ERR_FUNC(GMAPI_F_RSA_SET_RSAREFPRIVATEKEY), "RSA_set_RSArefPrivateKey"},
{ERR_FUNC(GMAPI_F_RSA_SET_RSAREFPUBLICKEY), "RSA_set_RSArefPublicKey"},
{ERR_FUNC(GMAPI_F_SAF_BASE64_CREATEBASE64OBJ),
"SAF_Base64_CreateBase64Obj"},
{ERR_FUNC(GMAPI_F_SAF_BASE64_DECODE), "SAF_Base64_Decode"},
{ERR_FUNC(GMAPI_F_SAF_BASE64_DECODEFINAL), "SAF_Base64_DecodeFinal"},
{ERR_FUNC(GMAPI_F_SAF_BASE64_DECODEUPDATE), "SAF_Base64_DecodeUpdate"},
{ERR_FUNC(GMAPI_F_SAF_BASE64_ENCODE), "SAF_Base64_Encode"},
{ERR_FUNC(GMAPI_F_SAF_BASE64_ENCODEFINAL), "SAF_Base64_EncodeFinal"},
{ERR_FUNC(GMAPI_F_SAF_BASE64_ENCODEUPDATE), "SAF_Base64_EncodeUpdate"},
{ERR_FUNC(GMAPI_F_SAF_CREATESYMMKEYOBJ), "SAF_CreateSymmKeyObj"},
{ERR_FUNC(GMAPI_F_SAF_ECCPUBLICKEYENC), "SAF_EccPublicKeyEnc"},
{ERR_FUNC(GMAPI_F_SAF_ECCPUBLICKEYENCBYCERT),
"SAF_EccPublicKeyEncByCert"},
{ERR_FUNC(GMAPI_F_SAF_ECCSIGN), "SAF_EccSign"},
{ERR_FUNC(GMAPI_F_SAF_ECCVERIFYSIGN), "SAF_EccVerifySign"},
{ERR_FUNC(GMAPI_F_SAF_ECCVERIFYSIGNBYCERT), "SAF_EccVerifySignByCert"},
{ERR_FUNC(GMAPI_F_SAF_GENECCKEYPAIR), "SAF_GenEccKeyPair"},
{ERR_FUNC(GMAPI_F_SAF_GENERATEAGREEMENTDATAWITHECC),
"SAF_GenerateAgreementDataWithECC"},
{ERR_FUNC(GMAPI_F_SAF_GENERATEKEYWITHECC), "SAF_GenerateKeyWithECC"},
{ERR_FUNC(GMAPI_F_SAF_GETECCPUBLICKEY), "SAF_GetEccPublicKey"},
{ERR_FUNC(GMAPI_F_SAF_MACFINAL), "SAF_MacFinal"},
{ERR_FUNC(GMAPI_F_SAF_MACUPDATE), "SAF_MacUpdate"},
{ERR_FUNC(GMAPI_F_SAF_PKCS7_DECODEDIGESTEDDATA),
"SAF_Pkcs7_DecodeDigestedData"},
{ERR_FUNC(GMAPI_F_SAF_PKCS7_ENCODEDIGESTEDDATA),
"SAF_Pkcs7_EncodeDigestedData"},
{ERR_FUNC(GMAPI_F_SAF_SYMMDECRYPTUPDATE), "SAF_SymmDecryptUpdate"},
{ERR_FUNC(GMAPI_F_SAF_SYMMENCRYPTUPDATE), "SAF_SymmEncryptUpdate"},
{ERR_FUNC(GMAPI_F_SKF_CLOSEHANDLE), "SKF_CloseHandle"},
{ERR_FUNC(GMAPI_F_SKF_DECRYPT), "SKF_Decrypt"},
{ERR_FUNC(GMAPI_F_SKF_DECRYPTFINAL), "SKF_DecryptFinal"},
{ERR_FUNC(GMAPI_F_SKF_DECRYPTINIT), "SKF_DecryptInit"},
{ERR_FUNC(GMAPI_F_SKF_DECRYPTUPDATE), "SKF_DecryptUpdate"},
{ERR_FUNC(GMAPI_F_SKF_DIGEST), "SKF_Digest"},
{ERR_FUNC(GMAPI_F_SKF_DIGESTFINAL), "SKF_DigestFinal"},
{ERR_FUNC(GMAPI_F_SKF_DIGESTINIT), "SKF_DigestInit"},
{ERR_FUNC(GMAPI_F_SKF_DIGESTUPDATE), "SKF_DigestUpdate"},
{ERR_FUNC(GMAPI_F_SKF_ENCRYPT), "SKF_Encrypt"},
{ERR_FUNC(GMAPI_F_SKF_ENCRYPTFINAL), "SKF_EncryptFinal"},
{ERR_FUNC(GMAPI_F_SKF_ENCRYPTINIT), "SKF_EncryptInit"},
{ERR_FUNC(GMAPI_F_SKF_ENCRYPTUPDATE), "SKF_EncryptUpdate"},
{ERR_FUNC(GMAPI_F_SKF_EXTECCDECRYPT), "SKF_ExtECCDecrypt"},
{ERR_FUNC(GMAPI_F_SKF_EXTECCENCRYPT), "SKF_ExtECCEncrypt"},
{ERR_FUNC(GMAPI_F_SKF_EXTECCSIGN), "SKF_ExtECCSign"},
{ERR_FUNC(GMAPI_F_SKF_EXTECCVERIFY), "SKF_ExtECCVerify"},
{ERR_FUNC(GMAPI_F_SKF_EXTRSAPRIKEYOPERATION),
"SKF_ExtRSAPriKeyOperation"},
{ERR_FUNC(GMAPI_F_SKF_EXTRSAPUBKEYOPERATION),
"SKF_ExtRSAPubKeyOperation"},
{ERR_FUNC(GMAPI_F_SKF_GENEXTECCKEYPAIR), "SKF_GenExtECCKeyPair"},
{ERR_FUNC(GMAPI_F_SKF_GENEXTRSAKEY), "SKF_GenExtRSAKey"},
{ERR_FUNC(GMAPI_F_SKF_GENRANDOM), "SKF_GenRandom"},
{ERR_FUNC(GMAPI_F_SKF_GETDEVINFO), "SKF_GetDevInfo"},
{ERR_FUNC(GMAPI_F_SKF_GETDEVSTATE), "SKF_GetDevState"},
{ERR_FUNC(GMAPI_F_SKF_HANDLE_GET_CBCMAC_CTX),
"SKF_HANDLE_get_cbcmac_ctx"},
{ERR_FUNC(GMAPI_F_SKF_HANDLE_GET_CIPHER), "SKF_HANDLE_get_cipher"},
{ERR_FUNC(GMAPI_F_SKF_HANDLE_GET_CIPHER_CTX),
"SKF_HANDLE_get_cipher_ctx"},
{ERR_FUNC(GMAPI_F_SKF_HANDLE_GET_KEY), "SKF_HANDLE_get_key"},
{ERR_FUNC(GMAPI_F_SKF_HANDLE_GET_MD_CTX), "SKF_HANDLE_get_md_ctx"},
{ERR_FUNC(GMAPI_F_SKF_MAC), "SKF_Mac"},
{ERR_FUNC(GMAPI_F_SKF_MACFINAL), "SKF_MacFinal"},
{ERR_FUNC(GMAPI_F_SKF_MACINIT), "SKF_MacInit"},
{ERR_FUNC(GMAPI_F_SKF_MACUPDATE), "SKF_MacUpdate"},
{ERR_FUNC(GMAPI_F_SKF_SETSYMMKEY), "SKF_SetSymmKey"},
{ERR_FUNC(GMAPI_F_SM2CIPHERTEXTVALUE_GET_ECCCIPHER),
"SM2CiphertextValue_get_ECCCipher"},
{ERR_FUNC(GMAPI_F_SM2CIPHERTEXTVALUE_GET_ECCCIPHERBLOB),
@@ -151,101 +119,50 @@ static ERR_STRING_DATA GMAPI_str_functs[] = {
"SM2CiphertextValue_set_ECCCipher"},
{ERR_FUNC(GMAPI_F_SM2CIPHERTEXTVALUE_SET_ECCCIPHERBLOB),
"SM2CiphertextValue_set_ECCCIPHERBLOB"},
{ERR_FUNC(GMAPI_F_SM2_CIPHERTEXT_VALUE_GET_ECCCIPHER),
"SM2_CIPHERTEXT_VALUE_get_ECCCipher"},
{ERR_FUNC(GMAPI_F_SM2_CIPHERTEXT_VALUE_GET_ECCCIPHERBLOB),
"SM2_CIPHERTEXT_VALUE_get_ECCCIPHERBLOB"},
{ERR_FUNC(GMAPI_F_SM2_CIPHERTEXT_VALUE_NEW_FROM_ECCCIPHER),
"SM2_CIPHERTEXT_VALUE_new_from_ECCCipher"},
{ERR_FUNC(GMAPI_F_SM2_CIPHERTEXT_VALUE_NEW_FROM_ECCCIPHERBLOB),
"SM2_CIPHERTEXT_VALUE_new_from_ECCCIPHERBLOB"},
{ERR_FUNC(GMAPI_F_SM2_CIPHERTEXT_VALUE_SET_ECCCIPHER),
"SM2_CIPHERTEXT_VALUE_set_ECCCipher"},
{ERR_FUNC(GMAPI_F_SM2_CIPHERTEXT_VALUE_SET_ECCCIPHERBLOB),
"SM2_CIPHERTEXT_VALUE_set_ECCCIPHERBLOB"},
{0, NULL}
};
static ERR_STRING_DATA GMAPI_str_reasons[] = {
{ERR_REASON(GMAPI_R_BUFFER_TOO_SMALL), "buffer too small"},
{ERR_REASON(GMAPI_R_CBCMAC_FAILURE), "cbcmac failure"},
{ERR_REASON(GMAPI_R_CTX_NOT_CREATED), "ctx not created"},
{ERR_REASON(GMAPI_R_DECODE_EC_PRIVATE_KEY_FAILED),
"decode ec private key failed"},
{ERR_REASON(GMAPI_R_DECODE_EC_PUBLIC_KEY_FAILED),
"decode ec public key failed"},
{ERR_REASON(GMAPI_R_DECRYPT_FAILED), "decrypt failed"},
{ERR_REASON(GMAPI_R_ENCODE_CIPHERTEXT_FAILED),
"encode ciphertext failed"},
{ERR_REASON(GMAPI_R_ENCODE_FAILED), "encode failed"},
{ERR_REASON(GMAPI_R_ENCODE_RSA_PUBLIC_KEY_FAILED),
"encode rsa public key failed"},
{ERR_REASON(GMAPI_R_ENCODE_SIGNATURE_FAILED), "encode signature failed"},
{ERR_REASON(GMAPI_R_ENCRYPT_FAILED), "encrypt failed"},
{ERR_REASON(GMAPI_R_FAIL), "fail"},
{ERR_REASON(GMAPI_R_GEN_RANDOM), "gen random"},
{ERR_REASON(GMAPI_R_GEN_RSA_FAILED), "gen rsa failed"},
{ERR_REASON(GMAPI_R_GET_PRIVATE_KEY_FAILED), "get private key failed"},
{ERR_REASON(GMAPI_R_GET_PUBLIC_KEY_FAILED), "get public key failed"},
{ERR_REASON(GMAPI_R_INT_OVERFLOW), "int overflow"},
{ERR_REASON(GMAPI_R_INVALID_ALGID), "invalid algid"},
{ERR_REASON(GMAPI_R_INVALID_ALGOR), "invalid algor"},
{ERR_REASON(GMAPI_R_INVALID_ARGUMENTS), "invalid arguments"},
{ERR_REASON(GMAPI_R_INVALID_BIGNUM_LENGTH), "invalid bignum length"},
{ERR_REASON(GMAPI_R_INVALID_BLOB), "invalid blob"},
{ERR_REASON(GMAPI_R_INVALID_CIPHERTEXT), "invalid ciphertext"},
{ERR_REASON(GMAPI_R_INVALID_CIPHERTEXT_LENGTH),
"invalid ciphertext length"},
{ERR_REASON(GMAPI_R_INVALID_CIPHERTEXT_MAC), "invalid ciphertext mac"},
{ERR_REASON(GMAPI_R_INVALID_CIPHERTEXT_POINT),
"invalid ciphertext point"},
{ERR_REASON(GMAPI_R_INVALID_CIPHER_CTX_HANDLE),
"invalid cipher ctx handle"},
{ERR_REASON(GMAPI_R_INVALID_CIPHETEXT_LENGTH),
"invalid ciphetext length"},
{ERR_REASON(GMAPI_R_INVALID_CONTEXT), "invalid context"},
{ERR_REASON(GMAPI_R_INVALID_DIGEST_ALGOR), "invalid digest algor"},
{ERR_REASON(GMAPI_R_INVALID_DIGEST_LENGTH), "invalid digest length"},
{ERR_REASON(GMAPI_R_INVALID_ECC_PRIVATE_KEY), "invalid ecc private key"},
{ERR_REASON(GMAPI_R_INVALID_ECC_PUBLIC_KEY), "invalid ecc public key"},
{ERR_REASON(GMAPI_R_INVALID_EC_KEY), "invalid ec key"},
{ERR_REASON(GMAPI_R_INVALID_EC_PRIVATE_KEY), "invalid ec private key"},
{ERR_REASON(GMAPI_R_INVALID_EC_PUBLIC_KEY), "invalid ec public key"},
{ERR_REASON(GMAPI_R_INVALID_FEED_BIT_LENGTH), "invalid feed bit length"},
{ERR_REASON(GMAPI_R_INVALID_HANDLE), "invalid handle"},
{ERR_REASON(GMAPI_R_INVALID_HANDLE_ALGOR), "invalid handle algor"},
{ERR_REASON(GMAPI_R_INVALID_HANDLE_MAGIC), "invalid handle magic"},
{ERR_REASON(GMAPI_R_INVALID_HANDLE_TYPE), "invalid handle type"},
{ERR_REASON(GMAPI_R_INVALID_HASH_HANDLE), "invalid hash handle"},
{ERR_REASON(GMAPI_R_INVALID_ID_LENGTH), "invalid id length"},
{ERR_REASON(GMAPI_R_INVALID_INPUT_LENGTH), "invalid input length"},
{ERR_REASON(GMAPI_R_INVALID_IV_LENGTH), "invalid iv length"},
{ERR_REASON(GMAPI_R_INVALID_KEY_HANDLE), "invalid key handle"},
{ERR_REASON(GMAPI_R_INVALID_KEY_LENGTH), "invalid key length"},
{ERR_REASON(GMAPI_R_INVALID_KEY_USAGE), "invalid key usage"},
{ERR_REASON(GMAPI_R_INVALID_LENGTH), "invalid length"},
{ERR_REASON(GMAPI_R_INVALID_MAC_HANDLE), "invalid mac handle"},
{ERR_REASON(GMAPI_R_INVALID_PLAINTEXT_LENGTH),
"invalid plaintext length"},
{ERR_REASON(GMAPI_R_INVALID_PRIVATE_KEY), "invalid private key"},
{ERR_REASON(GMAPI_R_INVALID_PUBLIC_KEY), "invalid public key"},
{ERR_REASON(GMAPI_R_INVALID_RANDOM_LENGTH), "invalid random length"},
{ERR_REASON(GMAPI_R_INVALID_RSA_KEY_LENGTH), "invalid rsa key length"},
{ERR_REASON(GMAPI_R_INVALID_RSA_PRIVATE_KEY), "invalid rsa private key"},
{ERR_REASON(GMAPI_R_INVALID_RSA_PUBLIC_KEY), "invalid rsa public key"},
{ERR_REASON(GMAPI_R_INVALID_SIGNATURE), "invalid signature"},
{ERR_REASON(GMAPI_R_INVALID_SKF_CIPHERTEXT), "invalid skf ciphertext"},
{ERR_REASON(GMAPI_R_INVALID_SKF_EC_CIPHERTEXT),
"invalid skf ec ciphertext"},
{ERR_REASON(GMAPI_R_INVALID_SM2_CIPHERTEXT), "invalid sm2 ciphertext"},
{ERR_REASON(GMAPI_R_INVALID_SM2_CIPHERTEXT_MAC_LENGTH),
"invalid sm2 ciphertext mac length"},
{ERR_REASON(GMAPI_R_INVALID_SM2_PRIVATE_KEY), "invalid sm2 private key"},
{ERR_REASON(GMAPI_R_INVALID_SM2_SIGNATURE), "invalid sm2 signature"},
{ERR_REASON(GMAPI_R_MAC_FAILURE), "mac failure"},
{ERR_REASON(GMAPI_R_MALLOC_FAILED), "malloc failed"},
{ERR_REASON(GMAPI_R_NOT_CONVERTABLE), "not convertable"},
{ERR_REASON(GMAPI_R_NO_PUBLIC_KEY), "no public key"},
{ERR_REASON(GMAPI_R_NULL_ARGUMENT), "null argument"},
{ERR_REASON(GMAPI_R_OPERATION_NOT_INITIALIZED),
"operation not initialized"},
{ERR_REASON(GMAPI_R_SAF_ERROR), "saf error"},
{ERR_REASON(GMAPI_R_SIGN_FAILED), "sign failed"},
{ERR_REASON(GMAPI_R_VERIFY_NOT_PASS), "verify not pass"},
{ERR_REASON(GMAPI_R_NOT_IMPLEMENTED), "not implemented"},
{ERR_REASON(GMAPI_R_NOT_SUPPORTED_GMAPI_CIPHER),
"not supported gmapi cipher"},
{ERR_REASON(GMAPI_R_NOT_SUPPORTED_PKEY), "not supported pkey"},
{0, NULL}
};

334
crypto/gmapi/gmapi_sdf_ec.c
View File

@@ -58,19 +58,30 @@
* This is different from SAF/SDF/SKF where return 0 means success.
*/
#include <openssl/ec.h>
#include <openssl/sm2.h>
#include <openssl/err.h>
#include <openssl/sdf.h>
#include <openssl/gmapi.h>
#include <openssl/objects.h>
#include "../sm2/sm2_lcl.h"
#include <stdio.h>
#include "internal/cryptlib.h"
#if !defined(OPENSSL_NO_SDF) && !defined(OPENSSL_NO_EC)
# include <openssl/ec.h>
# include <openssl/sm2.h>
# include <openssl/err.h>
# include <openssl/sdf.h>
# include <openssl/gmapi.h>
# include <openssl/objects.h>
# include "../sm2/sm2_lcl.h"
# include "../ecies/ecies_lcl.h"
EC_KEY *EC_KEY_new_from_ECCrefPublicKey(const ECCrefPublicKey *ref)
{
EC_KEY *ret;
if (!ref) {
GMAPIerr(GMAPI_F_EC_KEY_NEW_FROM_ECCREFPUBLICKEY,
ERR_R_PASSED_NULL_PARAMETER);
return NULL;
}
if (!(ret = EC_KEY_new_by_curve_name(NID_sm2p256v1))) {
GMAPIerr(GMAPI_F_EC_KEY_NEW_FROM_ECCREFPUBLICKEY, ERR_R_EC_LIB);
return NULL;
@@ -253,7 +264,6 @@ int EC_KEY_get_ECCrefPrivateKey(EC_KEY *ec_key, ECCrefPrivateKey *ref)
{
const EC_GROUP *group;
const BIGNUM *sk;
int nbytes;
/* check arguments */
if (!ec_key || !ref) {
@@ -282,8 +292,7 @@ int EC_KEY_get_ECCrefPrivateKey(EC_KEY *ec_key, ECCrefPrivateKey *ref)
ref->bits = EC_GROUP_get_degree(group);
nbytes = (EC_GROUP_get_degree(group) + 7)/8;
if (!BN_bn2bin(sk, ref->K + nbytes - BN_num_bytes(sk))) {
if (!BN_bn2bin(sk, ref->K + sizeof(ref->K) - BN_num_bytes(sk))) {
GMAPIerr(GMAPI_F_EC_KEY_GET_ECCREFPRIVATEKEY, ERR_R_BN_LIB);
return 0;
}
@@ -291,6 +300,7 @@ int EC_KEY_get_ECCrefPrivateKey(EC_KEY *ec_key, ECCrefPrivateKey *ref)
return 1;
}
# ifndef OPENSSL_NO_SM2
SM2CiphertextValue *SM2CiphertextValue_new_from_ECCCipher(const ECCCipher *ref)
{
SM2CiphertextValue *ret = NULL;
@@ -465,6 +475,7 @@ int SM2CiphertextValue_get_ECCCipher(const SM2CiphertextValue *cv,
end:
return ret;
}
# endif
ECDSA_SIG *ECDSA_SIG_new_from_ECCSignature(const ECCSignature *ref)
{
@@ -587,3 +598,306 @@ int ECDSA_SIG_get_ECCSignature(const ECDSA_SIG *sig, ECCSignature *ref)
return 1;
}
ECCCipher *d2i_ECCCipher(ECCCipher **a, const unsigned char **pp, long length)
{
ECCCipher *ret = NULL;
ECCCipher *sdf = NULL;
SM2CiphertextValue *cv = NULL;
if (!(cv = d2i_SM2CiphertextValue(NULL, pp, length))) {
GMAPIerr(GMAPI_F_D2I_ECCCIPHER, ERR_R_SM2_LIB);
goto end;
}
if (*a) {
if (!SM2CiphertextValue_get_ECCCipher(cv, *a)) {
GMAPIerr(GMAPI_F_D2I_ECCCIPHER, ERR_R_GMAPI_LIB);
goto end;
}
ret = *a;
} else {
if (!(sdf = OPENSSL_malloc(sizeof(ECCCipher) - 1 +
ASN1_STRING_length(cv->ciphertext)))) {
GMAPIerr(GMAPI_F_D2I_ECCCIPHER, ERR_R_MALLOC_FAILURE);
goto end;
}
sdf->L = ASN1_STRING_length(cv->ciphertext);
if (!SM2CiphertextValue_get_ECCCipher(cv, sdf)) {
GMAPIerr(GMAPI_F_D2I_ECCCIPHER, ERR_R_GMAPI_LIB);
goto end;
}
ret = sdf;
sdf = NULL;
}
end:
OPENSSL_free(sdf);
SM2CiphertextValue_free(cv);
return ret;
}
ECCCipher *d2i_ECCCipher_bio(BIO *bp, ECCCipher **a)
{
return NULL;
}
ECCCipher *d2i_ECCCipher_fp(FILE *fp, ECCCipher **a)
{
return NULL;
}
int i2d_ECCCipher(ECCCipher *a, unsigned char **pp)
{
int ret;
SM2CiphertextValue *cv = NULL;
if (!(cv = SM2CiphertextValue_new_from_ECCCipher(a))) {
GMAPIerr(GMAPI_F_I2D_ECCCIPHER, ERR_R_SM2_LIB);
return 0;
}
ret = i2d_SM2CiphertextValue(cv, pp);
SM2CiphertextValue_free(cv);
return ret;
}
int i2d_ECCCipher_bio(BIO *bp, ECCCipher *a)
{
return 0;
}
int i2d_ECCCipher_fp(FILE *fp, ECCCipher *a)
{
return 0;
}
ECCSignature *d2i_ECCSignature(ECCSignature **a, const unsigned char **pp, long length)
{
ECCSignature *ret = NULL;
ECCSignature *sdf_sig = NULL;
ECDSA_SIG *sig = NULL;
if (!(sig = d2i_ECDSA_SIG(NULL, pp, length))) {
GMAPIerr(GMAPI_F_D2I_ECCSIGNATURE, ERR_R_EC_LIB);
goto end;
}
if (!(sdf_sig = OPENSSL_malloc(sizeof(ECCSignature)))) {
GMAPIerr(GMAPI_F_D2I_ECCSIGNATURE, ERR_R_MALLOC_FAILURE);
goto end;
}
if (!ECDSA_SIG_get_ECCSignature(sig, sdf_sig)) {
GMAPIerr(GMAPI_F_D2I_ECCSIGNATURE, ERR_R_GMAPI_LIB);
goto end;
}
ret = sdf_sig;
sdf_sig = NULL;
end:
OPENSSL_free(sdf_sig);
ECDSA_SIG_free(sig);
return ret;
}
ECCSignature *d2i_ECCSignature_bio(BIO *bp, ECCSignature **a)
{
return NULL;
}
ECCSignature *d2i_ECCSignature_fp(FILE *fp, ECCSignature **a)
{
return NULL;
}
int i2d_ECCSignature(ECCSignature *a, unsigned char **pp)
{
int ret;
ECDSA_SIG *sig = NULL;
if (!(sig = ECDSA_SIG_new_from_ECCSignature(a))) {
GMAPIerr(GMAPI_F_I2D_ECCSIGNATURE, ERR_R_GMAPI_LIB);
return 0;
}
ret = i2d_ECDSA_SIG(sig, pp);
ECDSA_SIG_free(sig);
return ret;
}
int i2d_ECCSignature_bio(BIO *bp, ECCSignature *a)
{
return 0;
}
int i2d_ECCSignature_fp(FILE *fp, ECCSignature *a)
{
return 0;
}
# ifndef OPENSSL_NO_ECIES
ECIES_CIPHERTEXT_VALUE *ECIES_CIPHERTEXT_VALUE_new_from_ECCCipher(
const ECCCipher *ref)
{
ECIES_CIPHERTEXT_VALUE *ret = NULL;
ECIES_CIPHERTEXT_VALUE *cv = NULL;
if (!(cv = ECIES_CIPHERTEXT_VALUE_new())) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_NEW_FROM_ECCCIPHER,
ERR_R_MALLOC_FAILURE);
goto end;
}
if (!ECIES_CIPHERTEXT_VALUE_set_ECCCipher(cv, ref)) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_NEW_FROM_ECCCIPHER,
ERR_R_GMAPI_LIB);
goto end;
}
ret = cv;
cv = NULL;
end:
ECIES_CIPHERTEXT_VALUE_free(cv);
return ret;
}
int ECIES_CIPHERTEXT_VALUE_set_ECCCipher(ECIES_CIPHERTEXT_VALUE *cv, const ECCCipher *ref)
{
int ret = 0;
int point_form = POINT_CONVERSION_COMPRESSED;
EC_GROUP *group = NULL;
EC_POINT *point = NULL;
BIGNUM *x = NULL;
BIGNUM *y = NULL;
BN_CTX *bn_ctx = NULL;
int len;
if (!(group = EC_GROUP_new_by_curve_name(NID_sm2p256v1))
|| !(point = EC_POINT_new(group))
|| !(x = BN_new())
|| !(y = BN_new())
|| !(bn_ctx = BN_CTX_new())) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_SET_ECCCIPHER,
ERR_R_MALLOC_FAILURE);
goto end;
}
if (!BN_bin2bn(ref->x, sizeof(ref->x), x)
|| !BN_bin2bn(ref->y, sizeof(ref->y), y)) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_SET_ECCCIPHER,
ERR_R_BN_LIB);
goto end;
}
if (!EC_POINT_set_affine_coordinates_GFp(group, point, x, y, bn_ctx)) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_SET_ECCCIPHER,
ERR_R_EC_LIB);
goto end;
}
len = EC_POINT_point2oct(group, point, point_form, NULL, 0, NULL);
if (!ASN1_OCTET_STRING_set(cv->ephem_point, NULL, len)) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_SET_ECCCIPHER,
ERR_R_MALLOC_FAILURE);
goto end;
}
if (EC_POINT_point2oct(group, point, point_form,
cv->ephem_point->data, len, NULL) <= 0) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_SET_ECCCIPHER,
ERR_R_EC_LIB);
goto end;
}
if (!ASN1_OCTET_STRING_set(cv->ciphertext, ref->C, ref->L)) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_SET_ECCCIPHER,
ERR_R_ASN1_LIB);
goto end;
}
if (!ASN1_OCTET_STRING_set(cv->mactag, ref->M, sizeof(ref->M))) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_SET_ECCCIPHER,
ERR_R_ASN1_LIB);
goto end;
}
ret = 1;
end:
EC_GROUP_free(group);
EC_POINT_free(point);
BN_free(x);
BN_free(y);
BN_CTX_free(bn_ctx);
return ret;
}
int ECIES_CIPHERTEXT_VALUE_get_ECCCipher(const ECIES_CIPHERTEXT_VALUE *cv, ECCCipher *ref)
{
int ret = 0;
EC_GROUP *group = NULL;
EC_POINT *point = NULL;
BIGNUM *x = NULL;
BIGNUM *y = NULL;
BN_CTX *bn_ctx = NULL;
int len;
if (ASN1_STRING_length(cv->mactag) != sizeof(ref->M)) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_GET_ECCCIPHER,
GMAPI_R_INVALID_SM2_CIPHERTEXT_MAC_LENGTH);
return 0;
}
len = sizeof(ECCCipher) - 1 + ASN1_STRING_length(cv->ciphertext);
if (!ref) {
return len;
}
if (!(group = EC_GROUP_new_by_curve_name(NID_sm2p256v1))
|| !(point = EC_POINT_new(group))
|| !(x = BN_new())
|| !(y = BN_new())
|| !(bn_ctx = BN_CTX_new())) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_GET_ECCCIPHER,
ERR_R_MALLOC_FAILURE);
goto end;
}
if (!EC_POINT_oct2point(group, point,
ASN1_STRING_get0_data(cv->ephem_point),
ASN1_STRING_length(cv->ephem_point), bn_ctx)) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_GET_ECCCIPHER,
ERR_R_EC_LIB);
goto end;
}
if (!EC_POINT_get_affine_coordinates_GFp(group, point, x, y, bn_ctx)) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_GET_ECCCIPHER,
ERR_R_EC_LIB);
goto end;
}
memset(ref, 0, len);
BN_bn2bin(x, ref->x + sizeof(ref->x) - BN_num_bytes(x));
BN_bn2bin(y, ref->y + sizeof(ref->y) - BN_num_bytes(y));
memcpy(ref->C, ASN1_STRING_get0_data(cv->ciphertext),
ASN1_STRING_length(cv->ciphertext));
memcpy(ref->M, ASN1_STRING_get0_data(cv->mactag),
ASN1_STRING_length(cv->mactag));
ret = len;
end:
EC_GROUP_free(group);
EC_POINT_free(point);
BN_free(x);
BN_free(y);
BN_CTX_free(bn_ctx);
return ret;
}
# endif /* OPENSSL_NO_ECIES */
#endif

594
crypto/gmapi/gmapi_sdf_rsa.c
View File

@@ -1,209 +1,385 @@
/* ====================================================================
* Copyright (c) 2015-2016 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.
* ====================================================================
*/
/* convert RSA between native and SDF types, never include skf.h */
#include <stdio.h>
#include <openssl/err.h>
#include <openssl/gmapi.h>
#include <openssl/rsa.h>
#include <openssl/sdf.h>
#include "../rsa/rsa_locl.h" //FIXME
RSA *RSA_new_from_RSArefPublicKey(const RSArefPublicKey *ref)
{
RSA *ret;
if (!(ret = RSA_new())) {
GMAPIerr(GMAPI_F_RSA_NEW_FROM_RSAREFPUBLICKEY, ERR_R_RSA_LIB);
return NULL;
}
if (!RSA_set_RSArefPublicKey(ret, ref)) {
GMAPIerr(GMAPI_F_RSA_NEW_FROM_RSAREFPUBLICKEY,
GMAPI_R_INVALID_RSA_PUBLIC_KEY);
RSA_free(ret);
return NULL;
}
return ret;
}
int RSA_set_RSArefPublicKey(RSA *rsa, const RSArefPublicKey *ref)
{
if (!rsa || !ref) {
GMAPIerr(GMAPI_F_RSA_SET_RSAREFPUBLICKEY,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if ((ref->bits < 1024) || (ref->bits > RSAref_MAX_LEN*8) ||
(ref->bits % 8 != 0)) {
GMAPIerr(GMAPI_F_RSA_SET_RSAREFPUBLICKEY,
GMAPI_R_INVALID_RSA_KEY_LENGTH);
return 0;
}
if (!(rsa->n = BN_bin2bn(ref->m, ref->bits/8, rsa->n))) {
GMAPIerr(GMAPI_F_RSA_SET_RSAREFPUBLICKEY,
GMAPI_R_INVALID_RSA_PUBLIC_KEY);
return 0;
}
if (!(rsa->e = BN_bin2bn(ref->e, RSAref_MAX_LEN, rsa->e))) {
GMAPIerr(GMAPI_F_RSA_SET_RSAREFPUBLICKEY,
GMAPI_R_INVALID_RSA_PUBLIC_KEY);
return 0;
}
if (!RSA_check_key(rsa)) {
GMAPIerr(GMAPI_F_RSA_SET_RSAREFPUBLICKEY,
GMAPI_R_INVALID_RSA_PUBLIC_KEY);
return 0;
}
return 1;
}
int RSA_get_RSArefPublicKey(RSA *rsa, RSArefPublicKey *ref)
{
int nbytes;
if (!rsa || !ref) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPUBLICKEY,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if (!rsa->n || !rsa->e) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPUBLICKEY,
GMAPI_R_INVALID_RSA_PUBLIC_KEY);
return 0;
}
nbytes = BN_num_bytes(rsa->n);
if (!BN_bn2bin(rsa->n, ref->m) || !BN_bn2bin(rsa->e,
ref->e + MAX_RSA_EXPONENT_LEN - BN_num_bytes(rsa->e))) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPUBLICKEY,
GMAPI_R_ENCODE_RSA_PUBLIC_KEY_FAILED);
return 0;
}
return 1;
}
RSA *RSA_new_from_RSArefPrivateKey(const RSArefPrivateKey *ref)
{
RSA *ret;
if (!(ret = RSA_new())) {
GMAPIerr(GMAPI_F_RSA_NEW_FROM_RSAREFPRIVATEKEY, ERR_R_RSA_LIB);
return NULL;
}
if (!RSA_set_RSArefPrivateKey(ret, ref)) {
GMAPIerr(GMAPI_F_RSA_NEW_FROM_RSAREFPRIVATEKEY,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
RSA_free(ret);
return NULL;
}
return ret;
}
int RSA_set_RSArefPrivateKey(RSA *rsa, const RSArefPrivateKey *ref)
{
int nbytes;
if (!rsa || !ref) {
GMAPIerr(GMAPI_F_RSA_SET_RSAREFPRIVATEKEY,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if ((ref->bits < 1024) || (ref->bits > RSAref_MAX_LEN*8) ||
(ref->bits % 8 != 0) || (ref->bits % 16 != 0)) {
GMAPIerr(GMAPI_F_RSA_SET_RSAREFPRIVATEKEY,
GMAPI_R_INVALID_KEY_LENGTH);
return 0;
}
nbytes = ref->bits/8;
if (!(rsa->n = BN_bin2bn(ref->m, nbytes, rsa->n)) ||
!(rsa->e = BN_bin2bn(ref->e, MAX_RSA_EXPONENT_LEN, rsa->e)) ||
!(rsa->d = BN_bin2bn(ref->d, nbytes, rsa->d)) ||
!(rsa->p = BN_bin2bn(ref->prime[0], nbytes/2, rsa->p)) ||
!(rsa->q = BN_bin2bn(ref->prime[1], nbytes/2, rsa->q)) ||
!(rsa->dmp1 = BN_bin2bn(ref->pexp[0], nbytes/2, rsa->dmp1)) ||
!(rsa->dmq1 = BN_bin2bn(ref->pexp[1], nbytes/2, rsa->dmq1)) ||
!(rsa->iqmp = BN_bin2bn(ref->coef, nbytes/2, rsa->iqmp))) {
GMAPIerr(GMAPI_F_RSA_SET_RSAREFPRIVATEKEY,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
return 1;
}
int RSA_get_RSArefPrivateKey(RSA *rsa, RSArefPrivateKey *ref)
{
int nbytes;
if (!rsa || !ref) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPRIVATEKEY,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if (!rsa->n || !rsa->e || !rsa->d || !rsa->p || !rsa->q ||
!rsa->dmp1 || !rsa->dmq1 || !rsa->iqmp) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPRIVATEKEY,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
memset(ref, 0, sizeof(*ref));
ref->bits = BN_num_bits(rsa->n);
nbytes = BN_num_bytes(rsa->n);
if (!BN_bn2bin(rsa->n, ref->m) ||
!BN_bn2bin(rsa->e, ref->e + MAX_RSA_EXPONENT_LEN - BN_num_bytes(rsa->e)) ||
!BN_bn2bin(rsa->d, ref->d + nbytes - BN_num_bytes(rsa->d)) ||
!BN_bn2bin(rsa->p, (unsigned char *)&(ref->prime[0]) + nbytes/2 - BN_num_bytes(rsa->p)) ||
!BN_bn2bin(rsa->q, (unsigned char *)&(ref->prime[1]) + nbytes/2 - BN_num_bytes(rsa->q)) ||
!BN_bn2bin(rsa->dmp1, (unsigned char *)&(ref->pexp[0]) + nbytes/2 - BN_num_bytes(rsa->dmp1)) ||
!BN_bn2bin(rsa->dmq1, (unsigned char *)&(ref->pexp[1]) + nbytes/2 - BN_num_bytes(rsa->dmq1)) ||
!BN_bn2bin(rsa->iqmp, ref->coef + nbytes/2 - BN_num_bytes(rsa->iqmp))) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPRIVATEKEY,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
return 1;
}
/* ====================================================================
* Copyright (c) 2015-2016 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 "internal/cryptlib.h"
#if !defined(OPENSSL_NO_SDF) && !defined(OPENSSL_NO_RSA)
# include <openssl/err.h>
# include <openssl/rsa.h>
# include <openssl/sdf.h>
# include <openssl/gmapi.h>
RSA *RSA_new_from_RSArefPublicKey(const RSArefPublicKey *ref)
{
RSA *ret = NULL;
RSA *rsa = NULL;
if (!ref) {
GMAPIerr(GMAPI_F_RSA_NEW_FROM_RSAREFPUBLICKEY,
ERR_R_PASSED_NULL_PARAMETER);
return NULL;
}
if (!(rsa = RSA_new())) {
GMAPIerr(GMAPI_F_RSA_NEW_FROM_RSAREFPUBLICKEY,
ERR_R_MALLOC_FAILURE);
return NULL;
}
if (!RSA_set_RSArefPublicKey(rsa, ref)) {
GMAPIerr(GMAPI_F_RSA_NEW_FROM_RSAREFPUBLICKEY,
GMAPI_R_INVALID_RSA_PUBLIC_KEY);
goto end;
}
ret = rsa;
rsa = NULL;
end:
RSA_free(rsa);
return ret;
}
int RSA_set_RSArefPublicKey(RSA *rsa, const RSArefPublicKey *ref)
{
int ret = 0;
BIGNUM *n = NULL;
BIGNUM *e = NULL;
if (!rsa || !ref) {
GMAPIerr(GMAPI_F_RSA_SET_RSAREFPUBLICKEY,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if ((ref->bits < OPENSSL_RSA_FIPS_MIN_MODULUS_BITS) ||
(ref->bits > sizeof(ref->m) * 8) || (ref->bits % 8 != 0)) {
GMAPIerr(GMAPI_F_RSA_SET_RSAREFPUBLICKEY,
GMAPI_R_INVALID_RSA_KEY_LENGTH);
return 0;
}
if (!(n = BN_bin2bn(ref->m, sizeof(ref->m), NULL))) {
GMAPIerr(GMAPI_F_RSA_SET_RSAREFPUBLICKEY, ERR_R_BN_LIB);
goto end;
}
if (!(e = BN_bin2bn(ref->e, sizeof(ref->e), NULL))) {
GMAPIerr(GMAPI_F_RSA_SET_RSAREFPUBLICKEY, ERR_R_BN_LIB);
goto end;
}
if (!RSA_set0_key(rsa, n, e, NULL)) {
GMAPIerr(GMAPI_F_RSA_SET_RSAREFPUBLICKEY, ERR_R_RSA_LIB);
goto end;
}
n = NULL;
e = NULL;
if (1 != RSA_check_key(rsa)) {
GMAPIerr(GMAPI_F_RSA_SET_RSAREFPUBLICKEY,
GMAPI_R_INVALID_RSA_PUBLIC_KEY);
goto end;
}
ret = 1;
end:
BN_free(n);
BN_free(e);
return ret;
}
int RSA_get_RSArefPublicKey(RSA *rsa, RSArefPublicKey *ref)
{
const BIGNUM *n;
const BIGNUM *e;
if (!rsa || !ref) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPUBLICKEY,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
RSA_get0_key(rsa, &n, &e, NULL);
if (!n || !e) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPUBLICKEY,
GMAPI_R_INVALID_RSA_PUBLIC_KEY);
return 0;
}
if (RSA_bits(rsa) % 8 != 0 || RSA_bits(rsa) > sizeof(ref->m) * 8) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPUBLICKEY,
GMAPI_R_INVALID_RSA_PUBLIC_KEY);
return 0;
}
memset(ref, 0, sizeof(RSArefPublicKey));
ref->bits = RSA_bits(rsa);
if (BN_bn2bin(n, ref->m + sizeof(ref->m) - BN_num_bytes(n)) <= 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPUBLICKEY,
GMAPI_R_ENCODE_RSA_PUBLIC_KEY_FAILED);
return 0;
}
if (BN_bn2bin(e, ref->e + sizeof(ref->e) - BN_num_bytes(e)) <= 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPUBLICKEY,
GMAPI_R_ENCODE_RSA_PUBLIC_KEY_FAILED);
return 0;
}
return 1;
}
RSA *RSA_new_from_RSArefPrivateKey(const RSArefPrivateKey *ref)
{
RSA *ret = NULL;
RSA *rsa = NULL;
if (!ref) {
GMAPIerr(GMAPI_F_RSA_NEW_FROM_RSAREFPRIVATEKEY,
ERR_R_PASSED_NULL_PARAMETER);
return NULL;
}
if (!(rsa = RSA_new())) {
GMAPIerr(GMAPI_F_RSA_NEW_FROM_RSAREFPRIVATEKEY,
ERR_R_MALLOC_FAILURE);
return NULL;
}
if (!RSA_set_RSArefPrivateKey(rsa, ref)) {
GMAPIerr(GMAPI_F_RSA_NEW_FROM_RSAREFPRIVATEKEY,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
goto end;
}
ret = rsa;
rsa = NULL;
end:
RSA_free(ret);
return ret;
}
int RSA_set_RSArefPrivateKey(RSA *rsa, const RSArefPrivateKey *ref)
{
int ret = 0;
BIGNUM *n = NULL;
BIGNUM *e = NULL;
BIGNUM *d = NULL;
BIGNUM *p = NULL;
BIGNUM *q = NULL;
BIGNUM *dmp1 = NULL;
BIGNUM *dmq1 = NULL;
BIGNUM *iqmp = NULL;
if (!rsa || !ref) {
GMAPIerr(GMAPI_F_RSA_SET_RSAREFPRIVATEKEY,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if (ref->bits < OPENSSL_RSA_FIPS_MIN_MODULUS_BITS
|| ref->bits > sizeof(ref->m) *8
|| ref->bits % 8 != 0
|| ref->bits % 16 != 0) {
GMAPIerr(GMAPI_F_RSA_SET_RSAREFPRIVATEKEY,
GMAPI_R_INVALID_KEY_LENGTH);
return 0;
}
if (!(n = BN_bin2bn(ref->m, sizeof(ref->m), NULL))
|| !(e = BN_bin2bn(ref->e, sizeof(ref->e), NULL))
|| !(d = BN_bin2bn(ref->d, sizeof(ref->d), NULL))
|| !(p = BN_bin2bn(ref->prime[0], sizeof(ref->prime[0]), NULL))
|| !(q = BN_bin2bn(ref->prime[1], sizeof(ref->prime[1]), NULL))
|| !(dmp1 = BN_bin2bn(ref->pexp[0], sizeof(ref->pexp[0]), NULL))
|| !(dmq1 = BN_bin2bn(ref->pexp[0], sizeof(ref->pexp[1]), NULL))
|| !(iqmp = BN_bin2bn(ref->coef, sizeof(ref->coef), NULL))) {
GMAPIerr(GMAPI_F_RSA_SET_RSAREFPRIVATEKEY, ERR_R_BN_LIB);
goto end;
}
if (!RSA_set0_key(rsa, n, e, d)) {
GMAPIerr(GMAPI_F_RSA_SET_RSAREFPRIVATEKEY,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
goto end;
}
n = NULL;
e = NULL;
d = NULL;
if (!RSA_set0_factors(rsa, p, q)) {
GMAPIerr(GMAPI_F_RSA_SET_RSAREFPRIVATEKEY,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
goto end;
}
p = NULL;
q = NULL;
if (!RSA_set0_crt_params(rsa, dmp1, dmq1, iqmp)) {
GMAPIerr(GMAPI_F_RSA_SET_RSAREFPRIVATEKEY,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
goto end;
}
dmp1 = NULL;
dmq1 = NULL;
iqmp = NULL;
ret = 1;
end:
BN_free(n);
BN_free(e);
BN_free(d);
BN_free(p);
BN_free(q);
BN_free(dmp1);
BN_free(dmq1);
BN_free(iqmp);
return ret;
}
int RSA_get_RSArefPrivateKey(RSA *rsa, RSArefPrivateKey *ref)
{
const BIGNUM *n;
const BIGNUM *e;
const BIGNUM *d;
const BIGNUM *p;
const BIGNUM *q;
const BIGNUM *dmp1;
const BIGNUM *dmq1;
const BIGNUM *iqmp;
if (!rsa || !ref) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPRIVATEKEY,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if (RSA_bits(rsa) % 8 != 0 || RSA_bits(rsa) > sizeof(ref->m) * 8) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPRIVATEKEY,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
RSA_get0_key(rsa, &n, &e, &d);
RSA_get0_factors(rsa, &p, &q);
RSA_get0_crt_params(rsa, &dmp1, &dmq1, &iqmp);
if (!n || !e || !d) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPRIVATEKEY,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
memset(ref, 0, sizeof(RSArefPrivateKey));
ref->bits = RSA_bits(rsa);
if (BN_bn2bin(n, ref->m + sizeof(ref->m) - BN_num_bytes(n)) <= 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPRIVATEKEY,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
if (BN_bn2bin(e, ref->e + sizeof(ref->e) - BN_num_bytes(e)) <= 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPRIVATEKEY,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
if (BN_bn2bin(d, ref->d + sizeof(ref->d) - BN_num_bytes(d)) <= 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPRIVATEKEY,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
if (p && BN_bn2bin(p, ref->prime[0] + sizeof(ref->prime[0]) -
BN_num_bytes(p)) < 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPRIVATEKEY,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
if (q && BN_bn2bin(q, ref->prime[1] + sizeof(ref->prime[1]) -
BN_num_bytes(q)) < 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPRIVATEKEY,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
if (dmp1 && BN_bn2bin(dmp1, ref->pexp[0] + sizeof(ref->pexp[0]) -
BN_num_bytes(dmp1)) < 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPRIVATEKEY,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
if (dmq1 && BN_bn2bin(dmq1, ref->pexp[1] + sizeof(ref->pexp[1]) -
BN_num_bytes(dmq1)) < 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPRIVATEKEY,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
if (iqmp && BN_bn2bin(iqmp, ref->coef + sizeof(ref->coef) -
BN_num_bytes(iqmp)) < 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAREFPRIVATEKEY,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
return 1;
}
#endif

192
crypto/gmapi/gmapi_sgd.c
View File

@@ -49,80 +49,168 @@
#include <stdio.h>
#include <string.h>
#include <openssl/err.h>
#include <openssl/evp.h>
#include <openssl/sgd.h>
#include <openssl/gmapi.h>
#include "../../e_os.h"
const EVP_MD *EVP_get_digestbysgd(int sgd)
typedef struct {
int nid;
ULONG ulAlgId;
ULONG ulFeedBitLen;
} GMAPI_CIPHER_ITEM;
static GMAPI_CIPHER_ITEM gmapi_ciphers[] = {
{NID_sm1_ecb, SGD_SM1_ECB, 0},
{NID_sm1_cbc, SGD_SM1_CBC, 0},
{NID_sm1_cfb1, SGD_SM1_CFB, 1},
{NID_sm1_cfb8, SGD_SM1_CFB, 8},
{NID_sm1_cfb128, SGD_SM1_CFB, 128},
{NID_sm1_ofb128, SGD_SM1_OFB, 128},
{NID_sms4_ecb, SGD_SM4_ECB, 0},
{NID_sms4_cbc, SGD_SM4_CBC, 0},
{NID_sms4_cfb1, SGD_SM4_CFB, 1},
{NID_sms4_cfb8, SGD_SM4_CFB, 8},
{NID_sms4_cfb128, SGD_SM4_CFB, 128},
{NID_sms4_ofb128, SGD_SM4_OFB, 128},
{NID_ssf33_ecb, SGD_SSF33_ECB, 0},
{NID_ssf33_cbc, SGD_SSF33_CBC, 0},
{NID_ssf33_cfb1, SGD_SSF33_CFB, 1},
{NID_ssf33_cfb8, SGD_SSF33_CFB, 8},
{NID_ssf33_cfb128, SGD_SSF33_CFB, 128},
{NID_ssf33_ofb128, SGD_SSF33_OFB, 128},
{NID_zuc_128eea3, SGD_ZUC_EEA3, 0},
};
const EVP_CIPHER *EVP_get_cipherbysgd(ULONG ulAlgId, ULONG ulFeedBitLen)
{
switch (sgd) {
case SGD_SM3:
return EVP_sm3();
case SGD_SHA1:
return EVP_sha1();
case SGD_SHA256:
return EVP_sha256();
size_t i;
for (i = 0; i < OSSL_NELEM(gmapi_ciphers); i++) {
if (gmapi_ciphers[i].ulAlgId == ulAlgId
&& gmapi_ciphers[i].ulFeedBitLen == ulFeedBitLen) {
return EVP_get_cipherbynid(gmapi_ciphers[i].nid);
}
}
return NULL;
return NULL;
}
const EVP_CIPHER *EVP_get_cipherbysgd(int sgd)
int EVP_CIPHER_get_sgd(const EVP_CIPHER *cipher, ULONG *pulAlgId, ULONG *pulFeedBits)
{
switch (sgd) {
case SGD_SM4_ECB:
return EVP_sms4_ecb();
case SGD_SM4_CBC:
return EVP_sms4_cbc();
case SGD_SM4_CFB:
return EVP_sms4_cfb();
case SGD_SM4_OFB:
return EVP_sms4_ofb();
#define OPENSSL_NO_ZUC
#ifndef OPENSSL_NO_ZUC
case SGD_ZUC:
return EVP_zuc();
case SGD_ZUC_EEA3:
return EVP_zuc_eea3();
#endif
size_t i;
if (!cipher || !pulAlgId || !pulFeedBits) {
GMAPIerr(GMAPI_F_EVP_CIPHER_GET_SGD, ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
for (i = 0; i < OSSL_NELEM(gmapi_ciphers); i++) {
if (EVP_CIPHER_nid(cipher) == gmapi_ciphers[i].nid) {
*pulAlgId = gmapi_ciphers[i].ulAlgId;
*pulFeedBits = gmapi_ciphers[i].ulFeedBitLen;
return 1;
}
}
/* caller can clear this error */
GMAPIerr(GMAPI_F_EVP_CIPHER_GET_SGD, GMAPI_R_NOT_SUPPORTED_GMAPI_CIPHER);
*pulAlgId = 0;
*pulFeedBits = 0;
return 0;
}
int EVP_CIPHER_CTX_get_sgd(const EVP_CIPHER_CTX *ctx,
ULONG *pulAlgId, ULONG *pulFeedBits)
{
if (!ctx || !pulAlgId || !pulFeedBits) {
GMAPIerr(GMAPI_F_EVP_CIPHER_CTX_GET_SGD,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
return EVP_CIPHER_get_sgd(EVP_CIPHER_CTX_cipher(ctx), pulAlgId, pulFeedBits);
}
typedef struct {
int nid;
ULONG ulAlgId;
} GMAPI_ALGOR_ITEM;
static GMAPI_ALGOR_ITEM gmapi_digests[] = {
{NID_sm3, SGD_SM3},
{NID_sha1, SGD_SHA1},
{NID_sha256, SGD_SHA256},
};
const EVP_MD *EVP_get_digestbysgd(ULONG ulAlgId)
{
size_t i;
for (i = 0; i < OSSL_NELEM(gmapi_digests); i++) {
if (gmapi_digests[i].ulAlgId == ulAlgId) {
return EVP_get_digestbynid(gmapi_digests[i].nid);
}
}
return NULL;
}
/*
int load_engine(void)
int EVP_MD_get_sgd(const EVP_MD *md, ULONG *ulAlgId)
{
ENGINE *e;
size_t i;
ENGINE_load_builtin_engines(0);
if (!md || !ulAlgId) {
GMAPIerr(GMAPI_F_EVP_MD_GET_SGD, ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
ENGINE_register_all_complete();
for (i = 0; i < OSSL_NELEM(gmapi_digests); i++) {
if (gmapi_digests[i].nid == EVP_MD_nid(md)) {
*ulAlgId = gmapi_digests[i].ulAlgId;
return 1;
}
}
}
*/
const char *GMAPI_keyusage2str(int usage)
{
return NULL;
}
int GMAPI_sgd2ciphernid(int sgd)
{
*ulAlgId = 0;
return 0;
}
int GMAPI_sgd2mdnid(int sgd)
int EVP_MD_CTX_get_sgd(const EVP_MD_CTX *ctx, ULONG *ulAlgId)
{
return EVP_MD_get_sgd(EVP_MD_CTX_md(ctx), ulAlgId);
}
static GMAPI_ALGOR_ITEM gmapi_pkeys[] = {
{NID_rsa, SGD_RSA_SIGN},
{NID_rsaEncryption, SGD_RSA_ENC},
{NID_sm2sign, SGD_SM2_1},
{NID_sm2exchange, SGD_SM2_2},
{NID_sm2encrypt, SGD_SM2_3}
};
int EVP_PKEY_get_sgd(const EVP_PKEY *pkey, ULONG *ulAlgId)
{
size_t i;
if (!pkey || !ulAlgId) {
GMAPIerr(GMAPI_F_EVP_PKEY_GET_SGD, ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
for (i = 0; i < OSSL_NELEM(gmapi_pkeys); i++) {
if (gmapi_pkeys[i].nid == EVP_PKEY_base_id(pkey)) {
*ulAlgId = gmapi_pkeys[i].ulAlgId;
return 1;
}
}
GMAPIerr(GMAPI_F_EVP_PKEY_GET_SGD, GMAPI_R_NOT_SUPPORTED_PKEY);
return 0;
}
int EVP_MD_sgd(const EVP_MD *md)
int EVP_PKEY_CTX_get_sgd(const EVP_PKEY_CTX *ctx, ULONG *ulAlgId)
{
return 0;
}
int EVP_CIPHER_sgd(const EVP_CIPHER *cipher)
{
return 0;
return EVP_PKEY_get_sgd(EVP_PKEY_CTX_get0_pkey((EVP_PKEY_CTX *)ctx), ulAlgId);
}

386
crypto/gmapi/gmapi_skf_ec.c
View File

@@ -48,12 +48,16 @@
*/
#include <stdio.h>
#include <openssl/sm2.h>
#include <openssl/ec.h>
#include <openssl/gmapi.h>
#include <openssl/skf.h>
#include "../ec/ec_lcl.h"
#include "../sm2/sm2_lcl.h"
#include "internal/cryptlib.h"
#if !defined(OPENSSL_NO_SKF) && !defined(OPENSSL_NO_EC)
# include <openssl/sm2.h>
# include <openssl/ec.h>
# include <openssl/gmapi.h>
# include <openssl/skf.h>
# include "../ec/ec_lcl.h"
# include "../sm2/sm2_lcl.h"
# include "../ecies/ecies_lcl.h"
EC_KEY *EC_KEY_new_from_ECCPUBLICKEYBLOB(const ECCPUBLICKEYBLOB *blob)
{
@@ -85,11 +89,11 @@ int EC_KEY_set_ECCPUBLICKEYBLOB(EC_KEY *ec_key, const ECCPUBLICKEYBLOB *blob)
return 0;
}
if (!(x = BN_bin2bn(blob->XCoordinate, ECC_MAX_XCOORDINATE_BITS_LEN/8, NULL))) {
if (!(x = BN_bin2bn(blob->XCoordinate, sizeof(blob->XCoordinate), NULL))) {
GMAPIerr(GMAPI_F_EC_KEY_SET_ECCPUBLICKEYBLOB, ERR_R_BN_LIB);
goto end;
}
if (!(y = BN_bin2bn(blob->YCoordinate, ECC_MAX_YCOORDINATE_BITS_LEN/8, NULL))) {
if (!(y = BN_bin2bn(blob->YCoordinate, sizeof(blob->YCoordinate), NULL))) {
GMAPIerr(GMAPI_F_EC_KEY_SET_ECCPUBLICKEYBLOB, ERR_R_BN_LIB);
goto end;
}
@@ -141,11 +145,11 @@ int EC_KEY_get_ECCPUBLICKEYBLOB(EC_KEY *ec_key, ECCPUBLICKEYBLOB *blob)
memset(blob, 0, sizeof(*blob));
blob->BitLen = EC_GROUP_get_degree(group);
if (!BN_bn2bin(x, blob->XCoordinate + (ECC_MAX_XCOORDINATE_BITS_LEN+7)/8 - BN_num_bytes(x))) {
if (!BN_bn2bin(x, blob->XCoordinate + sizeof(blob->XCoordinate) - BN_num_bytes(x))) {
GMAPIerr(GMAPI_F_EC_KEY_GET_ECCPUBLICKEYBLOB, ERR_R_BN_LIB);
goto end;
}
if (!BN_bn2bin(y, blob->YCoordinate + (ECC_MAX_YCOORDINATE_BITS_LEN+7)/8 - BN_num_bytes(y))) {
if (!BN_bn2bin(y, blob->YCoordinate + sizeof(blob->YCoordinate) - BN_num_bytes(y))) {
GMAPIerr(GMAPI_F_EC_KEY_GET_ECCPUBLICKEYBLOB, ERR_R_BN_LIB);
goto end;
}
@@ -187,7 +191,7 @@ int EC_KEY_set_ECCPRIVATEKEYBLOB(EC_KEY *ec_key, const ECCPRIVATEKEYBLOB *blob)
goto end;
}
if (!(d = BN_bin2bn(blob->PrivateKey, (ECC_MAX_MODULUS_BITS_LEN+7)/8, NULL))) {
if (!(d = BN_bin2bn(blob->PrivateKey, sizeof(blob->PrivateKey), NULL))) {
GMAPIerr(GMAPI_F_EC_KEY_SET_ECCPRIVATEKEYBLOB, ERR_R_BN_LIB);
goto end;
}
@@ -221,7 +225,7 @@ int EC_KEY_get_ECCPRIVATEKEYBLOB(EC_KEY *ec_key, ECCPRIVATEKEYBLOB *blob)
blob->BitLen = EC_GROUP_get_degree(EC_KEY_get0_group(ec_key));
if (!BN_bn2bin(d, blob->PrivateKey + (ECC_MAX_MODULUS_BITS_LEN+7)/8 - BN_num_bytes(d))) {
if (!BN_bn2bin(d, blob->PrivateKey + sizeof(blob->PrivateKey) - BN_num_bytes(d))) {
GMAPIerr(GMAPI_F_EC_KEY_GET_ECCPRIVATEKEYBLOB, ERR_R_BN_LIB);
return 0;
}
@@ -229,6 +233,7 @@ int EC_KEY_get_ECCPRIVATEKEYBLOB(EC_KEY *ec_key, ECCPRIVATEKEYBLOB *blob)
return 1;
}
# ifndef OPENSSL_NO_SM2
SM2CiphertextValue *SM2CiphertextValue_new_from_ECCCIPHERBLOB(
const ECCCIPHERBLOB *blob)
{
@@ -259,19 +264,19 @@ int SM2CiphertextValue_set_ECCCIPHERBLOB(SM2CiphertextValue *cv,
return 0;
}
if (!BN_bin2bn(blob->XCoordinate, ECC_MAX_XCOORDINATE_BITS_LEN/8,
if (!BN_bin2bn(blob->XCoordinate, sizeof(blob->XCoordinate),
cv->xCoordinate)) {
GMAPIerr(GMAPI_F_SM2CIPHERTEXTVALUE_SET_ECCCIPHERBLOB, ERR_R_BN_LIB);
goto end;
}
if (!BN_bin2bn(blob->YCoordinate, ECC_MAX_YCOORDINATE_BITS_LEN/8,
if (!BN_bin2bn(blob->YCoordinate, sizeof(blob->YCoordinate),
cv->yCoordinate)) {
GMAPIerr(GMAPI_F_SM2CIPHERTEXTVALUE_SET_ECCCIPHERBLOB, ERR_R_BN_LIB);
goto end;
}
if (!ASN1_OCTET_STRING_set(cv->hash, blob->HASH, 32)) {
if (!ASN1_OCTET_STRING_set(cv->hash, blob->HASH, sizeof(blob->HASH))) {
GMAPIerr(GMAPI_F_SM2CIPHERTEXTVALUE_SET_ECCCIPHERBLOB, ERR_R_ASN1_LIB);
goto end;
}
@@ -283,7 +288,7 @@ int SM2CiphertextValue_set_ECCCIPHERBLOB(SM2CiphertextValue *cv,
goto end;
}
ret = 0;
ret = 1;
end:
return ret;
}
@@ -291,8 +296,6 @@ end:
int SM2CiphertextValue_get_ECCCIPHERBLOB(const SM2CiphertextValue *cv,
ECCCIPHERBLOB *blob)
{
int ret = 0;
if (BN_num_bits(cv->xCoordinate) > ECC_MAX_XCOORDINATE_BITS_LEN ||
BN_num_bits(cv->yCoordinate) > ECC_MAX_YCOORDINATE_BITS_LEN) {
GMAPIerr(GMAPI_F_SM2CIPHERTEXTVALUE_GET_ECCCIPHERBLOB,
@@ -300,7 +303,7 @@ int SM2CiphertextValue_get_ECCCIPHERBLOB(const SM2CiphertextValue *cv,
return 0;
}
if (ASN1_STRING_length(cv->hash) != 32) {
if (ASN1_STRING_length(cv->hash) != sizeof(blob->HASH)) {
GMAPIerr(GMAPI_F_SM2CIPHERTEXTVALUE_GET_ECCCIPHERBLOB,
GMAPI_R_INVALID_CIPHERTEXT_LENGTH);
return 0;
@@ -314,12 +317,12 @@ int SM2CiphertextValue_get_ECCCIPHERBLOB(const SM2CiphertextValue *cv,
}
if (!BN_bn2bin(cv->xCoordinate, blob->XCoordinate +
ECC_MAX_XCOORDINATE_BITS_LEN/8 - BN_num_bytes(cv->xCoordinate))) {
sizeof(blob->XCoordinate) - BN_num_bytes(cv->xCoordinate))) {
GMAPIerr(GMAPI_F_SM2CIPHERTEXTVALUE_GET_ECCCIPHERBLOB, ERR_R_BN_LIB);
return 0;
}
if (!BN_bn2bin(cv->yCoordinate, blob->YCoordinate +
ECC_MAX_YCOORDINATE_BITS_LEN/8 - BN_num_bytes(cv->yCoordinate))) {
sizeof(blob->YCoordinate) - BN_num_bytes(cv->yCoordinate))) {
GMAPIerr(GMAPI_F_SM2CIPHERTEXTVALUE_GET_ECCCIPHERBLOB, ERR_R_BN_LIB);
return 0;
}
@@ -333,6 +336,7 @@ int SM2CiphertextValue_get_ECCCIPHERBLOB(const SM2CiphertextValue *cv,
return 1;
}
# endif /* OPENSSL_NO_SM2 */
ECDSA_SIG *ECDSA_SIG_new_from_ECCSIGNATUREBLOB(const ECCSIGNATUREBLOB *blob)
{
@@ -356,12 +360,15 @@ ECDSA_SIG *ECDSA_SIG_new_from_ECCSIGNATUREBLOB(const ECCSIGNATUREBLOB *blob)
int ECDSA_SIG_set_ECCSIGNATUREBLOB(ECDSA_SIG *sig, const ECCSIGNATUREBLOB *blob)
{
if (!(sig->r = BN_bin2bn(blob->r, 64, sig->r))) {
OPENSSL_assert(sig->r);
OPENSSL_assert(sig->s);
if (!(sig->r = BN_bin2bn(blob->r, sizeof(blob->r), sig->r))) {
GMAPIerr(GMAPI_F_ECDSA_SIG_SET_ECCSIGNATUREBLOB, ERR_R_BN_LIB);
return 0;
}
if (!(sig->s = BN_bin2bn(blob->s, 64, sig->s))) {
if (!(sig->s = BN_bin2bn(blob->s, sizeof(blob->s), sig->s))) {
GMAPIerr(GMAPI_F_ECDSA_SIG_SET_ECCSIGNATUREBLOB, ERR_R_BN_LIB);
return 0;
}
@@ -371,20 +378,347 @@ int ECDSA_SIG_set_ECCSIGNATUREBLOB(ECDSA_SIG *sig, const ECCSIGNATUREBLOB *blob)
int ECDSA_SIG_get_ECCSIGNATUREBLOB(const ECDSA_SIG *sig, ECCSIGNATUREBLOB *blob)
{
if ((BN_num_bytes(sig->r) > 256/8) || (BN_num_bytes(sig->s) > 256/8)) {
if ((BN_num_bytes(sig->r) > sizeof(blob->r)) || (BN_num_bytes(sig->s) > sizeof(blob->s))) {
GMAPIerr(GMAPI_F_ECDSA_SIG_GET_ECCSIGNATUREBLOB, GMAPI_R_INVALID_BIGNUM_LENGTH);
return 0;
}
if (!BN_bn2bin(sig->r, blob->r + 256/8 - BN_num_bytes(sig->r))) {
if (!BN_bn2bin(sig->r, blob->r + sizeof(blob->r) - BN_num_bytes(sig->r))) {
GMAPIerr(GMAPI_F_ECDSA_SIG_GET_ECCSIGNATUREBLOB, ERR_R_BN_LIB);
return 0;
}
if (!BN_bn2bin(sig->s, blob->s + 256/8 - BN_num_bytes(sig->s))) {
if (!BN_bn2bin(sig->s, blob->s + sizeof(blob->s) - BN_num_bytes(sig->s))) {
GMAPIerr(GMAPI_F_ECDSA_SIG_GET_ECCSIGNATUREBLOB, ERR_R_BN_LIB);
return 0;
}
return 1;
}
int ECCPRIVATEKEYBLOB_set_private_key(ECCPRIVATEKEYBLOB *blob,
const BIGNUM *priv_key)
{
if (BN_num_bytes(priv_key) > 32) {
GMAPIerr(GMAPI_F_ECCPRIVATEKEYBLOB_SET_PRIVATE_KEY,
GMAPI_R_INVALID_SM2_PRIVATE_KEY);
return 0;
}
blob->BitLen = 256;
memset(blob->PrivateKey, 0, sizeof(blob->PrivateKey));
BN_bn2bin(priv_key, blob->PrivateKey + sizeof(blob->PrivateKey)
- BN_num_bytes(priv_key));
return 1;
}
# ifndef OPENSSL_NO_ECIES
ECIES_CIPHERTEXT_VALUE *ECIES_CIPHERTEXT_VALUE_new_from_ECCCIPHERBLOB(const ECCCIPHERBLOB *blob)
{
ECIES_CIPHERTEXT_VALUE *ret = NULL;
if (!(ret = ECIES_CIPHERTEXT_VALUE_new())) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_NEW_FROM_ECCCIPHERBLOB,
ERR_R_MALLOC_FAILURE);
return NULL;
}
if (!ECIES_CIPHERTEXT_VALUE_set_ECCCIPHERBLOB(ret, blob)) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_NEW_FROM_ECCCIPHERBLOB,
ERR_R_GMAPI_LIB);
ECIES_CIPHERTEXT_VALUE_free(ret);
return NULL;
}
return ret;
}
int ECIES_CIPHERTEXT_VALUE_set_ECCCIPHERBLOB(ECIES_CIPHERTEXT_VALUE *cv, const ECCCIPHERBLOB *blob)
{
int ret = 0;
BIGNUM *x = NULL;
BIGNUM *y = NULL;
EC_GROUP *group = NULL;
EC_POINT *point = NULL;
BN_CTX *bn_ctx = NULL;
size_t len;
if (!cv || !blob) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_SET_ECCCIPHERBLOB,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if (!(x = BN_bin2bn(blob->XCoordinate, sizeof(blob->XCoordinate), NULL))) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_SET_ECCCIPHERBLOB, ERR_R_BN_LIB);
goto end;
}
if (!(y = BN_bin2bn(blob->YCoordinate, sizeof(blob->YCoordinate), NULL))) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_SET_ECCCIPHERBLOB, ERR_R_BN_LIB);
goto end;
}
if (!(group = EC_GROUP_new_by_curve_name(NID_sm2p256v1))) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_SET_ECCCIPHERBLOB, ERR_R_EC_LIB);
goto end;
}
if (!(point = EC_POINT_new(group))) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_SET_ECCCIPHERBLOB, ERR_R_MALLOC_FAILURE);
goto end;
}
if (!(bn_ctx = BN_CTX_new())) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_SET_ECCCIPHERBLOB, ERR_R_MALLOC_FAILURE);
goto end;
}
if (!EC_POINT_set_affine_coordinates_GFp(group, point, x, y, bn_ctx)) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_SET_ECCCIPHERBLOB, ERR_R_EC_LIB);
goto end;
}
if (!(len = EC_POINT_point2oct(group, point, POINT_CONVERSION_UNCOMPRESSED, NULL, 0, bn_ctx))) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_SET_ECCCIPHERBLOB, ERR_R_EC_LIB);
goto end;
}
if (!ASN1_OCTET_STRING_set(cv->ephem_point, NULL, (int)len)) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_SET_ECCCIPHERBLOB, ERR_R_MALLOC_FAILURE);
goto end;
}
if (EC_POINT_point2oct(group, point, POINT_CONVERSION_UNCOMPRESSED, cv->ephem_point->data, len, bn_ctx) != len) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_SET_ECCCIPHERBLOB, ERR_R_EC_LIB);
goto end;
}
if (!ASN1_OCTET_STRING_set(cv->ciphertext, blob->Cipher, blob->CipherLen)) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_SET_ECCCIPHERBLOB, ERR_R_MALLOC_FAILURE);
goto end;
}
if (!ASN1_OCTET_STRING_set(cv->mactag, blob->HASH, sizeof(blob->HASH))) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_SET_ECCCIPHERBLOB, ERR_R_MALLOC_FAILURE);
goto end;
}
ret = 1;
end:
BN_free(x);
BN_free(y);
EC_GROUP_free(group);
EC_POINT_free(point);
BN_CTX_free(bn_ctx);
return ret;
}
int ECIES_CIPHERTEXT_VALUE_get_ECCCIPHERBLOB(const ECIES_CIPHERTEXT_VALUE *cv, ECCCIPHERBLOB *blob)
{
int ret = 0;
EC_GROUP *group = NULL;
EC_POINT *point = NULL;
BIGNUM *x = NULL;
BIGNUM *y = NULL;
BN_CTX *bn_ctx = NULL;
if (!(group = EC_GROUP_new_by_curve_name(NID_sm2p256v1))) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_GET_ECCCIPHERBLOB, ERR_R_EC_LIB);
goto end;
}
if (!(point = EC_POINT_new(group))) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_GET_ECCCIPHERBLOB, ERR_R_EC_LIB);
goto end;
}
if (!(x = BN_new())) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_GET_ECCCIPHERBLOB, ERR_R_MALLOC_FAILURE);
goto end;
}
if (!(y = BN_new())) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_GET_ECCCIPHERBLOB, ERR_R_MALLOC_FAILURE);
goto end;
}
if (!(bn_ctx = BN_CTX_new())) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_GET_ECCCIPHERBLOB, ERR_R_MALLOC_FAILURE);
goto end;
}
if (!EC_POINT_oct2point(group, point, ASN1_STRING_get0_data(cv->ephem_point), ASN1_STRING_length(cv->ephem_point), bn_ctx)) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_GET_ECCCIPHERBLOB, ERR_R_EC_LIB);
goto end;
}
if (!EC_POINT_get_affine_coordinates_GFp(group, point, x, y, bn_ctx)) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_GET_ECCCIPHERBLOB, ERR_R_EC_LIB);
goto end;
}
if (BN_num_bytes(x) > sizeof(blob->XCoordinate)) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_GET_ECCCIPHERBLOB, GMAPI_R_INVALID_SKF_EC_CIPHERTEXT);
goto end;
}
BN_bn2bin(x, blob->XCoordinate + sizeof(blob->XCoordinate) - BN_num_bytes(x));
if (BN_num_bytes(y) > sizeof(blob->YCoordinate)) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_GET_ECCCIPHERBLOB, GMAPI_R_INVALID_SKF_EC_CIPHERTEXT);
goto end;
}
BN_bn2bin(y, blob->YCoordinate + sizeof(blob->YCoordinate) - BN_num_bytes(y));
if (ASN1_STRING_length(cv->mactag) != sizeof(blob->HASH)) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_GET_ECCCIPHERBLOB, GMAPI_R_INVALID_SKF_EC_CIPHERTEXT);
goto end;
}
memcpy(blob->HASH, ASN1_STRING_get0_data(cv->mactag), ASN1_STRING_length(cv->mactag));
//FIXME: check input ?
blob->CipherLen = ASN1_STRING_length(cv->ciphertext);
memcpy(blob->Cipher, ASN1_STRING_get0_data(cv->ciphertext),
ASN1_STRING_length(cv->ciphertext));
end:
EC_GROUP_free(group);
EC_POINT_free(point);
BN_free(x);
BN_free(y);
BN_CTX_free(bn_ctx);
return ret;
}
# endif /* OPENSSL_NO_ECIES */
ECCCIPHERBLOB *d2i_ECCCIPHERBLOB(ECCCIPHERBLOB **a, const unsigned char **pp, long length)
{
ECCCIPHERBLOB *ret = NULL;
ECCCIPHERBLOB *blob = NULL;
SM2CiphertextValue *cv = NULL;
if (!(cv = d2i_SM2CiphertextValue(NULL, pp, length))) {
GMAPIerr(GMAPI_F_D2I_ECCCIPHERBLOB, ERR_R_SM2_LIB);
goto end;
}
if (!(blob = OPENSSL_malloc(sizeof(ECCCIPHERBLOB) - 1 + ASN1_STRING_length(cv->ciphertext)))) {
GMAPIerr(GMAPI_F_D2I_ECCCIPHERBLOB, ERR_R_MALLOC_FAILURE);
goto end;
}
blob->CipherLen = ASN1_STRING_length(cv->ciphertext);
if (!SM2CiphertextValue_get_ECCCIPHERBLOB(cv, blob)) {
GMAPIerr(GMAPI_F_D2I_ECCCIPHERBLOB, ERR_R_GMAPI_LIB);
goto end;
}
ret = blob;
blob = NULL;
end:
OPENSSL_free(blob);
SM2CiphertextValue_free(cv);
return ret;
}
int i2d_ECCCIPHERBLOB(ECCCIPHERBLOB *a, unsigned char **pp)
{
int ret;
SM2CiphertextValue *cv = NULL;
if (!(cv = SM2CiphertextValue_new_from_ECCCIPHERBLOB(a))) {
GMAPIerr(GMAPI_F_I2D_ECCCIPHERBLOB, GMAPI_R_INVALID_SKF_CIPHERTEXT);
return 0;
}
if ((ret = i2d_SM2CiphertextValue(cv, pp)) <= 0) {
}
SM2CiphertextValue_free(cv);
return ret;
}
ECCCIPHERBLOB *d2i_ECCCIPHERBLOB_bio(BIO *bp, ECCCIPHERBLOB **a)
{
GMAPIerr(GMAPI_F_D2I_ECCCIPHERBLOB_BIO, GMAPI_R_NOT_IMPLEMENTED);
return NULL;
}
int i2d_ECCCIPHERBLOB_bio(BIO *bp, ECCCIPHERBLOB *a)
{
GMAPIerr(GMAPI_F_I2D_ECCCIPHERBLOB_BIO, GMAPI_R_NOT_IMPLEMENTED);
return 0;
}
ECCSIGNATUREBLOB *d2i_ECCSIGNATUREBLOB(ECCSIGNATUREBLOB **a, const unsigned char **pp, long length)
{
ECCSIGNATUREBLOB *ret = NULL;
ECCSIGNATUREBLOB *blob = NULL;
ECDSA_SIG *sig = NULL;
if (!(sig = d2i_ECDSA_SIG(NULL, pp, length))) {
GMAPIerr(GMAPI_F_D2I_ECCSIGNATUREBLOB, ERR_R_EC_LIB);
goto end;
}
if (!(blob = OPENSSL_malloc(sizeof(ECCSIGNATUREBLOB)))) {
GMAPIerr(GMAPI_F_D2I_ECCSIGNATUREBLOB, ERR_R_MALLOC_FAILURE);
goto end;
}
if (!ECDSA_SIG_get_ECCSIGNATUREBLOB(sig, blob)) {
GMAPIerr(GMAPI_F_D2I_ECCSIGNATUREBLOB, ERR_R_GMAPI_LIB);
goto end;
}
ret = blob;
blob = NULL;
end:
OPENSSL_free(blob);
ECDSA_SIG_free(sig);
return ret;
}
int i2d_ECCSIGNATUREBLOB(ECCSIGNATUREBLOB *a, unsigned char **pp)
{
int ret;
ECDSA_SIG *sig = NULL;
if (!(sig = ECDSA_SIG_new_from_ECCSIGNATUREBLOB(a))) {
GMAPIerr(GMAPI_F_I2D_ECCSIGNATUREBLOB, ERR_R_GMAPI_LIB);
return 0;
}
ret = i2d_ECDSA_SIG(sig, pp);
ECDSA_SIG_free(sig);
return ret;
}
ECCSIGNATUREBLOB *d2i_ECCSIGNATUREBLOB_bio(BIO *bp, ECCSIGNATUREBLOB **a)
{
GMAPIerr(GMAPI_F_D2I_ECCSIGNATUREBLOB_BIO, GMAPI_R_NOT_IMPLEMENTED);
return NULL;
}
int i2d_ECCSIGNATUREBLOB_bio(BIO *fp, ECCSIGNATUREBLOB *a)
{
GMAPIerr(GMAPI_F_I2D_ECCSIGNATUREBLOB_BIO, GMAPI_R_NOT_IMPLEMENTED);
return 0;
}
# ifndef OPENSSL_NO_STDIO
ECCCIPHERBLOB *d2i_ECCCIPHERBLOB_fp(FILE *fp, ECCCIPHERBLOB **a)
{
GMAPIerr(GMAPI_F_D2I_ECCCIPHERBLOB_FP, GMAPI_R_NOT_IMPLEMENTED);
return NULL;
}
int i2d_ECCCIPHERBLOB_fp(FILE *fp, ECCCIPHERBLOB *a)
{
GMAPIerr(GMAPI_F_I2D_ECCCIPHERBLOB_FP, GMAPI_R_NOT_IMPLEMENTED);
return 0;
}
ECCSIGNATUREBLOB *d2i_ECCSIGNATUREBLOB_fp(FILE *fp, ECCSIGNATUREBLOB **a)
{
GMAPIerr(GMAPI_F_D2I_ECCSIGNATUREBLOB_FP, GMAPI_R_NOT_IMPLEMENTED);
return NULL;
}
int i2d_ECCSIGNATUREBLOB_fp(FILE *fp, ECCSIGNATUREBLOB *a)
{
GMAPIerr(GMAPI_F_I2D_ECCSIGNATUREBLOB_FP, GMAPI_R_NOT_IMPLEMENTED);
return 0;
}
# endif /* OPENSSL_NO_STDIO */
#endif

616
crypto/gmapi/gmapi_skf_rsa.c
View File

@@ -1,214 +1,402 @@
/* ====================================================================
* Copyright (c) 2015-2016 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/rsa.h>
#include <openssl/skf.h>
#include <openssl/gmapi.h>
#include "../rsa/rsa_locl.h"
/* Wrapper functions */
RSA *RSA_new_from_RSAPUBLICKEYBLOB(const RSAPUBLICKEYBLOB *blob)
{
RSA *ret;
if (!(ret = RSA_new())) {
GMAPIerr(GMAPI_F_RSA_NEW_FROM_RSAPUBLICKEYBLOB, ERR_R_RSA_LIB);
return NULL;
}
if (!RSA_set_RSAPUBLICKEYBLOB(ret, blob)) {
GMAPIerr(GMAPI_F_RSA_NEW_FROM_RSAPUBLICKEYBLOB,
GMAPI_R_INVALID_RSA_PUBLIC_KEY);
RSA_free(ret);
return NULL;
}
return ret;
}
RSA *RSA_new_from_RSAPRIVATEKEYBLOB(const RSAPRIVATEKEYBLOB *blob)
{
RSA *ret;
if (!(ret = RSA_new())) {
GMAPIerr(GMAPI_F_RSA_NEW_FROM_RSAPRIVATEKEYBLOB, ERR_R_RSA_LIB);
return NULL;
}
if (!RSA_set_RSAPRIVATEKEYBLOB(ret, blob)) {
GMAPIerr(GMAPI_F_RSA_NEW_FROM_RSAPRIVATEKEYBLOB,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
RSA_free(ret);
return NULL;
}
return ret;
}
int RSA_set_RSAPUBLICKEYBLOB(RSA *rsa, const RSAPUBLICKEYBLOB *blob)
{
if (!rsa || !blob) {
GMAPIerr(GMAPI_F_RSA_SET_RSAPUBLICKEYBLOB,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if ((blob->BitLen < 1024) || (blob->BitLen > MAX_RSA_MODULUS_LEN*8) ||
(blob->BitLen / 8 != 0)) {
GMAPIerr(GMAPI_F_RSA_SET_RSAPUBLICKEYBLOB,
GMAPI_R_INVALID_RSA_KEY_LENGTH);
return 0;
}
if (!(rsa->n = BN_bin2bn(blob->Modulus, blob->BitLen/8, rsa->n))) {
GMAPIerr(GMAPI_F_RSA_SET_RSAPUBLICKEYBLOB,
GMAPI_R_INVALID_RSA_PUBLIC_KEY);
return 0;
}
if (!(rsa->e = BN_bin2bn(blob->PublicExponent, MAX_RSA_EXPONENT_LEN,
rsa->e))) {
GMAPIerr(GMAPI_F_RSA_SET_RSAPUBLICKEYBLOB,
GMAPI_R_INVALID_RSA_PUBLIC_KEY);
return 0;
}
if (!RSA_check_key(rsa)) {
GMAPIerr(GMAPI_F_RSA_SET_RSAPUBLICKEYBLOB,
GMAPI_R_INVALID_RSA_PUBLIC_KEY);
return 0;
}
return 1;
}
int RSA_get_RSAPUBLICKEYBLOB(RSA *rsa, RSAPUBLICKEYBLOB *blob)
{
int nbytes;
if (!rsa || !blob) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPUBLICKEYBLOB,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if (!rsa->n || !rsa->e) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPUBLICKEYBLOB,
GMAPI_R_INVALID_RSA_PUBLIC_KEY);
return 0;
}
nbytes = BN_num_bytes(rsa->n);
if (!BN_bn2bin(rsa->n, blob->Modulus) || !BN_bn2bin(rsa->e,
blob->PublicExponent + MAX_RSA_EXPONENT_LEN - BN_num_bytes(rsa->e))) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPUBLICKEYBLOB,
GMAPI_R_ENCODE_RSA_PUBLIC_KEY_FAILED);
return 0;
}
return 1;
}
int RSA_set_RSAPRIVATEKEYBLOB(RSA *rsa, const RSAPRIVATEKEYBLOB *blob)
{
int nbytes;
if (!rsa || !blob) {
GMAPIerr(GMAPI_F_RSA_SET_RSAPRIVATEKEYBLOB,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if (blob->AlgID != SGD_RSA) {
GMAPIerr(GMAPI_F_RSA_SET_RSAPRIVATEKEYBLOB,
GMAPI_R_INVALID_ALGOR);
return 0;
}
if ((blob->BitLen < 1024) || (blob->BitLen > MAX_RSA_MODULUS_LEN*8) ||
(blob->BitLen % 8 != 0) || (blob->BitLen % 16 != 0)) {
GMAPIerr(GMAPI_F_RSA_SET_RSAPRIVATEKEYBLOB,
GMAPI_R_INVALID_KEY_LENGTH);
return 0;
}
nbytes = blob->BitLen/8;
if (!(rsa->n = BN_bin2bn(blob->Modulus, nbytes, rsa->n)) ||
!(rsa->e = BN_bin2bn(blob->PublicExponent, MAX_RSA_EXPONENT_LEN, rsa->e)) ||
!(rsa->d = BN_bin2bn(blob->PrivateExponent, nbytes, rsa->d)) ||
!(rsa->p = BN_bin2bn(blob->Prime1, nbytes/2, rsa->p)) ||
!(rsa->q = BN_bin2bn(blob->Prime2, nbytes/2, rsa->q)) ||
!(rsa->dmp1 = BN_bin2bn(blob->Prime1Exponent, nbytes/2, rsa->dmp1)) ||
!(rsa->dmq1 = BN_bin2bn(blob->Prime2Exponent, nbytes/2, rsa->dmq1)) ||
!(rsa->iqmp = BN_bin2bn(blob->Coefficient, nbytes/2, rsa->iqmp))) {
GMAPIerr(GMAPI_F_RSA_SET_RSAPRIVATEKEYBLOB, GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
return 1;
}
int RSA_get_RSAPRIVATEKEYBLOB(RSA *rsa, RSAPRIVATEKEYBLOB *blob)
{
int nbytes;
if (!rsa || !blob) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPRIVATEKEYBLOB,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if (!rsa->n || !rsa->e || !rsa->d || !rsa->p || !rsa->q ||
!rsa->dmp1 || !rsa->dmq1 || !rsa->iqmp) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPRIVATEKEYBLOB,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
memset(blob, 0, sizeof(*blob));
blob->AlgID = SGD_RSA;
blob->BitLen = BN_num_bits(rsa->n);
nbytes = BN_num_bytes(rsa->n);
if (!BN_bn2bin(rsa->n, blob->Modulus) ||
!BN_bn2bin(rsa->e, blob->PublicExponent + MAX_RSA_EXPONENT_LEN - BN_num_bytes(rsa->e)) ||
!BN_bn2bin(rsa->d, blob->PrivateExponent + nbytes - BN_num_bytes(rsa->d)) ||
!BN_bn2bin(rsa->p, blob->Prime1 + nbytes/2 - BN_num_bytes(rsa->p)) ||
!BN_bn2bin(rsa->q, blob->Prime2 + nbytes/2 - BN_num_bytes(rsa->q)) ||
!BN_bn2bin(rsa->dmp1, blob->Prime1Exponent + nbytes/2 - BN_num_bytes(rsa->dmp1)) ||
!BN_bn2bin(rsa->dmq1, blob->Prime2Exponent + nbytes/2 - BN_num_bytes(rsa->dmq1)) ||
!BN_bn2bin(rsa->iqmp, blob->Coefficient + nbytes/2 - BN_num_bytes(rsa->iqmp))) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPRIVATEKEYBLOB, GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
return 1;
}
/* ====================================================================
* Copyright (c) 2015-2016 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 "internal/cryptlib.h"
#if !defined(OPENSSL_NO_SKF) && !defined(OPENSSL_NO_RSA)
# include <openssl/err.h>
# include <openssl/rsa.h>
# include <openssl/skf.h>
# include <openssl/gmapi.h>
/* Wrapper functions */
RSA *RSA_new_from_RSAPUBLICKEYBLOB(const RSAPUBLICKEYBLOB *blob)
{
RSA *ret = NULL;
RSA *rsa = NULL;
if (!blob) {
GMAPIerr(GMAPI_F_RSA_NEW_FROM_RSAPUBLICKEYBLOB,
ERR_R_PASSED_NULL_PARAMETER);
return NULL;
}
if (!(rsa = RSA_new())) {
GMAPIerr(GMAPI_F_RSA_NEW_FROM_RSAPUBLICKEYBLOB,
ERR_R_MALLOC_FAILURE);
return NULL;
}
if (!RSA_set_RSAPUBLICKEYBLOB(rsa, blob)) {
GMAPIerr(GMAPI_F_RSA_NEW_FROM_RSAPUBLICKEYBLOB,
GMAPI_R_INVALID_RSA_PUBLIC_KEY);
goto end;
}
ret = rsa;
rsa = NULL;
end:
RSA_free(rsa);
return ret;
}
int RSA_set_RSAPUBLICKEYBLOB(RSA *rsa, const RSAPUBLICKEYBLOB *blob)
{
int ret = 0;
BIGNUM *n = NULL;
BIGNUM *e = NULL;
if (!rsa || !blob) {
GMAPIerr(GMAPI_F_RSA_SET_RSAPUBLICKEYBLOB,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if ((blob->BitLen < OPENSSL_RSA_FIPS_MIN_MODULUS_BITS)
|| (blob->BitLen > sizeof(blob->Modulus) * 8)
|| (blob->BitLen % 8 != 0)) {
GMAPIerr(GMAPI_F_RSA_SET_RSAPUBLICKEYBLOB,
GMAPI_R_INVALID_RSA_KEY_LENGTH);
return 0;
}
if (!(n = BN_bin2bn(blob->Modulus, sizeof(blob->Modulus), NULL))) {
GMAPIerr(GMAPI_F_RSA_SET_RSAPUBLICKEYBLOB,
GMAPI_R_INVALID_RSA_PUBLIC_KEY);
goto end;
}
if (!(e = BN_bin2bn(blob->PublicExponent,
sizeof(blob->PublicExponent), NULL))) {
GMAPIerr(GMAPI_F_RSA_SET_RSAPUBLICKEYBLOB,
GMAPI_R_INVALID_RSA_PUBLIC_KEY);
goto end;
}
if (!RSA_set0_key(rsa, n, e, NULL)) {
GMAPIerr(GMAPI_F_RSA_SET_RSAPUBLICKEYBLOB,
GMAPI_R_INVALID_RSA_PUBLIC_KEY);
goto end;
}
n = NULL;
e = NULL;
ret = 1;
end:
BN_free(n);
BN_free(e);
return ret;
}
int RSA_get_RSAPUBLICKEYBLOB(RSA *rsa, RSAPUBLICKEYBLOB *blob)
{
const BIGNUM *n;
const BIGNUM *e;
if (!rsa || !blob) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPUBLICKEYBLOB,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
RSA_get0_key(rsa, &n, &e, NULL);
if (!n || !e) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPUBLICKEYBLOB,
GMAPI_R_INVALID_RSA_PUBLIC_KEY);
return 0;
}
if (RSA_bits(rsa) > sizeof(blob->Modulus) * 8
|| RSA_bits(rsa) % 8 != 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPUBLICKEYBLOB,
GMAPI_R_INVALID_RSA_PUBLIC_KEY);
return 0;
}
memset(blob, 0, sizeof(RSAPUBLICKEYBLOB));
blob->AlgID = SGD_RSA;
blob->BitLen = RSA_bits(rsa);
if (BN_bn2bin(n, blob->Modulus +
sizeof(blob->Modulus) - BN_num_bytes(n)) <= 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPUBLICKEYBLOB,
GMAPI_R_ENCODE_RSA_PUBLIC_KEY_FAILED);
return 0;
}
if (BN_bn2bin(e, blob->PublicExponent +
sizeof(blob->PublicExponent) - BN_num_bytes(e)) <= 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPUBLICKEYBLOB,
GMAPI_R_ENCODE_RSA_PUBLIC_KEY_FAILED);
return 0;
}
return 1;
}
RSA *RSA_new_from_RSAPRIVATEKEYBLOB(const RSAPRIVATEKEYBLOB *blob)
{
RSA *ret = NULL;
RSA *rsa = NULL;
if (!blob) {
GMAPIerr(GMAPI_F_RSA_NEW_FROM_RSAPRIVATEKEYBLOB,
ERR_R_PASSED_NULL_PARAMETER);
return NULL;
}
if (!(rsa = RSA_new())) {
GMAPIerr(GMAPI_F_RSA_NEW_FROM_RSAPRIVATEKEYBLOB,
ERR_R_MALLOC_FAILURE);
return NULL;
}
if (!RSA_set_RSAPRIVATEKEYBLOB(rsa, blob)) {
GMAPIerr(GMAPI_F_RSA_NEW_FROM_RSAPRIVATEKEYBLOB,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
goto end;
}
ret = rsa;
rsa = NULL;
end:
RSA_free(rsa);
return ret;
}
int RSA_set_RSAPRIVATEKEYBLOB(RSA *rsa, const RSAPRIVATEKEYBLOB *blob)
{
int ret = 0;
BIGNUM *n = NULL;
BIGNUM *e = NULL;
BIGNUM *d = NULL;
BIGNUM *p = NULL;
BIGNUM *q = NULL;
BIGNUM *dmp1 = NULL;
BIGNUM *dmq1 = NULL;
BIGNUM *iqmp = NULL;
if (!rsa || !blob) {
GMAPIerr(GMAPI_F_RSA_SET_RSAPRIVATEKEYBLOB,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if (blob->AlgID != SGD_RSA) {
GMAPIerr(GMAPI_F_RSA_SET_RSAPRIVATEKEYBLOB,
GMAPI_R_INVALID_ALGOR);
return 0;
}
if (blob->BitLen < OPENSSL_RSA_FIPS_MIN_MODULUS_BITS
|| blob->BitLen > sizeof(blob->Modulus) * 8
|| blob->BitLen % 8 != 0
|| blob->BitLen % 16 != 0) {
GMAPIerr(GMAPI_F_RSA_SET_RSAPRIVATEKEYBLOB,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if (!(n = BN_bin2bn(blob->Modulus, sizeof(blob->Modulus), NULL))
|| !(e = BN_bin2bn(blob->PublicExponent, sizeof(blob->PublicExponent), NULL))
|| !(d = BN_bin2bn(blob->PrivateExponent, sizeof(blob->PrivateExponent), NULL))
|| !(p = BN_bin2bn(blob->Prime1, sizeof(blob->Prime1), NULL))
|| !(q = BN_bin2bn(blob->Prime2, sizeof(blob->Prime2), NULL))
|| !(dmp1 = BN_bin2bn(blob->Prime1Exponent, sizeof(blob->Prime1Exponent), NULL))
|| !(dmq1 = BN_bin2bn(blob->Prime2Exponent, sizeof(blob->Prime2Exponent), NULL))
|| !(iqmp = BN_bin2bn(blob->Coefficient, sizeof(blob->Coefficient), NULL))) {
GMAPIerr(GMAPI_F_RSA_SET_RSAPRIVATEKEYBLOB, ERR_R_BN_LIB);
goto end;
}
if (!RSA_set0_key(rsa, n, e, d)) {
GMAPIerr(GMAPI_F_RSA_SET_RSAPRIVATEKEYBLOB,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
goto end;
}
n = NULL;
e = NULL;
d = NULL;
if (!RSA_set0_factors(rsa, p, q)) {
GMAPIerr(GMAPI_F_RSA_SET_RSAPRIVATEKEYBLOB,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
goto end;
}
p = NULL;
q = NULL;
if (!RSA_set0_crt_params(rsa, dmp1, dmq1, iqmp)) {
GMAPIerr(GMAPI_F_RSA_SET_RSAPRIVATEKEYBLOB,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
goto end;
}
dmp1 = NULL;
dmq1 = NULL;
iqmp = NULL;
ret = 1;
end:
BN_free(n);
BN_free(e);
BN_free(d);
BN_free(p);
BN_free(q);
BN_free(dmp1);
BN_free(dmq1);
BN_free(iqmp);
return ret;
}
int RSA_get_RSAPRIVATEKEYBLOB(RSA *rsa, RSAPRIVATEKEYBLOB *blob)
{
const BIGNUM *n;
const BIGNUM *e;
const BIGNUM *d;
const BIGNUM *p;
const BIGNUM *q;
const BIGNUM *dmp1;
const BIGNUM *dmq1;
const BIGNUM *iqmp;
if (!rsa || !blob) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPRIVATEKEYBLOB,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if (RSA_bits(rsa) > sizeof(blob->Modulus) * 8
|| RSA_bits(rsa) % 8 != 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPRIVATEKEYBLOB,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
RSA_get0_key(rsa, &n, &e, &d);
RSA_get0_factors(rsa, &p, &q);
RSA_get0_crt_params(rsa, &dmp1, &dmq1, &iqmp);
if (!n || !e || !d) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPRIVATEKEYBLOB,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
memset(blob, 0, sizeof(RSAPRIVATEKEYBLOB));
blob->AlgID = SGD_RSA;
blob->BitLen = RSA_bits(rsa);
if (BN_bn2bin(n, blob->Modulus +
sizeof(blob->Modulus) - BN_num_bytes(n)) <= 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPRIVATEKEYBLOB,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
if (BN_bn2bin(e, blob->PublicExponent +
sizeof(blob->PublicExponent) - BN_num_bytes(e)) <= 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPRIVATEKEYBLOB,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
if (BN_bn2bin(d, blob->PrivateExponent +
sizeof(blob->PrivateExponent) - BN_num_bytes(d)) <= 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPRIVATEKEYBLOB,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
if (p && BN_bn2bin(p, blob->Prime1 +
sizeof(blob->Prime1) - BN_num_bytes(p)) < 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPRIVATEKEYBLOB,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
if (q && BN_bn2bin(q, blob->Prime2 +
sizeof(blob->Prime2) - BN_num_bytes(q)) < 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPRIVATEKEYBLOB,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
if (dmp1 && BN_bn2bin(dmp1, blob->Prime1Exponent +
sizeof(blob->Prime1Exponent) - BN_num_bytes(dmp1)) < 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPRIVATEKEYBLOB,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
if (dmq1 && BN_bn2bin(dmq1, blob->Prime2Exponent +
sizeof(blob->Prime2Exponent) - BN_num_bytes(dmq1)) < 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPRIVATEKEYBLOB,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
if (iqmp && BN_bn2bin(iqmp, blob->Coefficient +
sizeof(blob->Coefficient) - BN_num_bytes(iqmp)) < 0) {
GMAPIerr(GMAPI_F_RSA_GET_RSAPRIVATEKEYBLOB,
GMAPI_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
return 1;
}
#endif