❤️❤️【GmSSL】openssl与国密18接口之间的相互转换

古城微笑少年丶 2022-10-29 07:50 189阅读 0赞

>  /\* SDF \*/
> 
> \#define RSAref\_MAX\_BITS         2048
> 
> \#define RSAref\_MAX\_LEN          ((RSAref\_MAX\_BITS + 7) / 8)
> 
> \#define RSAref\_MAX\_PBITS        ((RSAref\_MAX\_BITS + 1) / 2)
> 
> \#define RSAref\_MAX\_PLEN         ((RSAref\_MAX\_PBITS + 7)/ 8)
> 
> **//注意这边ECCref\_MAX\_BITS的位数，设置不对，可能会导致段错误**
> 
> \#ifdef SGD\_MAX\_ECC\_BITS\_256
> 
> \#define ECCref\_MAX\_BITS         256
> 
> \#else
> 
> \#define ECCref\_MAX\_BITS         512
> 
> \#endif
> 
> \#define ECCref\_MAX\_LEN          ((ECCref\_MAX\_BITS+7) / 8)

> struct **ec\_key\_st** \{
> 
> const EC\_KEY\_METHOD \*meth;
> 
> ENGINE \*engine;
> 
> int version;
> 
> EC\_GROUP \*group;
> 
> **EC\_POINT \*pub\_key;**
> 
> **BIGNUM \*priv\_key;**
> 
> unsigned int enc\_flag;
> 
> point\_conversion\_form\_t conv\_form;
> 
> int references;
> 
> int flags;
> 
> CRYPTO\_EX\_DATA ex\_data;
> 
> CRYPTO\_RWLOCK \*lock;
> 
> \};

ECCrefPublicKey *pkref = (ECCrefPublicKey *)pkbuf;
    	ECCrefPrivateKey *skref = (ECCrefPrivateKey *)skbuf;
    	ECCCipher *cvref = (ECCCipher *)cvbuf;
    	ECCSignature *sigref = (ECCSignature *)sigbuf;
    	EC_KEY *pk = NULL;
    	EC_KEY *sk = NULL;
    	SM2_CIPHERTEXT_VALUE *cv = NULL;
    	ECDSA_SIG *sig = NULL;
    
    	if (!(pk = EC_KEY_new_from_ECCrefPublicKey(pkref))
    		|| !EC_KEY_set_ECCrefPublicKey(pk, pkref)
    		|| !EC_KEY_get_ECCrefPublicKey(pk, pkref)
    		|| !(sk = EC_KEY_new_from_ECCrefPrivateKey(skref))
    		|| !EC_KEY_set_ECCrefPrivateKey(sk, skref)
    		|| !EC_KEY_get_ECCrefPrivateKey(sk, skref)
    		|| !(cv = SM2_CIPHERTEXT_VALUE_new_from_ECCCipher(cvref))
    		|| !SM2_CIPHERTEXT_VALUE_set_ECCCipher(cv, cvref)
    		|| !SM2_CIPHERTEXT_VALUE_get_ECCCipher(cv, cvref)
    		|| !(sig = ECDSA_SIG_new_from_ECCSignature(sigref))
    		|| !ECDSA_SIG_set_ECCSignature(sig, sigref)
    		|| !ECDSA_SIG_get_ECCSignature(sig, sigref)) {
    		goto end;
    	}

