def sign_transaction_dict(eth_key, transaction_dict, mode='ECDSA'):
# generate RLP-serializable transaction, with defaults filled
unsigned_transaction = serializable_unsigned_transaction_from_dict(transaction_dict)
if mode == 'ECDSA':
transaction_hash = unsigned_transaction.hash()
elif mode == 'SM':
transaction_hash = HexBytes(sm3.sm3_hash(func.bytes_to_list(rlp.encode(unsigned_transaction))))
# detect chain
if isinstance(unsigned_transaction, UnsignedTransaction):
chain_id = None
else:
chain_id = unsigned_transaction.v
# sign with private key
if mode == 'SM':
SMC = sm2.CryptSM2(hex(eth_key),1)
rand = func.random_hex(SMC.para_len)
(r, s, v1) = SMC.sign(transaction_hash, rand)
v = to_eth_v(v1, chain_id)
else:
(v, r, s) = sign_transaction_hash(eth_key, transaction_hash, chain_id)
# serialize transaction with rlp
encoded_transaction = encode_transaction(unsigned_transaction, vrs=(v, r, s))
return (v, r, s, encoded_transaction)
def sign_message_hash(key, msg_hash, mode='ECDSA'):
if mode == 'ECDSA':
signature = key.sign_msg_hash(msg_hash)
(v_raw, r, s) = signature.vrs
elif mode == 'SM':
privatekey = key.to_bytes()
SMC = sm2.CryptSM2(privatekey.hex(), 1)
rand = func.random_hex(SMC.para_len)
(r, s, v_raw) = SMC.sign(msg_hash, rand)
v = to_eth_v(v_raw)
eth_signature_bytes = to_bytes32(r) + to_bytes32(s) + to_bytes(v)
return (v, r, s, eth_signature_bytes)
def test_sm3():
private_key = "3945208F7B2144B13F36E38AC6D39F95889393692860B51A42FB81EF4DF7C5B8"
public_key = "09F9DF311E5421A150DD7D161E4BC5C672179FAD1833FC076BB08FF356F35020" \
"CCEA490CE26775A52DC6EA718CC1AA600AED05FBF35E084A6632F6072DA9AD13"
random_hex_str = "59276E27D506861A16680F3AD9C02DCCEF3CC1FA3CDBE4CE6D54B80DEAC1BC21"
sm2_crypt = sm2.CryptSM2(public_key=public_key, private_key=private_key)
data = b"message digest"
print("-----------------test SM2withSM3 sign and verify---------------")
sign = sm2_crypt.sign_with_sm3(data, random_hex_str)
print('sign: %s' % sign)
verify = sm2_crypt.verify_with_sm3(sign, data)
print('verify: %s' % verify)
assert verify
def __init__(self,
private_key_bytes: bytes, mode='ECDSA',
backend: 'Union[BaseECCBackend, Type[BaseECCBackend], str, None]' = None,
) -> None:
validate_private_key_bytes(private_key_bytes)
self._raw_key = private_key_bytes
if mode=='ECDSA':
self.public_key = self.backend.private_key_to_public_key(self)
elif mode=='SM':
keys = sm2.CryptSM2(1, 1)
prikey=private_key_bytes.hex()
publickey=keys.privatekey_to_publickey(prikey.replace('0x',''))
self.public_key = PublicKey(publickey,'SM')
super().__init__(backend=backend)
def test_sm2():
private_key = '00B9AB0B828FF68872F21A837FC303668428DEA11DCD1B24429D0C99E24EED83D5'
public_key = 'B9C9A6E04E9C91F7BA880429273747D7EF5DDEB0BB2FF6317EB00BEF331A83081A6994B8993F3F5D6EADDDB81872266C87C018FB4162F5AF347B483E24620207'
sm2_crypt = sm2.CryptSM2(public_key=public_key, private_key=private_key)
data = b"111"
enc_data = sm2_crypt.encrypt(data)
# print("enc_data:%s" % enc_data)
# print("enc_data_base64:%s" % base64.b64encode(bytes.fromhex(enc_data)))
dec_data = sm2_crypt.decrypt(enc_data)
print(b"dec_data:%s" % dec_data)
assert data == dec_data
print("-----------------test sign and verify---------------")
random_hex_str = func.random_hex(sm2_crypt.para_len)
sign = sm2_crypt.sign(data, random_hex_str)
print(sign)
verify = sm2_crypt.verify(sign, data)
print('verify:%s' % verify)
assert verify
def sm_verify(self, signature, data: bytes, publickey: str):
'''
to verify the sign in 'SM' mode,if the signature is the right sign return True,
else return False.
'''
if 'r' in signature and 's' in signature:
r = signature['r']
s = signature['s']
elif len(signature) == 32:
signature = HexBytes(signature)
r = signature[0:32]
s = signature[33:64]
else:
raise ValueError("cann't find (r,s) in signature")
data = HexBytes(data)
SMC = sm2.CryptSM2(1, publickey)
sign = (r, s)
flag = SMC.verify(sign, data)
if flag == 0:
return False
else:
return True
def sm_private_to_publickey(self, privatekey: str):
keys = sm2.CryptSM2(1, 1)
publickey = keys.privatekey_to_publickey(privatekey)
return publickey