safeheron-api-sdk-python 1.1.18__py3-none-any.whl

safeheron_api_sdk_python/tools.py

@@ -0,0 +1,335 @@
+from Cryptodome.Cipher import AES
+from Cryptodome.Util.Padding import pad, unpad
+from Cryptodome.PublicKey import RSA
+from Cryptodome.Random import get_random_bytes
+from base64 import b64encode, b64decode
+from Cryptodome.Signature import PKCS1_v1_5 as Signature_pkcs1_v1_5
+from Cryptodome.Cipher import PKCS1_v1_5 as Cipher_pkcs1_v1_5
+from Cryptodome.Hash import SHA256, SHA1
+from Cryptodome import Random
+from Crypto.Cipher import PKCS1_OAEP
+from Cryptodome.Signature import pss
+import json
+import time
+import requests
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.backends import default_backend
+
+
+PEM_PUBLIC_HEAD = "-----BEGIN PUBLIC KEY-----\n"
+PEM_PUBLIC_END = "\n-----END PUBLIC KEY-----"
+PEM_PRIVATE_HEAD = "-----BEGIN RSA PRIVATE KEY-----\n"
+PEM_PRIVATE_END = "\n-----END RSA PRIVATE KEY-----"
+
+
+GCM_TYPE = "GCM_NOPADDING"
+ECB_OAEP_TYPE = "ECB_OAEP"
+
+def load_rsa_private_key(file_path, password=None):
+    try:
+        with open(file_path, "rb") as key_file:
+            private_key = serialization.load_pem_private_key(
+                key_file.read(),
+                password=password,
+                backend=default_backend()
+            )
+        pem = private_key.private_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PrivateFormat.PKCS8,
+            encryption_algorithm=serialization.NoEncryption()
+        )
+        return pem.decode()
+    except Exception as e:
+        raise Exception("Failed to parse rsa pem file")
+
+def check_key_and_iv(key: bytes, iv: bytes):
+    if len(key) != 32:
+        raise Exception("aes error: key must have 32 bytes")
+    if len(iv) != 16:
+        raise Exception("aes error: iv must have 16 bytes")
+
+
+def aes_encrypt(key: bytes, iv: bytes, message: bytes):
+    check_key_and_iv(key, iv)
+    message = pad(message, AES.block_size)
+    try:
+        cipher = AES.new(key, AES.MODE_CBC, iv)
+        encrypt_text = cipher.encrypt(message)
+    except Exception as e:
+        raise Exception("aes encrypt error: %s" % e)
+    return encrypt_text
+
+
+def aes_gcm_encrypt(key: bytes, iv: bytes, message: bytes):
+    check_key_and_iv(key, iv)
+    try:
+        cipher = AES.new(key, AES.MODE_GCM, iv)
+        cipher_text, tag = cipher.encrypt_and_digest(message)
+    except Exception as e:
+        raise Exception("aes encrypt error: %s" % e)
+    return cipher_text + tag
+
+
+def aes_decrypt(key: bytes, iv: bytes, encrypt_text: bytes):
+    check_key_and_iv(key, iv)
+    try:
+        cipher = AES.new(key, AES.MODE_CBC, iv)
+        pad_text = cipher.decrypt(encrypt_text)
+    except Exception as e:
+        raise Exception("aes decrypt error: %s" % e)
+    return unpad(pad_text, AES.block_size)
+
+
+def aes_gcm_decrypt(key: bytes, iv: bytes, encrypt_text: bytes):
+    check_key_and_iv(key, iv)
+    try:
+        cipher = AES.new(key, AES.MODE_GCM, iv)
+        pad_text = cipher.decrypt(encrypt_text)
+    except Exception as e:
+        raise Exception("aes decrypt error: %s" % e)
+    return pad_text[0:len(pad_text)-len(iv)]
+
+
+def get_rsa_key(key_pem, passphrase=None):
+    if key_pem == '':
+        raise Exception("rsa encrypt error: pubkey can't be none")
+    if passphrase is None:
+        return RSA.import_key(key_pem)
+    else:
+        return RSA.import_key(key_pem, passphrase=passphrase)
+
+
+def rsa_encrypt(public_key, message: bytes):
+    try:
+        cipher_rsa = Cipher_pkcs1_v1_5.new(public_key)
+        encrypt_text = cipher_rsa.encrypt(message)
+    except Exception as e:
+        raise Exception("rsa encrypt error: %s" % e)
+    encrypt_text_base64 = b64encode(encrypt_text)
+    return encrypt_text_base64.decode('utf-8')
+
+
+def rsa_oaep_encrypt(public_key, message: bytes):
+    try:
+        cipher = PKCS1_OAEP.new(public_key, hashAlgo=SHA256)
+        encrypt_text = cipher.encrypt(message)
+    except Exception as e:
+        raise Exception("rsa encrypt error: %s" % e)
+    encrypt_text_base64 = b64encode(encrypt_text)
+    return encrypt_text_base64.decode('utf-8')
+
+
+def rsa_decrypt(private_key, message: str):
+    encrypt_text = b64decode(message)
+    try:
+        cipher_rsa = Cipher_pkcs1_v1_5.new(private_key)
+        sentinel = Random.new().read(SHA1.digest_size)
+        return cipher_rsa.decrypt(encrypt_text, sentinel)
+    except Exception as e:
+        raise Exception("rsa decrypt error: %s" % e)
+
+
+def rsa_oaep_decrypt(private_key, message: str):
+    encrypt_text = b64decode(message)
+    try:
+        cipher_rsa = PKCS1_OAEP.new(private_key, hashAlgo=SHA256)
+        return cipher_rsa.decrypt(encrypt_text)
+    except Exception as e:
+        raise Exception("rsa decrypt error: %s" % e)
+
+
+def rsa_sign(private_key, message_hash: bytes):
+    try:
+        signer = Signature_pkcs1_v1_5.new(private_key)
+        digest = SHA256.new()
+        digest.update(message_hash)
+        signed = signer.sign(digest)
+        return b64encode(signed).decode()
+    except Exception as e:
+        raise Exception("rsa sign error: %s" % e)
+
+def rsa_pss_sign(private_key, message_hash: bytes):
+    try:
+        signer = pss.new(private_key)
+        digest = SHA256.new()
+        digest.update(message_hash)
+        signed = signer.sign(digest)
+        return b64encode(signed).decode()
+    except Exception as e:
+        raise Exception("rsa sign error: %s" % e)
+
+
+def rsa_verify(public_key, message_hash: bytes, signature):
+    try:
+        signer = Signature_pkcs1_v1_5.new(public_key)
+        digest = SHA256.new()
+        digest.update(message_hash)
+        return signer.verify(digest, b64decode(signature))
+    except Exception as e:
+        raise Exception("rsa sign error: %s" % e)
+
+def rsa_pass_verify(public_key, message_hash: bytes, signature):
+    try:
+        verifier = pss.new(public_key)
+        digest = SHA256.new()
+        digest.update(message_hash)
+        verifier.verify(digest, b64decode(signature))
+        return True
+    except Exception as e:
+        raise Exception("rsa sign error: %s" % e)
+
+
+def sort_request(r: dict):
+    sortData = json.dumps(r, sort_keys=True).replace(' ', '')
+    strArr = []
+    data1 = json.loads(sortData)
+    for key, value in data1.items():
+        # print(value, type(value))
+        if isinstance(value, dict):
+            val = json.dumps(value).replace(' ', '')
+        else:
+            val = value
+        strArr.append(key + '=' + str(val))
+    return "&".join(strArr).encode('utf-8')
+
+
+def encrypt_request(api_key, request_dict, platform_rsa_pk, api_user_rsa_sk):
+    platform_rsa_pk = get_rsa_key(PEM_PUBLIC_HEAD + platform_rsa_pk + PEM_PUBLIC_END)
+    api_user_rsa_sk = get_rsa_key(api_user_rsa_sk)
+
+    ret = dict()
+
+    ret['apiKey'] = api_key
+
+    # prepare aes key and iv
+    aes_key = get_random_bytes(32)
+    aes_iv = get_random_bytes(16)
+
+
+    # 1 rsa encrypt aes key + iv
+    aes_data = aes_key + aes_iv
+    ret['key'] = rsa_oaep_encrypt(platform_rsa_pk, aes_data)
+
+    # 2 aes encrypt request data
+    if request_dict is not None:
+        request_data = json.dumps(request_dict.__dict__).replace('\'', '\"').replace('\n', '').encode('utf-8')
+        aes_encrypted_bytes = aes_gcm_encrypt(aes_key, aes_iv, request_data)
+        ret['bizContent'] = b64encode(aes_encrypted_bytes).decode()
+
+    # 3 set timestamp
+    ret['timestamp'] = str(int(time.time() * 1000))
+
+    # 4 sign request
+    need_sign_message = sort_request(ret)
+    ret['sig'] = rsa_sign(api_user_rsa_sk, need_sign_message)
+    ret['rsaType'] = ECB_OAEP_TYPE
+    ret['aesType'] = GCM_TYPE
+    return ret
+
+
+def decrypt_response(response_dict, platform_rsa_pk, api_user_rsa_sk):
+    platform_rsa_pk = get_rsa_key(PEM_PUBLIC_HEAD + platform_rsa_pk + PEM_PUBLIC_END)
+    api_user_rsa_sk = get_rsa_key(api_user_rsa_sk)
+    required_keys = {
+        'key',
+        'sig',
+        'bizContent',
+        'timestamp',
+        'code',
+        'message'
+    }
+    missing_keys = required_keys.difference(response_dict.keys())
+    if missing_keys:
+        raise Exception(response_dict)
+
+    # 1 rsa verify
+    rsaType = ''
+    if "rsaType" in response_dict:
+        rsaType = response_dict.pop('rsaType')
+
+    aesType = ''
+    if "aesType" in response_dict:
+        aesType = response_dict.pop('aesType')
+
+    sig = response_dict.pop('sig')
+    need_sign_message = sort_request(response_dict)
+    v = rsa_verify(platform_rsa_pk, need_sign_message, sig)
+    if not v:
+        raise Exception("rsa verify: false")
+
+    # 2 get aes key and iv
+    key = response_dict.pop('key')
+    if ECB_OAEP_TYPE == rsaType:
+        aes_data = rsa_oaep_decrypt(api_user_rsa_sk, key)
+    else:
+        aes_data = rsa_decrypt(api_user_rsa_sk, key)
+    aes_key = aes_data[0:32]
+    aes_iv = aes_data[32:48]
+
+    # 3 aes decrypt data, get response data
+    if GCM_TYPE == aesType:
+        r = aes_gcm_decrypt(aes_key, aes_iv, b64decode(response_dict['bizContent']))
+    else:
+        r = aes_decrypt(aes_key, aes_iv, b64decode(response_dict['bizContent']))
+    #response_dict['bizContent'] = json.loads(r.decode())
+
+    return json.loads(r.decode())
+
+#Used for webhook decryption callback request data
+def decrypt_request(response_dict, verify_rsa_pk, decrypt_rsa_sk):
+    verify_rsa_pk = get_rsa_key(PEM_PUBLIC_HEAD + verify_rsa_pk + PEM_PUBLIC_END)
+    decrypt_rsa_sk = get_rsa_key(decrypt_rsa_sk)
+    # 1 rsa verify
+    sig = response_dict.pop('sig')
+    need_sign_message = sort_request(response_dict)
+    v = rsa_verify(verify_rsa_pk, need_sign_message, sig)
+    if not v:
+        raise Exception("rsa verify: false")
+
+    # 2 get aes key and iv
+    aes_data = rsa_decrypt(decrypt_rsa_sk, response_dict['key'])
+    aes_key = aes_data[0:32]
+    aes_iv = aes_data[32:48]
+  
+    # 3 aes decrypt data, get response data
+    r = aes_decrypt(aes_key, aes_iv, b64decode(response_dict['bizContent']))
+
+    return json.loads(r.decode())
+
+#For webhook to send encrypted response content
+def encrypt_response(raw_data,encrpyt_rsa_pk, sign_rsa_sk):
+    encrpyt_rsa_pk = get_rsa_key(PEM_PUBLIC_HEAD + encrpyt_rsa_pk + PEM_PUBLIC_END)
+    sign_rsa_sk = get_rsa_key(sign_rsa_sk)
+    ret = dict()
+    # prepare aes key and iv
+    aes_key = get_random_bytes(32)
+    aes_iv = get_random_bytes(16)
+    res_data = json.dumps(raw_data).replace('\n', '').encode('utf-8')
+
+    # 1 rsa encrypt aes key + iv
+    aes_data = aes_key + aes_iv
+    ret['key'] = rsa_encrypt(encrpyt_rsa_pk, aes_data)
+
+    # 2 aes encrypt request data
+    aes_encrypted_bytes = aes_encrypt(aes_key, aes_iv, res_data)
+    ret['bizContent'] = b64encode(aes_encrypted_bytes).decode()
+
+    # 3 set timestamp , no need to add
+    ret['timestamp'] = str(int(time.time() * 1000))
+
+    # 4 code
+    ret['code'] = "200"
+
+    # 5 message
+    ret['message'] = "callback_ok"
+
+    # 6 sign request
+    need_sign_message = sort_request(ret)
+    ret['sig'] = rsa_sign(sign_rsa_sk, need_sign_message)
+    return ret
+
+def rsa_gen_key():
+    rsa_key = RSA.generate(4096)
+    sk = rsa_key.export_key()
+    pk = rsa_key.publickey().export_key()
+    return sk, pk