> /\* SDF \*/
> 
> \#ifndef OPENSSL\_NO\_SDF
> 
> \# ifndef OPENSSL\_NO\_RSA
> 
> RSA \*RSA\_new\_from\_RSArefPublicKey(const RSArefPublicKey \*ref);
> 
> **int RSA\_set\_RSArefPublicKey(RSA \*rsa, const RSArefPublicKey \*ref);**
> 
> int **RSA\_get\_RSArefPublicKey**(RSA \*rsa, RSArefPublicKey \*ref);
> 
> RSA \*RSA\_new\_from\_RSArefPrivateKey(const RSArefPrivateKey \*ref);
> 
> int RSA\_set\_RSArefPrivateKey(RSA \*rsa, const RSArefPrivateKey \*ref);
> 
> int RSA\_get\_RSArefPrivateKey(RSA \*rsa, RSArefPrivateKey \*ref);
> 
> \# endif
> 
> \# ifndef OPENSSL\_NO\_EC
> 
> EC\_KEY \***EC\_KEY\_new\_from\_ECCrefPublicKey**(const ECCrefPublicKey \*ref);

> int EC\_KEY\_set\_ECCrefPublicKey(EC\_KEY \*ec\_key, const ECCrefPublicKey \*ref);
> 
> **ECCrefPublicKey转EC\_KEY**

int EC_KEY_set_ECCrefPublicKey(EC_KEY *ec_key, const ECCrefPublicKey *ref)
    {
    	int ret = 0;
    	BIGNUM *x = NULL;
    	BIGNUM *y = NULL;
    	int nbytes;
    
    	/* check arguments */
    	if (!ec_key || !ref) {
    		GMAPIerr(GMAPI_F_EC_KEY_SET_ECCREFPUBLICKEY,
    			ERR_R_PASSED_NULL_PARAMETER);
    		return 0;
    	}
    
    	if ((int)ref->bits != EC_GROUP_get_degree(EC_KEY_get0_group(ec_key))) {
    		GMAPIerr(GMAPI_F_EC_KEY_SET_ECCREFPUBLICKEY,
    			GMAPI_R_INVALID_KEY_LENGTH);
    		return 0;
    	}
    
    
        //貌似这边定死了，ref->bits 必须是256，要不然会报错！！！！！！！！！！
    
    
    	/* ECCrefPublicKey ==> EC_KEY */
    	nbytes = (ref->bits + 7)/8;
    
    	if (!(x = BN_bin2bn(ref->x + ECCref_MAX_LEN - nbytes, nbytes, NULL))) {
    		GMAPIerr(GMAPI_F_EC_KEY_SET_ECCREFPUBLICKEY, ERR_R_BN_LIB);
    		goto end;
    	}
    	if (!(y = BN_bin2bn(ref->y + ECCref_MAX_LEN - nbytes, nbytes, NULL))) {
    		GMAPIerr(GMAPI_F_EC_KEY_SET_ECCREFPUBLICKEY, ERR_R_BN_LIB);
    		goto end;
    	}
    	if (!EC_KEY_set_public_key_affine_coordinates(ec_key, x, y)) {
    		GMAPIerr(GMAPI_F_EC_KEY_SET_ECCREFPUBLICKEY,
    			GMAPI_R_INVALID_PUBLIC_KEY);
    		goto end;
    	}
    
    	ret = 1;
    end:
    	BN_free(x);
    	BN_free(y);
    	return ret;
    }

> **int EC\_KEY\_get\_ECCrefPublicKey(EC\_KEY \*ec\_key, ECCrefPublicKey \*ref);**
> 
> **EC\_KEY转ECCrefPublicKey**

> EC\_KEY \***EC\_KEY\_new\_from\_ECCrefPrivateKey**(const ECCrefPrivateKey \*ref);
> 
> int EC\_KEY\_set\_ECCrefPrivateKey(EC\_KEY \*ec\_key, const ECCrefPrivateKey \*ref);

> **int EC\_KEY\_get\_ECCrefPrivateKey(EC\_KEY \*ec\_key, ECCrefPrivateKey \*ref);**
> 
> **EC\_KEY转ECCrefPrivateKey**

> \#  ifndef OPENSSL\_NO\_SM2

> **SM2CiphertextValue \*SM2CiphertextValue\_new\_from\_ECCCipher(const ECCCipher \*ref);**
> 
> **ECCCipher 转 ** **SM2CiphertextValue**