safeheron_api_sdk_python/webhook/webhook_converter.py

@@ -0,0 +1,58 @@
+from safeheron_api_sdk_python.tools import *
+
+
+class WebhookConverter:
+
+    def __init__(self, config):
+        self.safeheron_webHook_rsa_public_key = config['safeheronWebHookRsaPublicKey']
+        if config.get('webHookRsaPrivateKey'):
+            self.web_hook_rsa_private_key = PEM_PRIVATE_HEAD + config['webHookRsaPrivateKey'] + PEM_PRIVATE_END
+        if config.get('webHookRsaPrivateKeyPemFile'):
+            self.web_hook_rsa_private_key = load_rsa_private_key(config['webHookRsaPrivateKeyPemFile'])
+
+    def converter(self, webhook):
+        platform_rsa_pk = get_rsa_key(PEM_PUBLIC_HEAD + self.safeheron_webHook_rsa_public_key + PEM_PUBLIC_END)
+        api_user_rsa_sk = get_rsa_key(self.web_hook_rsa_private_key)
+        required_keys = {
+            'key',
+            'sig',
+            'bizContent',
+            'timestamp',
+        }
+
+        missing_keys = required_keys.difference(webhook.keys())
+        if missing_keys:
+            raise Exception(webhook)
+
+        # 1 rsa verify
+        rsaType = ''
+        if "rsaType" in webhook:
+            rsaType = webhook.pop('rsaType')
+
+        aesType = ''
+        if "aesType" in webhook:
+            aesType = webhook.pop('aesType')
+
+        sig = webhook.pop('sig')
+        need_sign_message = sort_request(webhook)
+        v = rsa_verify(platform_rsa_pk, need_sign_message, sig)
+        if not v:
+            raise Exception("rsa verify: false")
+
+        # 2 get aes key and iv
+        key = webhook.pop('key')
+        if ECB_OAEP_TYPE == rsaType:
+            aes_data = rsa_oaep_decrypt(api_user_rsa_sk, key)
+        else:
+            aes_data = rsa_decrypt(api_user_rsa_sk, key)
+        aes_key = aes_data[0:32]
+        aes_iv = aes_data[32:48]
+
+        # 3 aes decrypt data, get response data
+        if GCM_TYPE == aesType:
+            r = aes_gcm_decrypt(aes_key, aes_iv, b64decode(webhook['bizContent']))
+        else:
+            r = aes_decrypt(aes_key, aes_iv, b64decode(webhook['bizContent']))
+        # response_dict['bizContent'] = json.loads(r.decode())
+
+        return json.loads(r.decode())