> **int SM2CiphertextValue\_set\_ECCCipher(SM2CiphertextValue \*cv, const ECCCipher \*ref);**

**SM2CiphertextValue 转 ECCCipher**

> **int SM2CiphertextValue\_get\_ECCCipher(const SM2CiphertextValue \*cv, ECCCipher \*ref);**

**注意项**： **ECCCipher.L需要进行初始化分配空间，要不然会报错；**

/* as the `ECCCipher->C[1]` default size is too small, we have to
    	 * check `ECCCipher->L` to make sure caller has initialized this
    	 * structure and prepared enough buffer to hold variable length
    	 * ciphertext
    	 */
    	if (ref->L < (unsigned int)ASN1_STRING_length(cv->ciphertext)) {
    		GMAPIerr(GMAPI_F_SM2CIPHERTEXTVALUE_GET_ECCCIPHER,
    			GMAPI_R_BUFFER_TOO_SMALL);
    		printf("LLLLL \n");
    		return 0;
    	}

> \#  endif
> 
> \#  ifndef OPENSSL\_NO\_ECIES
> 
> ECIES\_CIPHERTEXT\_VALUE \*ECIES\_CIPHERTEXT\_VALUE\_new\_from\_ECCCipher(const ECCCipher \*ref);
> 
> int ECIES\_CIPHERTEXT\_VALUE\_set\_ECCCipher(ECIES\_CIPHERTEXT\_VALUE \*cv, const ECCCipher \*ref);
> 
> int ECIES\_CIPHERTEXT\_VALUE\_get\_ECCCipher(const ECIES\_CIPHERTEXT\_VALUE \*cv, ECCCipher \*ref);
> 
> \#  endif

> **ECDSA\_SIG \*ECDSA\_SIG\_new\_from\_ECCSignature(const ECCSignature \*ref);**
> 
> **ECCSignature转ECDSA\_SIG**

> int ECDSA\_SIG\_set\_ECCSignature(ECDSA\_SIG \*sig, const ECCSignature \*ref);
> 
> int ECDSA\_SIG\_get\_ECCSignature(const ECDSA\_SIG \*sig, ECCSignature \*ref);
> 
> ECCCipher \*d2i\_ECCCipher(ECCCipher \*\*a, const unsigned char \*\*pp, long length);
> 
> int i2d\_ECCCipher(ECCCipher \*a, unsigned char \*\*pp);
> 
> ECCSignature \*d2i\_ECCSignature(ECCSignature \*\*a, const unsigned char \*\*pp, long length);
> 
> int i2d\_ECCSignature(ECCSignature \*a, unsigned char \*\*pp);
> 
> \# endif
> 
> \#endif

> SM2CiphertextValue \***SM2\_do\_encrypt**(const EVP\_MD \*md, const unsigned char \*in, size\_t inlen, EC\_KEY \*ec\_key);
> 
> int **SM2\_do\_decrypt**(const EVP\_MD \*md, const SM2CiphertextValue \*in,
> 
>     unsigned char \*out, size\_t \*outlen, EC\_KEY \*ec\_key);
> 
> int SM2\_encrypt(int type, const unsigned char \*in, size\_t inlen,
> 
>     unsigned char \*out, size\_t \*outlen, EC\_KEY \*ec\_key);
> 
> int SM2\_decrypt(int type, const unsigned char \*in, size\_t inlen,
> 
>     unsigned char \*out, size\_t \*outlen, EC\_KEY \*ec\_key);
> 
> \#define **SM2\_encrypt\_with\_recommended**(in,inlen,out,outlen,ec\_key) \\
> 
>     SM2\_encrypt(NID\_sm3,in,inlen,out,outlen,ec\_key)
> 
> \#define SM2\_decrypt\_with\_recommended(in,inlen,out,outlen,ec\_key) \\
> 
>     SM2\_decrypt(NID\_sm3,in,inlen,out,outlen,ec\_key)