safeheron_api_sdk_python-1.1.18.dist-info/METADATA

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: safeheron_api_sdk_python
+Version: 1.1.18
+Summary: Python for Safeheron API
+Home-page: https://github.com/Safeheron/safeheron-api-sdk-python
+Author: safeheron
+Author-email: support@safeheron.com
+License: MIT License
+Platform: all
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+License-File: LICENSE
+Requires-Dist: pycryptodomex
+Requires-Dist: requests
+Requires-Dist: cryptography
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: platform
+Dynamic: requires-dist
+Dynamic: summary
+
+# Python SDK for Safeheron API

safeheron_api_sdk_python-1.1.18.dist-info/RECORD

@@ -0,0 +1,19 @@
+safeheron_api_sdk_python/client.py,sha256=kIRknW1YAhgKAl9hxQ7VQuMfwdeUh_VJrUnuxOX1cxs,1192
+safeheron_api_sdk_python/tools.py,sha256=5a5IJXE4U9AcMEju6uLXAgW-7dpBE6qOLLZdVe_9WNg,10930
+safeheron_api_sdk_python/api/account_api.py,sha256=p-6dNcxETdxcwuZlYBkzfMc8hc8cz8DmaXV2tXPme5A,12250
+safeheron_api_sdk_python/api/api_key_management_api.py,sha256=X1_-bskqZN8LyIAe4HoEFw6tVZc9m-P0jZv00tLX2Po,1270
+safeheron_api_sdk_python/api/coin_api.py,sha256=2emU9ZdGJeQwLsM9r9niaT3f_2vT1i_cykqzZgNyyp4,2648
+safeheron_api_sdk_python/api/gas_api.py,sha256=TX_kinHrZt1Y8VTIe5RdbmBrV2Ht4LW6cQz4n2HlMu4,1152
+safeheron_api_sdk_python/api/mpc_sign_api.py,sha256=sxFJPVV4azF4raWxtt4oUC5bEu3cp_ZBMMbjnlOJ5CM,3456
+safeheron_api_sdk_python/api/tools_api.py,sha256=yqLfxmVjq24cp-pkj-iSIWK_ZHCv6Zkwf6EymzLuV7A,972
+safeheron_api_sdk_python/api/transaction_api.py,sha256=4B7Skq2tEoMfMHeyLj9NhqoB2x6OABtRPZf9Ox05VY0,19762
+safeheron_api_sdk_python/api/web3_api.py,sha256=glMr7e_Gzz8zXv5GH9v1ASGylALxHK3wh9vADv7zvDg,12565
+safeheron_api_sdk_python/api/webhook_api.py,sha256=HQi1Y4MHYzjPZEF_CfLp-3kG_trn8Of7ojKpxxFTPmo,3529
+safeheron_api_sdk_python/api/whitelist_api.py,sha256=xmsKjkANqE-Np3VRQjftXqFvYiPP4SOnuXU2Z-m02Zg,9555
+safeheron_api_sdk_python/cosigner/co_signer_converter.py,sha256=rQ5NK2fns0oZXi_gmFNAIJAaJOgMO87we_8sTK3XbPg,6928
+safeheron_api_sdk_python/webhook/webhook_converter.py,sha256=_TJH9B1nsusysDOa7iAPTccKJ0v1eQOYA5vAq0Qk-bg,2074
+safeheron_api_sdk_python-1.1.18.dist-info/licenses/LICENSE,sha256=jmur70PCz0N4z2UiEwoFuZbCfilZhc-2H5KfuEYKqO0,1071
+safeheron_api_sdk_python-1.1.18.dist-info/METADATA,sha256=La6X9BswB2VjPRUEbxF2yXGSOiwLYK7pxTJpV8Op4Gg,682
+safeheron_api_sdk_python-1.1.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+safeheron_api_sdk_python-1.1.18.dist-info/top_level.txt,sha256=P7fhd_ESNNrP0csqebAfcWq3hfRJrBuDIlVD1KXHTeY,25
+safeheron_api_sdk_python-1.1.18.dist-info/RECORD,,

safeheron_api_sdk_python-1.1.18.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

safeheron_api_sdk_python-1.1.18.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c)  2022 Safeheron Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

safeheron_api_sdk_python-1.1.18.dist-info/top_level.txt

@@ -0,0 +1 @@
+safeheron_api_sdk_python