From af14de7569617aafd9eb28f17e4d97cd740b3d82 Mon Sep 17 00:00:00 2001 From: YanNaingWinn Date: Wed, 17 Jun 2026 17:17:56 +0700 Subject: [PATCH 1/5] Fix Dependabot security alerts: bump vulnerable dependencies --- dev-requirements.txt | Bin 7522 -> 7686 bytes requirements.txt | Bin 5752 -> 5684 bytes 2 files changed, 0 insertions(+), 0 deletions(-) diff --git a/dev-requirements.txt b/dev-requirements.txt index c0d3069589904b7e995b5e58de547b7ec8610a80..495be64c0dc74ff7978fe66197c96a54f9aab736 100644 GIT binary patch delta 630 zcmXBR&r2IY6bJCP*{qw*W{vrsYz!h&L<&YtqOCs;;yDBfK}3SY9|Wmw#UF@D52d6c zBCX6pJcx*35f9=)B6t%20P*O-i{ME_JQvaL8(H?lF!N^Kdoy?4zkC07D%NJE2@H*b z)4XB{UCF|{Qh@)IB2*nYIOyQ{9Y+biI5;w=a?HLu!ZRwz+&W`o!nrI*OR%8v{u7PY zUNxi;#TwpuT*G5aPrw$v9S-aLa9baS&pO8pxXSR*H4aT9uB64!a2Li!gR`C(T!+uy z0F&-Um~(TM9qEIdF-@*)()N zqE>Mo%4l8GjMa?ARcu*Rn63Q4+>r)2Jo@VSy&r_6I6;2r(JW>^k#pXb4k@LrBThw>`U5Z}EqaS*D*{Aq|| zj45L25M6tEV@KhO4@>}7#wX&T=YjZx}7llbH9K}0qF1E%V^y48BVsX!v@ HDO#k&=2B}b6~w_Q#ByANl;fx^REwfTiiD6s zN(iMEF@6RGL3DEwI+PBQp>shHad2>uOyVHL$)S|~4Dxt<;S2A5zwfo@dRLxLcV#C#PzpTnNdC9YIiRx0c&OT<;1Rn?)ZE@Em`jy01fT0_n{j|W`74pbQ%^k@y* ze3Ns=pQq-ZWXpezL;o$t0yg!)DnA0tNnP9)YvQ4}D>fw7#Z`$i?*g;xtT@lh-~zvc zOU&ydtm_3{=v8`>R;YjzT4XnLpONrJS{Ezgo@j_WeZ3`$Vp6iihwx2K!bOUaLU8*3 zwoFOAs9u)tPa`WFMfQ1rW|N8N4j-d$abw&3jJ0?$w8@{LEt>H*TB3%VXwgd;TsNnf zFxu=H=lE_oSjh``N!d}-_UU|zW}^KB@|Gnb|Dc>&U_0gUD>ctt`hb&kmaOSgH*0)0 z9jSVqJIjsC6wOS7znM3@%8t^_%Kme*|6Gx0xko5@BUI|U{>x!e(k|iTn|#STj1TXy JKU`6CaSBaljjI3v diff --git a/requirements.txt b/requirements.txt index 0f54754743143303be025235c0930e37552428f0..72b9bfb97a33c57ca510d4d6becfb15e45849a0e 100644 GIT binary patch delta 449 zcmX}oze_?<6bJD0-t+n6<@Lua1Bno65J?oXvgq@cR*pedfPKv@;X#vJ%_E6@`rMv>ahM_! z!=A!5IY$e=IHJVncJkRpudGEr#@QKozDYx3A<^)A3feCM-^{HZs zt>TJ}q09VuXIad0Su{95uDNAcO`F&;)$n2R!NO-z;M@4&{Y=3gpTYv;kvEsoF?Ue0 z==ioYaWHg&fVF`eYaL0Oj(giN(!wF0gaQKgx-8HJtx<(aG-q6YNDNgLGbuEMFZ&TR zaT1rJik=ukP*R~uc|1!Y{2DnoT*U2g4xHn0M4&C&r5b4iCr(j{Q_|4lcy+8`-dVtz zQ)L25@;F3S5^0x)2iG}@?f`Um9xv_;f^r0^yp68Bj;P0He6=X0{+q`h>uaP8%qp9P S?%6-}swjAyc=KjBf&KuG=V_7v From a8ea48fa956c9d52777bb8e75b6cbb258adbca20 Mon Sep 17 00:00:00 2001 From: YanNaingWinn Date: Wed, 17 Jun 2026 19:28:15 +0700 Subject: [PATCH 2/5] Resolve code scanning alerts (CodeQL + Semgrep) --- cryptnox_cli/command/command.py | 3 + cryptnox_cli/command/erc_token/initialize.py | 6 +- cryptnox_cli/command/eth.py | 10 + cryptnox_cli/command/get_clearpubkey.py | 1 + cryptnox_cli/command/helper/cards.py | 3 +- cryptnox_cli/command/helper/config.py | 1 + cryptnox_cli/command/helper/helper_methods.py | 1 + cryptnox_cli/command/helper/security.py | 1 + cryptnox_cli/command/seed.py | 1 + cryptnox_cli/command/transfer.py | 2 - .../command/user_keys/authentication.py | 2 + .../command/user_keys/hello/windows_hello.py | 1 + .../command/user_keys/piv/piv_card.py | 1 + cryptnox_cli/interactive_cli.py | 4 + cryptnox_cli/lib/cryptos/blocks.py | 150 ++++++++++ cryptnox_cli/lib/cryptos/coins/bitcoin.py | 9 + cryptnox_cli/lib/cryptos/composite.py | 227 +++++++++++++++ cryptnox_cli/lib/cryptos/deterministic.py | 180 ++++++++++++ cryptnox_cli/lib/cryptos/keystore.py | 260 +++++++++++++++++- cryptnox_cli/lib/cryptos/main.py | 168 ++++++++++- cryptnox_cli/lib/cryptos/mnemonic.py | 68 ++++- cryptnox_cli/lib/cryptos/ripemd.py | 42 ++- cryptnox_cli/lib/cryptos/specials.py | 29 ++ cryptnox_cli/lib/cryptos/stealth.py | 21 ++ cryptnox_cli/lib/cryptos/transaction.py | 206 +++++++++++++- cryptnox_cli/lib/cryptos/wallet.py | 156 ++++++++++- cryptnox_cli/lib/cryptos/wallet_utils.py | 2 +- cryptnox_cli/wallet/btc.py | 38 +-- cryptnox_cli/wallet/eth/api.py | 1 + dev-requirements.txt | Bin 7686 -> 7688 bytes requirements.txt | Bin 5684 -> 5686 bytes 31 files changed, 1540 insertions(+), 54 deletions(-) diff --git a/cryptnox_cli/command/command.py b/cryptnox_cli/command/command.py index 0f2d894..d74bbc7 100644 --- a/cryptnox_cli/command/command.py +++ b/cryptnox_cli/command/command.py @@ -55,6 +55,7 @@ def _handle_execution(self, serial_number: int = None) -> int: try: self.serial_number = self.data.serial except AttributeError: + # No serial provided in arguments; keep the passed-in serial_number pass try: card = self._cards[self.serial_number] @@ -67,6 +68,8 @@ def _handle_execution(self, serial_number: int = None) -> int: self.run_execute(card) + return None + def run_execute(self, card) -> int: print(f"Using card with serial number {card.serial_number}") origin = card.origin diff --git a/cryptnox_cli/command/erc_token/initialize.py b/cryptnox_cli/command/erc_token/initialize.py index e2089bb..40c0023 100644 --- a/cryptnox_cli/command/erc_token/initialize.py +++ b/cryptnox_cli/command/erc_token/initialize.py @@ -7,10 +7,10 @@ import gzip import json -import urllib +import urllib.error +import urllib.parse from argparse import Namespace from typing import List -from urllib import parse import cryptnox_sdk_py import requests @@ -202,7 +202,7 @@ def _token_slots() -> list[str]: def _abi() -> str: def uri_validator(x): try: - result = parse.urlparse(x) + result = urllib.parse.urlparse(x) return all([result.scheme, result.netloc]) except Exception: return False diff --git a/cryptnox_cli/command/eth.py b/cryptnox_cli/command/eth.py index 3e2673b..d436608 100644 --- a/cryptnox_cli/command/eth.py +++ b/cryptnox_cli/command/eth.py @@ -169,6 +169,8 @@ def logs(self): endpoint.block_number save_to_config(self.card, self.config) + return None + @staticmethod def _get_logs(event) -> List[Dict[str, Any]]: min_offset = 0 @@ -256,6 +258,8 @@ def _execute(self, card): print(error) return -1 + return None + def _get_endpoint(self, card): config = get_configuration(card) @@ -311,6 +315,8 @@ def _add(self, card): print(f"Contract added to application. Use it with alias:" f" {self.data.alias}") + return None + @staticmethod def _list(card) -> int: config = get_configuration(card) @@ -356,6 +362,8 @@ def _functions(self, card): print(tabulate(tabulate_table, headers=tabulate_header, tablefmt="grid")) + return None + def _call(self, card): config = get_configuration(card) try: @@ -645,3 +653,5 @@ def _send_token(self, card): contract.transfer(card, config["endpoint"], config["network"], config["api_key"], self.data.contract, self.data.address, self.data.amount, self.data.price, self.data.limit, derivation) + + return None diff --git a/cryptnox_cli/command/get_clearpubkey.py b/cryptnox_cli/command/get_clearpubkey.py index 1f08b29..d715b71 100644 --- a/cryptnox_cli/command/get_clearpubkey.py +++ b/cryptnox_cli/command/get_clearpubkey.py @@ -98,6 +98,7 @@ def _execute(self, card) -> int: else: card.derive(key_type, "m/44'/0'/0'") except Exception: + # Best-effort derivation; clear pubkey read below handles failures pass pubkey_bytes = card.get_public_key_clear(derivation, path, compressed) self._print_pubkey_info(key_type, compressed, pubkey_bytes) diff --git a/cryptnox_cli/command/helper/cards.py b/cryptnox_cli/command/helper/cards.py index f048b50..532d70d 100644 --- a/cryptnox_cli/command/helper/cards.py +++ b/cryptnox_cli/command/helper/cards.py @@ -113,6 +113,7 @@ def refresh(self, remote: bool = False) -> None: except cryptnox_sdk_py.exceptions.ReaderException: break except cryptnox_sdk_py.exceptions.CryptnoxException: + # Card at this index is unreadable; skip it and continue scanning pass index += 1 @@ -194,7 +195,7 @@ def _open_card(self, index: int, remote: bool = False) -> cryptnox_sdk_py.Card: if test_response: if index in self._cards_by_index: return self._cards_by_index[index] - except (BaseException, cryptnox_sdk_py.exceptions.ConnectionException): + except (Exception, cryptnox_sdk_py.exceptions.ConnectionException): # Connection is stale, remove it and create new one del _GLOBAL_CONNECTIONS[index] if index in self._cards_by_index: diff --git a/cryptnox_cli/command/helper/config.py b/cryptnox_cli/command/helper/config.py index 54c4ee4..439b037 100644 --- a/cryptnox_cli/command/helper/config.py +++ b/cryptnox_cli/command/helper/config.py @@ -185,6 +185,7 @@ def write_config(card: cryptnox_sdk_py.Card, section: str, key: str, value: str) print(error) return 1 except AttributeError: + # Key not present on the validator instance; fall through to config handling pass try: diff --git a/cryptnox_cli/command/helper/helper_methods.py b/cryptnox_cli/command/helper/helper_methods.py index 576e1ce..cd23830 100644 --- a/cryptnox_cli/command/helper/helper_methods.py +++ b/cryptnox_cli/command/helper/helper_methods.py @@ -102,5 +102,6 @@ def try_eval(value: str) -> Any: try: value = ast.literal_eval(value) except ValueError: + # Not a literal; keep the original string value pass return value diff --git a/cryptnox_cli/command/helper/security.py b/cryptnox_cli/command/helper/security.py index 64081c6..58724b5 100644 --- a/cryptnox_cli/command/helper/security.py +++ b/cryptnox_cli/command/helper/security.py @@ -140,6 +140,7 @@ def check(card, check_seed: bool = True) -> bool: try: result = user_keys.authenticate(card) except NotImplementedError: + # User-key auth unsupported here; fall back to PIN authentication below pass if not result: diff --git a/cryptnox_cli/command/seed.py b/cryptnox_cli/command/seed.py index 2f34f07..a74f110 100644 --- a/cryptnox_cli/command/seed.py +++ b/cryptnox_cli/command/seed.py @@ -96,6 +96,7 @@ def _dual_seed(self, card: cryptnox_sdk_py.Card) -> int: print(error) return -1 except cryptnox_sdk_py.exceptions.DataValidationException: + # Expected when probing dual-seed support without a PIN; safe to proceed pass print("Dual seed generation process starting...") diff --git a/cryptnox_cli/command/transfer.py b/cryptnox_cli/command/transfer.py index e0abac1..2859fb2 100644 --- a/cryptnox_cli/command/transfer.py +++ b/cryptnox_cli/command/transfer.py @@ -10,10 +10,8 @@ try: import enums - from wallet import eth as wallet # noqa: F401 except ImportError: from .. import enums - from ..wallet import eth as wallet # noqa: F401 class Transfer(Command): diff --git a/cryptnox_cli/command/user_keys/authentication.py b/cryptnox_cli/command/user_keys/authentication.py index 3caa2f4..6309895 100644 --- a/cryptnox_cli/command/user_keys/authentication.py +++ b/cryptnox_cli/command/user_keys/authentication.py @@ -21,6 +21,7 @@ try: importlib.import_module("." + submodule, package=__package__) except Exception: + # Optional submodule unavailable in frozen build; skip it pass else: # When running normally, dynamically discover submodules @@ -155,6 +156,7 @@ def delete(name: str, card: cryptnox_sdk_py.Card, puk: str) -> bool: try: user_key.delete() except user_key_base.UserKeyException: + # Best-effort local key removal; proceed to delete it from the card pass card.user_key_delete(user_key.slot_index, puk) diff --git a/cryptnox_cli/command/user_keys/hello/windows_hello.py b/cryptnox_cli/command/user_keys/hello/windows_hello.py index dac23c6..b1d9e22 100644 --- a/cryptnox_cli/command/user_keys/hello/windows_hello.py +++ b/cryptnox_cli/command/user_keys/hello/windows_hello.py @@ -95,6 +95,7 @@ async def _get_user_credentials(account_id: str) -> KeyCredential: return key_result.credential _error_handle(key_result.status) + return None async def _public_key(name: str) -> bytearray: diff --git a/cryptnox_cli/command/user_keys/piv/piv_card.py b/cryptnox_cli/command/user_keys/piv/piv_card.py index 0206438..596d6a0 100644 --- a/cryptnox_cli/command/user_keys/piv/piv_card.py +++ b/cryptnox_cli/command/user_keys/piv/piv_card.py @@ -220,6 +220,7 @@ def is_locked(self, pin_bank: int) -> bool: try: self.verify_pin(pin_bank, "") except PinException: + # Empty PIN rejected as expected; card is not locked pass except PIVCardException as error: if error.sw_code == 0x6983: diff --git a/cryptnox_cli/interactive_cli.py b/cryptnox_cli/interactive_cli.py index 2803263..fdfdabe 100644 --- a/cryptnox_cli/interactive_cli.py +++ b/cryptnox_cli/interactive_cli.py @@ -219,6 +219,7 @@ def run(self) -> int: self._cards.refresh(self.port and client is not None) self._card_info = list(self._cards.values())[0].info except IndexError: + # No cards found yet; leave _card_info unset and continue pass self._cards.print_card_list(show_warnings=True, print_with_one_card=True) @@ -294,6 +295,7 @@ def _process_command(self): if execute[0] not in ["use", "exit", "back"]: execute[0:0] = self.subcommand except LookupError: + # Empty command; nothing to prepend, ignore pass else: self._prepare_parser() @@ -312,6 +314,7 @@ def _process_command(self): try: self.parser.parse_args(execute) except SystemExit: + # argparse exits on help/error; keep the interactive loop alive pass UsageParser.throw_error = True else: @@ -399,6 +402,7 @@ def _run_command(self, args: argparse.Namespace, to_always_run: List = None) -> try: self._card_info = self._cards[command.serial_number].info except KeyError: + # Card no longer present; keep previous _card_info pass except (cryptnox_sdk_py.exceptions.CryptnoxException, ExitException, TimeoutException) as error: print(error) diff --git a/cryptnox_cli/lib/cryptos/blocks.py b/cryptnox_cli/lib/cryptos/blocks.py index 61a7cba..05b63fc 100644 --- a/cryptnox_cli/lib/cryptos/blocks.py +++ b/cryptnox_cli/lib/cryptos/blocks.py @@ -53,3 +53,153 @@ def mk_merkle_proof(header, hashes, index): "siblings": [bytes_to_hex_string(x[::-1]) for x in merkle_siblings], "header": header } + + +# Explicit public API (added to satisfy CodeQL py/polluting-import). +# Lists the names this module already exported via 'import *', so wildcard +# import behaviour is unchanged. +__all__ = [ + "A", + "B", + "F0", + "F1", + "F2", + "F3", + "F4", + "G", + "Gx", + "Gy", + "K0", + "K1", + "K2", + "K3", + "K4", + "KK0", + "KK1", + "KK2", + "KK3", + "KK4", + "N", + "P", + "PADDING", + "R", + "RIPEMD160", + "RMD160Final", + "RMD160Transform", + "RMD160Update", + "RMDContext", + "ROL", + "access", + "add", + "add_privkeys", + "add_pubkeys", + "b58check_to_bin", + "b58check_to_hex", + "base64", + "bin_dbl_sha256", + "bin_hash160", + "bin_ripemd160", + "bin_sha256", + "bin_slowsha", + "bin_to_b58check", + "binascii", + "bytes_to_hex_string", + "change_curve", + "changebase", + "code_strings", + "compress", + "count", + "dbl_sha256", + "decode", + "decode_privkey", + "decode_pubkey", + "decode_sig", + "decompress", + "deserialize_header", + "deterministic_generate_k", + "digest_size", + "digestsize", + "divide", + "ecdsa_raw_recover", + "ecdsa_raw_sign", + "ecdsa_raw_verify", + "ecdsa_recover", + "ecdsa_sign", + "ecdsa_verify", + "ecdsa_verify_addr", + "electrum_sig_hash", + "encode", + "encode_privkey", + "encode_pubkey", + "encode_sig", + "fast_add", + "fast_multiply", + "from_byte_to_int", + "from_int_representation_to_bytes", + "from_int_to_byte", + "from_jacobian", + "from_string_to_bytes", + "getG", + "get_code_string", + "get_privkey_format", + "get_pubkey_format", + "get_version_byte", + "hash160", + "hash160High", + "hash160Low", + "hash_to_int", + "hashlib", + "hex_to_b58check", + "hex_to_hash160", + "hmac", + "int_types", + "inv", + "is_privkey", + "is_pubkey", + "is_python2", + "isinf", + "jacobian_add", + "jacobian_double", + "jacobian_multiply", + "lpad", + "magicbyte_to_prefix", + "mk_merkle_proof", + "mul_privkeys", + "multiaccess", + "multiply", + "neg_privkey", + "neg_pubkey", + "new", + "num_to_var_int", + "os", + "privkey_to_address", + "privkey_to_pubkey", + "privtoaddr", + "privtopub", + "pubkey_to_address", + "pubkey_to_hash", + "pubkey_to_hash_hex", + "pubtoaddr", + "random", + "random_electrum_seed", + "random_key", + "random_string", + "re", + "ripemd160", + "safe_from_hex", + "safe_hexlify", + "serialize_header", + "sha256", + "slice", + "slowsha", + "string_or_bytes_types", + "string_types", + "struct", + "subtract", + "subtract_privkeys", + "subtract_pubkeys", + "sum", + "sys", + "time", + "to_jacobian", +] diff --git a/cryptnox_cli/lib/cryptos/coins/bitcoin.py b/cryptnox_cli/lib/cryptos/coins/bitcoin.py index e5d9929..9a5bbe8 100644 --- a/cryptnox_cli/lib/cryptos/coins/bitcoin.py +++ b/cryptnox_cli/lib/cryptos/coins/bitcoin.py @@ -44,3 +44,12 @@ class Bitcoin(BaseCoin): 'p2wsh': 0x2aa7ed3 }, } + + +# Explicit public API (added to satisfy CodeQL py/polluting-import). +# Lists the names this module already exported via 'import *', so wildcard +# import behaviour is unchanged. +__all__ = [ + "BaseCoin", + "Bitcoin", +] diff --git a/cryptnox_cli/lib/cryptos/composite.py b/cryptnox_cli/lib/cryptos/composite.py index 7de81e0..de1f656 100644 --- a/cryptnox_cli/lib/cryptos/composite.py +++ b/cryptnox_cli/lib/cryptos/composite.py @@ -53,3 +53,230 @@ def sign_coinvault_tx(tx, priv): scr = [None] + filter(lambda x: x, scr[1:-1])[:k] + [scr[-1]] txobj['ins'][j]['script'] = serialize_script(scr) return serialize(txobj) + + +# Explicit public API (added to satisfy CodeQL py/polluting-import). +# Lists the names this module already exported via 'import *', so wildcard +# import behaviour is unchanged. +__all__ = [ + "A", + "B", + "DEFAULT", + "F0", + "F1", + "F2", + "F3", + "F4", + "G", + "Gx", + "Gy", + "K0", + "K1", + "K2", + "K3", + "K4", + "KK0", + "KK1", + "KK2", + "KK3", + "KK4", + "MAINNET_PRIVATE", + "MAINNET_PUBLIC", + "N", + "P", + "PADDING", + "PRIVATE", + "PUBLIC", + "R", + "RIPEMD160", + "RMD160Final", + "RMD160Transform", + "RMD160Update", + "RMDContext", + "ROL", + "SIGHASH_ALL", + "SIGHASH_ANYONECANPAY", + "SIGHASH_FORKID", + "SIGHASH_NONE", + "SIGHASH_SINGLE", + "TESTNET_PRIVATE", + "TESTNET_PUBLIC", + "access", + "add", + "add_privkeys", + "add_pubkeys", + "apply_multisignatures", + "b58check_to_bin", + "b58check_to_hex", + "base64", + "bin_dbl_sha256", + "bin_hash160", + "bin_ripemd160", + "bin_sha256", + "bin_slowsha", + "bin_to_b58check", + "bin_txhash", + "binascii", + "bip32_bin_extract_key", + "bip32_ckd", + "bip32_derive_key", + "bip32_descend", + "bip32_deserialize", + "bip32_extract_key", + "bip32_hdm_addr", + "bip32_hdm_script", + "bip32_master_key", + "bip32_privtopub", + "bip32_serialize", + "bytes_to_hex_string", + "change_curve", + "changebase", + "code_strings", + "coinvault_priv_to_bip32", + "coinvault_pub_to_bip32", + "compress", + "copy", + "count", + "crack_bip32_privkey", + "crack_electrum_wallet", + "dbl_sha256", + "dbl_sha256_list", + "decode", + "decode_privkey", + "decode_pubkey", + "decode_sig", + "decompress", + "der_decode_sig", + "der_encode_sig", + "deserialize", + "deserialize_script", + "deterministic_generate_k", + "digest_size", + "digestsize", + "divide", + "ecdsa_raw_recover", + "ecdsa_raw_sign", + "ecdsa_raw_verify", + "ecdsa_recover", + "ecdsa_sign", + "ecdsa_tx_recover", + "ecdsa_tx_sign", + "ecdsa_tx_verify", + "ecdsa_verify", + "ecdsa_verify_addr", + "electrum_address", + "electrum_mpk", + "electrum_privkey", + "electrum_pubkey", + "electrum_sig_hash", + "electrum_stretch", + "encode", + "encode_1_byte", + "encode_4_bytes", + "encode_8_bytes", + "encode_privkey", + "encode_pubkey", + "encode_sig", + "fast_add", + "fast_multiply", + "from_byte_to_int", + "from_int_representation_to_bytes", + "from_int_to_byte", + "from_jacobian", + "from_string_to_bytes", + "getG", + "get_code_string", + "get_privkey_format", + "get_pubkey_format", + "get_version_byte", + "hash160", + "hash160High", + "hash160Low", + "hash_to_int", + "hashlib", + "hex_to_b58check", + "hex_to_hash160", + "hmac", + "int_types", + "inv", + "is_bip66", + "is_inp", + "is_privkey", + "is_pubkey", + "is_python2", + "is_segwit", + "is_xprv", + "is_xpub", + "isinf", + "jacobian_add", + "jacobian_double", + "jacobian_multiply", + "json_changebase", + "json_is_base", + "list_to_bytes", + "lpad", + "magicbyte_to_prefix", + "mk_multisig_script", + "mk_p2w_scripthash_script", + "mk_p2wpkh_redeemscript", + "mk_p2wpkh_script", + "mk_p2wpkh_scriptcode", + "mk_pubkey_script", + "mk_scripthash_script", + "mul_privkeys", + "multiaccess", + "multiply", + "multisign", + "neg_privkey", + "neg_pubkey", + "new", + "num_to_var_int", + "os", + "output_script_to_address", + "p2wpkh_nested_script", + "parse_bip32_path", + "privkey_to_address", + "privkey_to_pubkey", + "privtoaddr", + "privtopub", + "pubkey_to_address", + "pubkey_to_hash", + "pubkey_to_hash_hex", + "public_txhash", + "pubtoaddr", + "random", + "random_electrum_seed", + "random_key", + "random_string", + "raw_bip32_ckd", + "raw_bip32_privtopub", + "raw_crack_bip32_privkey", + "re", + "reduce", + "ripemd160", + "safe_from_hex", + "safe_hexlify", + "select", + "serialize", + "serialize_script", + "serialize_script_unit", + "setup_coinvault_tx", + "sha256", + "sign_coinvault_tx", + "signature_form", + "slice", + "slowsha", + "string_or_bytes_types", + "string_types", + "struct", + "subtract", + "subtract_privkeys", + "subtract_pubkeys", + "sum", + "sys", + "time", + "to_jacobian", + "txhash", + "uahf_digest", + "verify_tx_input", +] diff --git a/cryptnox_cli/lib/cryptos/deterministic.py b/cryptnox_cli/lib/cryptos/deterministic.py index 8a23c84..a660b47 100644 --- a/cryptnox_cli/lib/cryptos/deterministic.py +++ b/cryptnox_cli/lib/cryptos/deterministic.py @@ -224,6 +224,8 @@ def bip32_descend(*args, prefixes=DEFAULT): path = parse_bip32_path(args[1]) elif len(args): key, path = args[0], list(map(int, args[1:])) + else: + raise TypeError("bip32_descend() requires at least one positional argument") for p in path: key = bip32_ckd(key, p, prefixes) return bip32_extract_key(key, prefixes) @@ -246,3 +248,181 @@ def parse_bip32_path(path): v = int(v) & 0x7fffffff patharr.append(v) return patharr + + +# Explicit public API (added to satisfy CodeQL py/polluting-import). +# Lists the names this module already exported via 'import *', so wildcard +# import behaviour is unchanged. +__all__ = [ + "A", + "B", + "DEFAULT", + "F0", + "F1", + "F2", + "F3", + "F4", + "G", + "Gx", + "Gy", + "K0", + "K1", + "K2", + "K3", + "K4", + "KK0", + "KK1", + "KK2", + "KK3", + "KK4", + "MAINNET_PRIVATE", + "MAINNET_PUBLIC", + "N", + "P", + "PADDING", + "PRIVATE", + "PUBLIC", + "R", + "RIPEMD160", + "RMD160Final", + "RMD160Transform", + "RMD160Update", + "RMDContext", + "ROL", + "TESTNET_PRIVATE", + "TESTNET_PUBLIC", + "access", + "add", + "add_privkeys", + "add_pubkeys", + "b58check_to_bin", + "b58check_to_hex", + "base64", + "bin_dbl_sha256", + "bin_hash160", + "bin_ripemd160", + "bin_sha256", + "bin_slowsha", + "bin_to_b58check", + "binascii", + "bip32_bin_extract_key", + "bip32_ckd", + "bip32_derive_key", + "bip32_descend", + "bip32_deserialize", + "bip32_extract_key", + "bip32_master_key", + "bip32_privtopub", + "bip32_serialize", + "bytes_to_hex_string", + "change_curve", + "changebase", + "code_strings", + "coinvault_priv_to_bip32", + "coinvault_pub_to_bip32", + "compress", + "count", + "crack_bip32_privkey", + "crack_electrum_wallet", + "dbl_sha256", + "decode", + "decode_privkey", + "decode_pubkey", + "decode_sig", + "decompress", + "deterministic_generate_k", + "digest_size", + "digestsize", + "divide", + "ecdsa_raw_recover", + "ecdsa_raw_sign", + "ecdsa_raw_verify", + "ecdsa_recover", + "ecdsa_sign", + "ecdsa_verify", + "ecdsa_verify_addr", + "electrum_address", + "electrum_mpk", + "electrum_privkey", + "electrum_pubkey", + "electrum_sig_hash", + "electrum_stretch", + "encode", + "encode_privkey", + "encode_pubkey", + "encode_sig", + "fast_add", + "fast_multiply", + "from_byte_to_int", + "from_int_representation_to_bytes", + "from_int_to_byte", + "from_jacobian", + "from_string_to_bytes", + "getG", + "get_code_string", + "get_privkey_format", + "get_pubkey_format", + "get_version_byte", + "hash160", + "hash160High", + "hash160Low", + "hash_to_int", + "hashlib", + "hex_to_b58check", + "hex_to_hash160", + "hmac", + "int_types", + "inv", + "is_privkey", + "is_pubkey", + "is_python2", + "is_xprv", + "is_xpub", + "isinf", + "jacobian_add", + "jacobian_double", + "jacobian_multiply", + "lpad", + "magicbyte_to_prefix", + "mul_privkeys", + "multiaccess", + "multiply", + "neg_privkey", + "neg_pubkey", + "new", + "num_to_var_int", + "os", + "parse_bip32_path", + "privkey_to_address", + "privkey_to_pubkey", + "privtoaddr", + "privtopub", + "pubkey_to_address", + "pubkey_to_hash", + "pubkey_to_hash_hex", + "pubtoaddr", + "random", + "random_electrum_seed", + "random_key", + "random_string", + "raw_bip32_ckd", + "raw_bip32_privtopub", + "raw_crack_bip32_privkey", + "re", + "ripemd160", + "safe_from_hex", + "safe_hexlify", + "sha256", + "slice", + "slowsha", + "string_or_bytes_types", + "string_types", + "struct", + "subtract", + "subtract_privkeys", + "subtract_pubkeys", + "sum", + "sys", + "time", + "to_jacobian", +] diff --git a/cryptnox_cli/lib/cryptos/keystore.py b/cryptnox_cli/lib/cryptos/keystore.py index abdd82e..283b855 100644 --- a/cryptnox_cli/lib/cryptos/keystore.py +++ b/cryptnox_cli/lib/cryptos/keystore.py @@ -166,6 +166,7 @@ def get_pubkey_derivation(self, x_pubkey): addr = self.coin.p2sh_scriptaddr(x_pubkey[2:]) if addr in self.addresses: return self.addresses[addr].get('pubkey') + return None def update_password(self, old_password, new_password): self.check_password(old_password) @@ -238,7 +239,7 @@ def derive_pubkey(self, for_change, n): return self.get_pubkey_from_xpub(xpub, (n,), self.bip39_prefixes) @classmethod - def get_pubkey_from_xpub(self, xpub, sequence, bip39_prefixes): + def get_pubkey_from_xpub(cls, xpub, sequence, bip39_prefixes): return bip32_derive_key(xpub, sequence, bip39_prefixes) """needed? @@ -352,7 +353,7 @@ class Hardware_KeyStore(KeyStore, Xpub): max_change_outputs = 1 def __init__(self, d, coin): - Xpub.__init__(self, coin) + Xpub.__init__(self) KeyStore.__init__(self, coin) # Errors and other user interaction is done through the wallet's # handler. The handler is per-window and preserved across @@ -483,7 +484,7 @@ def xpubkey_to_address(x_pubkey, coin): pubkey = x_pubkey elif x_pubkey[0:2] == 'ff': xpub, s = BIP32_KeyStore.parse_xpubkey(x_pubkey) - pubkey = BIP32_KeyStore.get_pubkey_from_xpub(xpub, s) + pubkey = BIP32_KeyStore.get_pubkey_from_xpub(xpub, s, coin.bip39_prefixes) else: raise BaseException("Cannot parse pubkey") address = coin.pubtoaddr(pubkey) @@ -516,11 +517,12 @@ def get_private_keys(text): parts = list(filter(bool, parts)) if bool(parts) and all(bitcoin.is_private_key(x) for x in parts): return parts + return None def is_private_key_list(text): return bool(get_private_keys(text)) -is_mpk = lambda x: is_xpub(x) +is_mpk = is_xpub is_private = lambda x: is_seed(x) or is_xprv(x) or is_private_key_list(x) is_master_key = lambda x: is_xprv(x) or is_xpub(x) is_private_key = lambda x: is_xprv(x) or is_private_key_list(x) @@ -568,7 +570,255 @@ def from_master_key(text, coin): if is_xprv(text, prefixes): k = from_xprv(text, coin) elif is_xpub(text, prefixes): - k = from_xpub(text, coin) + k = from_xpub(text, coin, 'p2pkh') else: raise BaseException('Invalid key') return k + + +# Explicit public API (added to satisfy CodeQL py/polluting-import). +# Lists the names this module already exported via 'import *', so wildcard +# import behaviour is unchanged. +__all__ = [ + "A", + "B", + "BIP32_KeyStore", + "CJK_INTERVALS", + "DEFAULT", + "Deterministic_KeyStore", + "ELECTRUM_VERSION", + "F0", + "F1", + "F2", + "F3", + "F4", + "G", + "Gx", + "Gy", + "Hardware_KeyStore", + "Imported_KeyStore", + "InvalidPassword", + "K0", + "K1", + "K2", + "K3", + "K4", + "KK0", + "KK1", + "KK2", + "KK3", + "KK4", + "KeyStore", + "MAINNET_PRIVATE", + "MAINNET_PUBLIC", + "N", + "P", + "PADDING", + "PBKDF2", + "PRIVATE", + "PROTOCOL_VERSION", + "PUBLIC", + "R", + "RIPEMD160", + "RMD160Final", + "RMD160Transform", + "RMD160Update", + "RMDContext", + "ROL", + "SEED_PREFIX", + "SEED_PREFIX_2FA", + "SEED_PREFIX_SW", + "Software_KeyStore", + "TESTNET_PRIVATE", + "TESTNET_PUBLIC", + "Xpub", + "access", + "add", + "add_privkeys", + "add_pubkeys", + "b58check_to_bin", + "b58check_to_hex", + "base64", + "bin_dbl_sha256", + "bin_hash160", + "bin_ripemd160", + "bin_sha256", + "bin_slowsha", + "bin_to_b58check", + "binascii", + "bip32_bin_extract_key", + "bip32_ckd", + "bip32_derive_key", + "bip32_descend", + "bip32_deserialize", + "bip32_extract_key", + "bip32_master_key", + "bip32_privtopub", + "bip32_serialize", + "bip39_is_checksum_valid", + "bip39_mnemonic_to_seed", + "bip39_normalize_passphrase", + "bip39_to_seed", + "bisect_left", + "bytes_to_hex_string", + "change_curve", + "changebase", + "code_strings", + "coinvault_priv_to_bip32", + "coinvault_pub_to_bip32", + "compress", + "count", + "crack_bip32_privkey", + "crack_electrum_wallet", + "dbl_sha256", + "decode", + "decode_privkey", + "decode_pubkey", + "decode_sig", + "decompress", + "deterministic_generate_k", + "digest_size", + "digestsize", + "divide", + "ecdsa_raw_recover", + "ecdsa_raw_sign", + "ecdsa_raw_verify", + "ecdsa_recover", + "ecdsa_sign", + "ecdsa_verify", + "ecdsa_verify_addr", + "eint_to_bytes", + "electrum_address", + "electrum_mnemonic_to_seed", + "electrum_mpk", + "electrum_privkey", + "electrum_pubkey", + "electrum_sig_hash", + "electrum_stretch", + "encode", + "encode_privkey", + "encode_pubkey", + "encode_sig", + "entropy_cs", + "entropy_to_words", + "fast_add", + "fast_multiply", + "from_bip39_seed", + "from_byte_to_int", + "from_electrum_seed", + "from_int_representation_to_bytes", + "from_int_to_byte", + "from_jacobian", + "from_master_key", + "from_private_key_list", + "from_string_to_bytes", + "from_xprv", + "from_xpub", + "getG", + "get_code_string", + "get_private_keys", + "get_privkey_format", + "get_pubkey_format", + "get_version_byte", + "hardware_keystore", + "hash160", + "hash160High", + "hash160Low", + "hash_to_int", + "hashlib", + "hex_to_b58check", + "hex_to_hash160", + "hfu", + "hmac", + "hw_keystores", + "int_types", + "inv", + "is_CJK", + "is_address_list", + "is_bip32_key", + "is_master_key", + "is_mpk", + "is_new_seed", + "is_old_seed", + "is_private", + "is_private_key", + "is_private_key_list", + "is_privkey", + "is_pubkey", + "is_python2", + "is_seed", + "is_xprv", + "is_xpub", + "is_xpubkey", + "isinf", + "jacobian_add", + "jacobian_double", + "jacobian_multiply", + "lpad", + "magicbyte_to_prefix", + "mnemonic_int_to_words", + "mnemonic_to_seed", + "mul_privkeys", + "multiaccess", + "multiply", + "neg_privkey", + "neg_pubkey", + "new", + "normalize", + "normalize_text", + "num_to_var_int", + "os", + "p2wpkh_from_bip39_seed", + "p2wpkh_p2sh_from_bip39_seed", + "parse_bip32_path", + "parse_xpubkey", + "privkey_to_address", + "privkey_to_pubkey", + "privtoaddr", + "privtopub", + "pubkey_to_address", + "pubkey_to_hash", + "pubkey_to_hash_hex", + "pubtoaddr", + "pw_decode", + "pw_encode", + "random", + "random_electrum_seed", + "random_key", + "random_string", + "raw_bip32_ckd", + "raw_bip32_privtopub", + "raw_crack_bip32_privkey", + "re", + "register_keystore", + "ripemd160", + "safe_from_hex", + "safe_hexlify", + "seed_prefix", + "seed_type", + "sha256", + "slice", + "slowsha", + "standard_from_bip39_seed", + "string_or_bytes_types", + "string_types", + "struct", + "subtract", + "subtract_privkeys", + "subtract_pubkeys", + "sum", + "sys", + "time", + "to_jacobian", + "unicodedata", + "whitespace", + "wordlist_english", + "words_bisect", + "words_mine", + "words_split", + "words_to_mnemonic_int", + "words_verify", + "xpubkey_to_address", + "xpubkey_to_pubkey", + "xtype_from_derivation", +] diff --git a/cryptnox_cli/lib/cryptos/main.py b/cryptnox_cli/lib/cryptos/main.py index 8e9a584..aebf222 100644 --- a/cryptnox_cli/lib/cryptos/main.py +++ b/cryptnox_cli/lib/cryptos/main.py @@ -147,7 +147,7 @@ def jacobian_multiply(a, n): return jacobian_multiply(a, n % N) if (n % 2) == 0: return jacobian_double(jacobian_multiply(a, n // 2)) - if (n % 2) == 1: + else: return jacobian_add(jacobian_double(jacobian_multiply(a, n // 2)), a) @@ -333,6 +333,7 @@ def compress(pubkey): return encode_pubkey(decode_pubkey(pubkey, f), 'bin_compressed') elif f == 'hex' or f == 'decimal': return encode_pubkey(decode_pubkey(pubkey, f), 'hex_compressed') + return None def decompress(pubkey): @@ -343,6 +344,7 @@ def decompress(pubkey): return encode_pubkey(decode_pubkey(pubkey, f), 'bin') elif f == 'hex_compressed' or f == 'decimal': return encode_pubkey(decode_pubkey(pubkey, f), 'hex') + return None def privkey_to_pubkey(privkey): @@ -398,7 +400,9 @@ def bin_hash160(string): digest = '' try: digest = hashlib.new('ripemd160', intermed).digest() - except: + except Exception: + # 'ripemd160' may be unavailable (e.g. OpenSSL 3 legacy provider off); + # fall back to the bundled pure-Python implementation. digest = RIPEMD160(intermed).digest() return digest @@ -423,7 +427,9 @@ def sha256(string): def bin_ripemd160(string): try: digest = hashlib.new('ripemd160', string).digest() - except: + except Exception: + # 'ripemd160' may be unavailable (e.g. OpenSSL 3 legacy provider off); + # fall back to the bundled pure-Python implementation. digest = RIPEMD160(string).digest() return digest @@ -541,7 +547,7 @@ def is_privkey(priv): try: get_privkey_format(priv) return True - except: + except Exception: return False @@ -549,7 +555,7 @@ def is_pubkey(pubkey): try: get_pubkey_format(pubkey) return True - except: + except Exception: return False @@ -677,8 +683,156 @@ def subtract(p1, p2): def magicbyte_to_prefix(magicbyte): + # Always return a 2-tuple of the low/high address prefix characters. + # Callers only test membership over these, so a repeated character when + # first == last is harmless and keeps the return shape consistent. first = bin_to_b58check(hash160Low, magicbyte=magicbyte)[0] last = bin_to_b58check(hash160High, magicbyte=magicbyte)[0] - if first == last: - return (first,) return (first, last) + + +# Explicit public API (added to satisfy CodeQL py/polluting-import). +# Lists the names this module already exported via 'import *', so wildcard +# import behaviour is unchanged. +__all__ = [ + "A", + "B", + "F0", + "F1", + "F2", + "F3", + "F4", + "G", + "Gx", + "Gy", + "K0", + "K1", + "K2", + "K3", + "K4", + "KK0", + "KK1", + "KK2", + "KK3", + "KK4", + "N", + "P", + "PADDING", + "R", + "RIPEMD160", + "RMD160Final", + "RMD160Transform", + "RMD160Update", + "RMDContext", + "ROL", + "access", + "add", + "add_privkeys", + "add_pubkeys", + "b58check_to_bin", + "b58check_to_hex", + "base64", + "bin_dbl_sha256", + "bin_hash160", + "bin_ripemd160", + "bin_sha256", + "bin_slowsha", + "bin_to_b58check", + "binascii", + "bytes_to_hex_string", + "change_curve", + "changebase", + "code_strings", + "compress", + "count", + "dbl_sha256", + "decode", + "decode_privkey", + "decode_pubkey", + "decode_sig", + "decompress", + "deterministic_generate_k", + "digest_size", + "digestsize", + "divide", + "ecdsa_raw_recover", + "ecdsa_raw_sign", + "ecdsa_raw_verify", + "ecdsa_recover", + "ecdsa_sign", + "ecdsa_verify", + "ecdsa_verify_addr", + "electrum_sig_hash", + "encode", + "encode_privkey", + "encode_pubkey", + "encode_sig", + "fast_add", + "fast_multiply", + "from_byte_to_int", + "from_int_representation_to_bytes", + "from_int_to_byte", + "from_jacobian", + "from_string_to_bytes", + "getG", + "get_code_string", + "get_privkey_format", + "get_pubkey_format", + "get_version_byte", + "hash160", + "hash160High", + "hash160Low", + "hash_to_int", + "hashlib", + "hex_to_b58check", + "hex_to_hash160", + "hmac", + "int_types", + "inv", + "is_privkey", + "is_pubkey", + "is_python2", + "isinf", + "jacobian_add", + "jacobian_double", + "jacobian_multiply", + "lpad", + "magicbyte_to_prefix", + "mul_privkeys", + "multiaccess", + "multiply", + "neg_privkey", + "neg_pubkey", + "new", + "num_to_var_int", + "os", + "privkey_to_address", + "privkey_to_pubkey", + "privtoaddr", + "privtopub", + "pubkey_to_address", + "pubkey_to_hash", + "pubkey_to_hash_hex", + "pubtoaddr", + "random", + "random_electrum_seed", + "random_key", + "random_string", + "re", + "ripemd160", + "safe_from_hex", + "safe_hexlify", + "sha256", + "slice", + "slowsha", + "string_or_bytes_types", + "string_types", + "struct", + "subtract", + "subtract_privkeys", + "subtract_pubkeys", + "sum", + "sys", + "time", + "to_jacobian", +] diff --git a/cryptnox_cli/lib/cryptos/mnemonic.py b/cryptnox_cli/lib/cryptos/mnemonic.py index e773055..4a083cc 100644 --- a/cryptnox_cli/lib/cryptos/mnemonic.py +++ b/cryptnox_cli/lib/cryptos/mnemonic.py @@ -16,8 +16,8 @@ from .specials import * from .wallet_utils import is_new_seed -wordlist_english = [word.strip() for word in - list(open(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'english.txt'), 'r'))] +with open(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'english.txt'), 'r') as _wordlist_file: + wordlist_english = [word.strip() for word in _wordlist_file] ELECTRUM_VERSION = '3.0.5' # version of the client package PROTOCOL_VERSION = '1.1' # protocol version requested @@ -226,6 +226,7 @@ def seed_prefix(seed_type): return SEED_PREFIX_SW elif seed_type == '2fa': return SEED_PREFIX_2FA + return None def seed_type(x): @@ -256,3 +257,66 @@ def words_mine(prefix, entbits, satisfunction, wordlist=wordlist_english, random print("Searched %f percent of the space" % (float(count) / float(1 << mine_bits))) return entropy_to_words(eint_to_bytes(pint + dint, entbits)) + + +# Explicit public API (added to satisfy CodeQL py/polluting-import). +# Lists the names this module already exported via 'import *', so wildcard +# import behaviour is unchanged. +__all__ = [ + "CJK_INTERVALS", + "ELECTRUM_VERSION", + "PBKDF2", + "PROTOCOL_VERSION", + "SEED_PREFIX", + "SEED_PREFIX_2FA", + "SEED_PREFIX_SW", + "bin_dbl_sha256", + "bin_to_b58check", + "binascii", + "bip39_is_checksum_valid", + "bip39_mnemonic_to_seed", + "bip39_normalize_passphrase", + "bisect_left", + "bytes_to_hex_string", + "changebase", + "code_strings", + "decode", + "eint_to_bytes", + "electrum_mnemonic_to_seed", + "encode", + "entropy_cs", + "entropy_to_words", + "from_byte_to_int", + "from_int_representation_to_bytes", + "from_int_to_byte", + "from_string_to_bytes", + "get_code_string", + "hashlib", + "hmac", + "int_types", + "is_CJK", + "is_new_seed", + "is_old_seed", + "is_seed", + "lpad", + "mnemonic_int_to_words", + "mnemonic_to_seed", + "normalize_text", + "os", + "random", + "random_string", + "safe_from_hex", + "safe_hexlify", + "seed_prefix", + "seed_type", + "string_or_bytes_types", + "string_types", + "unicodedata", + "whitespace", + "wordlist_english", + "words_bisect", + "words_mine", + "words_split", + "words_to_mnemonic_int", + "words_verify", +] diff --git a/cryptnox_cli/lib/cryptos/ripemd.py b/cryptnox_cli/lib/cryptos/ripemd.py index 86c0b6b..48ca00d 100644 --- a/cryptnox_cli/lib/cryptos/ripemd.py +++ b/cryptnox_cli/lib/cryptos/ripemd.py @@ -52,7 +52,8 @@ try: range = xrange -except: +except NameError: + # Python 3: xrange does not exist; the built-in range is already lazy. pass class RIPEMD160: @@ -164,7 +165,6 @@ def R(a, b, c, d, e, Fj, Kj, sj, rj, X): import struct def RMD160Transform(state, block): #uint32 state[5], uchar block[64] - x = [0]*16 if sys.byteorder == 'little': if is_python2: x = struct.unpack('<16L', ''.join([chr(x) for x in block[0:64]])) @@ -369,8 +369,6 @@ def RMD160Transform(state, block): #uint32 state[5], uchar block[64] state[4] = (state[0] + bb + c) % 0x100000000; state[0] = t % 0x100000000; - pass - def RMD160Update(ctx, inp, inplen): if type(inp) == str: @@ -412,3 +410,39 @@ def RMD160Final(ctx): new('The quick brown fox jumps over the lazy cog').hexdigest() assert '9c1185a5c5e9fc54612808977ee8f548b2258d31' == \ new('').hexdigest() + + +# Explicit public API (added to satisfy CodeQL py/polluting-import). +# Lists the names this module already exported via 'import *', so wildcard +# import behaviour is unchanged. +__all__ = [ + "F0", + "F1", + "F2", + "F3", + "F4", + "K0", + "K1", + "K2", + "K3", + "K4", + "KK0", + "KK1", + "KK2", + "KK3", + "KK4", + "PADDING", + "R", + "RIPEMD160", + "RMD160Final", + "RMD160Transform", + "RMD160Update", + "RMDContext", + "ROL", + "digest_size", + "digestsize", + "is_python2", + "new", + "struct", + "sys", +] diff --git a/cryptnox_cli/lib/cryptos/specials.py b/cryptnox_cli/lib/cryptos/specials.py index b3bfa0b..ebb92fe 100644 --- a/cryptnox_cli/lib/cryptos/specials.py +++ b/cryptnox_cli/lib/cryptos/specials.py @@ -138,3 +138,32 @@ def extract(d, cs): def random_string(x): return str(os.urandom(x)) + + +# Explicit public API (added to satisfy CodeQL py/polluting-import). +# Lists the names this module already exported via 'import *', so wildcard +# import behaviour is unchanged. +__all__ = [ + "bin_dbl_sha256", + "bin_to_b58check", + "binascii", + "bytes_to_hex_string", + "changebase", + "code_strings", + "decode", + "encode", + "from_byte_to_int", + "from_int_representation_to_bytes", + "from_int_to_byte", + "from_string_to_bytes", + "get_code_string", + "hashlib", + "int_types", + "lpad", + "os", + "random_string", + "safe_from_hex", + "safe_hexlify", + "string_or_bytes_types", + "string_types", +] diff --git a/cryptnox_cli/lib/cryptos/stealth.py b/cryptnox_cli/lib/cryptos/stealth.py index ca769d7..3028825 100644 --- a/cryptnox_cli/lib/cryptos/stealth.py +++ b/cryptnox_cli/lib/cryptos/stealth.py @@ -83,6 +83,9 @@ def mk_stealth_tx_outputs(stealth_addr, value, ephem_privkey, nonce, network='bt raise Exception('Invalid testnet stealth address: ' + stealth_addr) magic_byte_addr = 111 + else: + raise Exception('Unknown network: ' + str(network)) + ephem_pubkey = main.privkey_to_pubkey(ephem_privkey) output0 = {'script': mk_stealth_metadata_script(ephem_pubkey, nonce), 'value': 0} @@ -101,3 +104,21 @@ def ephem_pubkey_from_tx_script(stealth_tx_script): if len(stealth_tx_script) != 80: raise Exception('Wrong format for stealth tx output') return stealth_tx_script[14:] + + +# Explicit public API (added to satisfy CodeQL py/polluting-import). +# Lists the names this module already exported via 'import *', so wildcard +# import behaviour is unchanged. +__all__ = [ + "basic_stealth_address_to_pubkeys", + "ephem_pubkey_from_tx_script", + "main", + "mk_stealth_metadata_script", + "mk_stealth_tx_outputs", + "pubkeys_to_basic_stealth_address", + "shared_secret_receiver", + "shared_secret_sender", + "uncover_pay_privkey", + "uncover_pay_pubkey_receiver", + "uncover_pay_pubkey_sender", +] diff --git a/cryptnox_cli/lib/cryptos/transaction.py b/cryptnox_cli/lib/cryptos/transaction.py index 35da75d..8b29cd4 100644 --- a/cryptnox_cli/lib/cryptos/transaction.py +++ b/cryptnox_cli/lib/cryptos/transaction.py @@ -78,7 +78,7 @@ def deserialize(tx): if isinstance(tx, str) and re.match('^[0-9a-fA-F]*$', tx): # tx = bytes(bytearray.fromhex(tx)) return json_changebase(deserialize(binascii.unhexlify(tx)), - lambda x: safe_hexlify(x)) + safe_hexlify) # http://stackoverflow.com/questions/4851463/python-closure-write-to-variable-in-parent-scope # Python's scoping rules are demented, requiring me to make pos an object # so that it is call-by-reference @@ -148,7 +148,7 @@ def serialize(txobj, include_witness=True): txobj = bytes_to_hex_string(txobj) o = [] if json_is_base(txobj, 16): - json_changedbase = json_changebase(txobj, lambda x: binascii.unhexlify(x)) + json_changedbase = json_changebase(txobj, binascii.unhexlify) hexlified = safe_hexlify(serialize(json_changedbase, include_witness=include_witness)) return hexlified o.append(encode_4_bytes(txobj["version"])) @@ -178,7 +178,7 @@ def uahf_digest(txobj, i): o = [] if json_is_base(txobj, 16): - txobj = json_changebase(txobj, lambda x: binascii.unhexlify(x)) + txobj = json_changebase(txobj, binascii.unhexlify) o.append(encode(txobj["version"], 256, 4)[::-1]) serialized_ins = [] @@ -373,7 +373,7 @@ def p2wpkh_nested_script(pubkey): def deserialize_script(script): if isinstance(script, str) and re.match('^[0-9a-fA-F]*$', script): return json_changebase(deserialize_script(binascii.unhexlify(script)), - lambda x: safe_hexlify(x)) + safe_hexlify) out, pos = [], 0 while pos < len(script): code = from_byte_to_int(script[pos]) @@ -420,13 +420,13 @@ def serialize_script_unit(unit): def serialize_script(script): if json_is_base(script, 16): return binascii.hexlify(serialize_script(json_changebase(script, - lambda x: binascii.unhexlify(x)))) + binascii.unhexlify))) return ''.join(map(serialize_script_unit, script)) else: def serialize_script(script): if json_is_base(script, 16): return safe_hexlify(serialize_script(json_changebase(script, - lambda x: binascii.unhexlify(x)))) + binascii.unhexlify))) result = bytes() for b in map(serialize_script_unit, script): result += b if isinstance(b, bytes) else bytes(b, 'utf-8') @@ -507,6 +507,196 @@ def select(unspent, value): i += 1 if tv < value: raise Exception("Not enough funds") - unspents = low[:i] - actual_value = sum(unspent['value'] for unspent in unspents) return low[:i] + + +# Explicit public API (added to satisfy CodeQL py/polluting-import). +# Lists the names this module already exported via 'import *', so wildcard +# import behaviour is unchanged. +__all__ = [ + "A", + "B", + "F0", + "F1", + "F2", + "F3", + "F4", + "G", + "Gx", + "Gy", + "K0", + "K1", + "K2", + "K3", + "K4", + "KK0", + "KK1", + "KK2", + "KK3", + "KK4", + "N", + "P", + "PADDING", + "R", + "RIPEMD160", + "RMD160Final", + "RMD160Transform", + "RMD160Update", + "RMDContext", + "ROL", + "SIGHASH_ALL", + "SIGHASH_ANYONECANPAY", + "SIGHASH_FORKID", + "SIGHASH_NONE", + "SIGHASH_SINGLE", + "access", + "add", + "add_privkeys", + "add_pubkeys", + "apply_multisignatures", + "b58check_to_bin", + "b58check_to_hex", + "base64", + "bin_dbl_sha256", + "bin_hash160", + "bin_ripemd160", + "bin_sha256", + "bin_slowsha", + "bin_to_b58check", + "bin_txhash", + "binascii", + "bytes_to_hex_string", + "change_curve", + "changebase", + "code_strings", + "compress", + "copy", + "count", + "dbl_sha256", + "dbl_sha256_list", + "decode", + "decode_privkey", + "decode_pubkey", + "decode_sig", + "decompress", + "der_decode_sig", + "der_encode_sig", + "deserialize", + "deserialize_script", + "deterministic_generate_k", + "digest_size", + "digestsize", + "divide", + "ecdsa_raw_recover", + "ecdsa_raw_sign", + "ecdsa_raw_verify", + "ecdsa_recover", + "ecdsa_sign", + "ecdsa_tx_recover", + "ecdsa_tx_sign", + "ecdsa_tx_verify", + "ecdsa_verify", + "ecdsa_verify_addr", + "electrum_sig_hash", + "encode", + "encode_1_byte", + "encode_4_bytes", + "encode_8_bytes", + "encode_privkey", + "encode_pubkey", + "encode_sig", + "fast_add", + "fast_multiply", + "from_byte_to_int", + "from_int_representation_to_bytes", + "from_int_to_byte", + "from_jacobian", + "from_string_to_bytes", + "getG", + "get_code_string", + "get_privkey_format", + "get_pubkey_format", + "get_version_byte", + "hash160", + "hash160High", + "hash160Low", + "hash_to_int", + "hashlib", + "hex_to_b58check", + "hex_to_hash160", + "hmac", + "int_types", + "inv", + "is_bip66", + "is_inp", + "is_privkey", + "is_pubkey", + "is_python2", + "is_segwit", + "isinf", + "jacobian_add", + "jacobian_double", + "jacobian_multiply", + "json_changebase", + "json_is_base", + "list_to_bytes", + "lpad", + "magicbyte_to_prefix", + "mk_multisig_script", + "mk_p2w_scripthash_script", + "mk_p2wpkh_redeemscript", + "mk_p2wpkh_script", + "mk_p2wpkh_scriptcode", + "mk_pubkey_script", + "mk_scripthash_script", + "mul_privkeys", + "multiaccess", + "multiply", + "multisign", + "neg_privkey", + "neg_pubkey", + "new", + "num_to_var_int", + "os", + "output_script_to_address", + "p2wpkh_nested_script", + "privkey_to_address", + "privkey_to_pubkey", + "privtoaddr", + "privtopub", + "pubkey_to_address", + "pubkey_to_hash", + "pubkey_to_hash_hex", + "public_txhash", + "pubtoaddr", + "random", + "random_electrum_seed", + "random_key", + "random_string", + "re", + "reduce", + "ripemd160", + "safe_from_hex", + "safe_hexlify", + "select", + "serialize", + "serialize_script", + "serialize_script_unit", + "sha256", + "signature_form", + "slice", + "slowsha", + "string_or_bytes_types", + "string_types", + "struct", + "subtract", + "subtract_privkeys", + "subtract_pubkeys", + "sum", + "sys", + "time", + "to_jacobian", + "txhash", + "uahf_digest", + "verify_tx_input", +] diff --git a/cryptnox_cli/lib/cryptos/wallet.py b/cryptnox_cli/lib/cryptos/wallet.py index 3a8e104..1725990 100644 --- a/cryptnox_cli/lib/cryptos/wallet.py +++ b/cryptnox_cli/lib/cryptos/wallet.py @@ -28,7 +28,7 @@ def __init__(self, keystore, num_addresses=0, last_receiving_index=0, last_chang def privkey(self, address, formt="wif_compressed", password=None): if self.is_watching_only: - return + return None try: addr_derivation = self.addresses[address] except KeyError: @@ -39,7 +39,7 @@ def privkey(self, address, formt="wif_compressed", password=None): def export_privkeys(self, password=None): if self.is_watching_only: - return + return None return { 'receiving': {addr: self.privkey(addr, password=password) for addr in self.receiving_addresses}, 'change': {addr: self.privkey(addr, password=password) for addr in self.change_addresses} @@ -58,6 +58,7 @@ def pubtoaddr(self, pubkey): return self.coin.pubtosegwit(pubkey) elif self.keystore.xtype == "p2wpkh-p2sh": return self.coin.pubtop2w(pubkey) + return None def receiving_address(self, index): pubkey = self.pubkey_receiving(index) @@ -149,4 +150,153 @@ def details(self, password=None): 'xchange': (), 'receiving': [self.account(a, password=password) for a in self.receiving_addresses], 'change': [self.account(a, password=password) for a in self.change_addresses] - } \ No newline at end of file + } + + +# Explicit public API (added to satisfy CodeQL py/polluting-import). +# Lists the names this module already exported via 'import *', so wildcard +# import behaviour is unchanged. +__all__ = [ + "A", + "B", + "F0", + "F1", + "F2", + "F3", + "F4", + "G", + "Gx", + "Gy", + "HDWallet", + "K0", + "K1", + "K2", + "K3", + "K4", + "KK0", + "KK1", + "KK2", + "KK3", + "KK4", + "N", + "P", + "PADDING", + "R", + "RIPEMD160", + "RMD160Final", + "RMD160Transform", + "RMD160Update", + "RMDContext", + "ROL", + "access", + "add", + "add_privkeys", + "add_pubkeys", + "b58check_to_bin", + "b58check_to_hex", + "base64", + "bin_dbl_sha256", + "bin_hash160", + "bin_ripemd160", + "bin_sha256", + "bin_slowsha", + "bin_to_b58check", + "binascii", + "bytes_to_hex_string", + "change_curve", + "changebase", + "code_strings", + "compress", + "count", + "dbl_sha256", + "decode", + "decode_privkey", + "decode_pubkey", + "decode_sig", + "decompress", + "deterministic_generate_k", + "digest_size", + "digestsize", + "divide", + "ecdsa_raw_recover", + "ecdsa_raw_sign", + "ecdsa_raw_verify", + "ecdsa_recover", + "ecdsa_sign", + "ecdsa_verify", + "ecdsa_verify_addr", + "electrum_sig_hash", + "encode", + "encode_privkey", + "encode_pubkey", + "encode_sig", + "fast_add", + "fast_multiply", + "from_byte_to_int", + "from_int_representation_to_bytes", + "from_int_to_byte", + "from_jacobian", + "from_string_to_bytes", + "getG", + "get_code_string", + "get_privkey_format", + "get_pubkey_format", + "get_version_byte", + "hash160", + "hash160High", + "hash160Low", + "hash_to_int", + "hashlib", + "hex_to_b58check", + "hex_to_hash160", + "hmac", + "int_types", + "inv", + "is_privkey", + "is_pubkey", + "is_python2", + "isinf", + "jacobian_add", + "jacobian_double", + "jacobian_multiply", + "lpad", + "magicbyte_to_prefix", + "mul_privkeys", + "multiaccess", + "multiply", + "neg_privkey", + "neg_pubkey", + "new", + "num_to_var_int", + "os", + "privkey_to_address", + "privkey_to_pubkey", + "privtoaddr", + "privtopub", + "pubkey_to_address", + "pubkey_to_hash", + "pubkey_to_hash_hex", + "pubtoaddr", + "random", + "random_electrum_seed", + "random_key", + "random_string", + "re", + "ripemd160", + "safe_from_hex", + "safe_hexlify", + "sha256", + "slice", + "slowsha", + "string_or_bytes_types", + "string_types", + "struct", + "subtract", + "subtract_privkeys", + "subtract_pubkeys", + "sum", + "sys", + "time", + "to_jacobian", + "xpubkey_to_address", +] diff --git a/cryptnox_cli/lib/cryptos/wallet_utils.py b/cryptnox_cli/lib/cryptos/wallet_utils.py index 4e2579e..f046919 100644 --- a/cryptnox_cli/lib/cryptos/wallet_utils.py +++ b/cryptnox_cli/lib/cryptos/wallet_utils.py @@ -78,7 +78,7 @@ def __str__(self): try: from Cryptodome.Cipher import AES -except: +except ImportError: AES = None diff --git a/cryptnox_cli/wallet/btc.py b/cryptnox_cli/wallet/btc.py index 3a060df..11e57ee 100644 --- a/cryptnox_cli/wallet/btc.py +++ b/cryptnox_cli/wallet/btc.py @@ -6,7 +6,6 @@ import json import re import urllib.parse -import urllib.request import requests from enum import Enum from typing import Union, List, Dict @@ -85,13 +84,15 @@ def get_data(self, endpoint: str, params: Dict = None, data: bytes = None) \ if not parsed.hostname or 'blockcypher.com' not in parsed.hostname: raise ValueError("Invalid URL: must be blockcypher.com domain") - req = urllib.request.Request( - full_url, - headers={'User-Agent': 'Mozilla/5.0'}, - data=data - ) - self.web_rsc = urllib.request.urlopen(req, timeout=30) - self.js_res = json.load(self.web_rsc) + # Use 'requests' (validated allow-listed https URL) instead of urllib, + # which would also honour file:// and other local schemes. + headers = {'User-Agent': 'Mozilla/5.0'} + if data is None: + response = requests.get(full_url, headers=headers, timeout=30) + else: + response = requests.post(full_url, headers=headers, data=data, timeout=30) + response.raise_for_status() + self.js_res = response.json() self.web_rsc = None except Exception as ex: print(ex) @@ -237,19 +238,20 @@ def get_data(self, endpoint: str, params: Dict = None, data: bytes = None) \ headers = {'User-Agent': 'Mozilla/5.0'} if self.api_key: headers['x-token'] = self.api_key - req = urllib.request.Request( - full_url, - headers=headers, - data=data - ) - self.web_rsc = urllib.request.urlopen(req, timeout=30) - b_rep = self.web_rsc.read() + # Use 'requests' (validated allow-listed https URL) instead of urllib, + # which would also honour file:// and other local schemes. + if data is None: + response = requests.get(full_url, headers=headers, timeout=30) + else: + response = requests.post(full_url, headers=headers, data=data, timeout=30) + response.raise_for_status() + b_rep = response.content if len(b_rep) == 64 and b_rep[0] != ord('{'): b_rep = b'{"txid":"' + b_rep + b'"}' self.js_res = json.loads(b_rep) - except urllib.error.HTTPError as error: - raise IOError(f"Error while processing request:\n{error.code} - " - f"{error.read().decode('utf8')}") from error + except requests.exceptions.HTTPError as error: + raise IOError(f"Error while processing request:\n{error.response.status_code} - " + f"{error.response.text}") from error except Exception as error: raise IOError(f"Error while processing request:\n{self.url}{endpoint}?params_enc\n" f"{error}") from error diff --git a/cryptnox_cli/wallet/eth/api.py b/cryptnox_cli/wallet/eth/api.py index 631d3ca..6f85483 100644 --- a/cryptnox_cli/wallet/eth/api.py +++ b/cryptnox_cli/wallet/eth/api.py @@ -80,6 +80,7 @@ def transaction_hash(self, transaction: Dict[str, Any], vrs: bool = False): del transaction["maxFeePerGas"] del transaction["maxPriorityFeePerGas"] except KeyError: + # EIP-1559 fee fields absent (legacy transaction); nothing to remove pass unsigned_transaction = serializable_unsigned_transaction_from_dict(transaction) encoded_transaction = encode_transaction(unsigned_transaction, (self._chain_id, 0, 0)) diff --git a/dev-requirements.txt b/dev-requirements.txt index 495be64c0dc74ff7978fe66197c96a54f9aab736..55dc49e3fd14ff2032caf7a1858cd38ca22314d3 100644 GIT binary patch delta 82 zcmZp(>9E=GjFr=pL65-zh>a&ZvRZG}VzXeLEFxquS&oBa^DNE+mdQ>WI+GWOvuw8F m9gP delta 75 zcmeCMX|vhzjFr=ZL65;0geN<)T5r~3vtXWlgwJ4-9LMHaoCPeCMTB%FFA!(hY{kdH d&1wWxXFB<#gyrT2$!AQHm4q!eFObP#1ON{l6)FG# diff --git a/requirements.txt b/requirements.txt index 72b9bfb97a33c57ca510d4d6becfb15e45849a0e..a917212f5e2b88dfea7525c68eb8b5fa7e219588 100644 GIT binary patch delta 53 zcmV-50LuTgEVe9=x|37_Fq2Rf2(j|s1e4MNERqrgvIYnX0W*_94Lh?$5l{mGF_B?8 Lk_k4m0u?d=0viyA delta 55 zcmV-70LcHgEVL|;x|0L~Fq1A82(j|s1d~((ERqrgvIYnX1u_6G05y|Q2{W@m5mW<_ NVmOisHnRj3G6C~h57Gbt From c91b40fe66d97abdb18e9d8f7a799640f91051d6 Mon Sep 17 00:00:00 2001 From: YanNaingWinn Date: Wed, 17 Jun 2026 19:43:02 +0700 Subject: [PATCH 3/5] Remove __all__ blocks that caused CodeQL py/undefined-export errors while keeping all other code-scanning fixes --- cryptnox_cli/lib/cryptos/blocks.py | 150 ------------- cryptnox_cli/lib/cryptos/coins/bitcoin.py | 9 - cryptnox_cli/lib/cryptos/composite.py | 227 -------------------- cryptnox_cli/lib/cryptos/deterministic.py | 178 ---------------- cryptnox_cli/lib/cryptos/keystore.py | 248 ---------------------- cryptnox_cli/lib/cryptos/main.py | 147 ------------- cryptnox_cli/lib/cryptos/mnemonic.py | 63 ------ cryptnox_cli/lib/cryptos/ripemd.py | 36 ---- cryptnox_cli/lib/cryptos/specials.py | 29 --- cryptnox_cli/lib/cryptos/stealth.py | 18 -- cryptnox_cli/lib/cryptos/transaction.py | 192 ----------------- cryptnox_cli/lib/cryptos/wallet.py | 149 ------------- 12 files changed, 1446 deletions(-) diff --git a/cryptnox_cli/lib/cryptos/blocks.py b/cryptnox_cli/lib/cryptos/blocks.py index 05b63fc..61a7cba 100644 --- a/cryptnox_cli/lib/cryptos/blocks.py +++ b/cryptnox_cli/lib/cryptos/blocks.py @@ -53,153 +53,3 @@ def mk_merkle_proof(header, hashes, index): "siblings": [bytes_to_hex_string(x[::-1]) for x in merkle_siblings], "header": header } - - -# Explicit public API (added to satisfy CodeQL py/polluting-import). -# Lists the names this module already exported via 'import *', so wildcard -# import behaviour is unchanged. -__all__ = [ - "A", - "B", - "F0", - "F1", - "F2", - "F3", - "F4", - "G", - "Gx", - "Gy", - "K0", - "K1", - "K2", - "K3", - "K4", - "KK0", - "KK1", - "KK2", - "KK3", - "KK4", - "N", - "P", - "PADDING", - "R", - "RIPEMD160", - "RMD160Final", - "RMD160Transform", - "RMD160Update", - "RMDContext", - "ROL", - "access", - "add", - "add_privkeys", - "add_pubkeys", - "b58check_to_bin", - "b58check_to_hex", - "base64", - "bin_dbl_sha256", - "bin_hash160", - "bin_ripemd160", - "bin_sha256", - "bin_slowsha", - "bin_to_b58check", - "binascii", - "bytes_to_hex_string", - "change_curve", - "changebase", - "code_strings", - "compress", - "count", - "dbl_sha256", - "decode", - "decode_privkey", - "decode_pubkey", - "decode_sig", - "decompress", - "deserialize_header", - "deterministic_generate_k", - "digest_size", - "digestsize", - "divide", - "ecdsa_raw_recover", - "ecdsa_raw_sign", - "ecdsa_raw_verify", - "ecdsa_recover", - "ecdsa_sign", - "ecdsa_verify", - "ecdsa_verify_addr", - "electrum_sig_hash", - "encode", - "encode_privkey", - "encode_pubkey", - "encode_sig", - "fast_add", - "fast_multiply", - "from_byte_to_int", - "from_int_representation_to_bytes", - "from_int_to_byte", - "from_jacobian", - "from_string_to_bytes", - "getG", - "get_code_string", - "get_privkey_format", - "get_pubkey_format", - "get_version_byte", - "hash160", - "hash160High", - "hash160Low", - "hash_to_int", - "hashlib", - "hex_to_b58check", - "hex_to_hash160", - "hmac", - "int_types", - "inv", - "is_privkey", - "is_pubkey", - "is_python2", - "isinf", - "jacobian_add", - "jacobian_double", - "jacobian_multiply", - "lpad", - "magicbyte_to_prefix", - "mk_merkle_proof", - "mul_privkeys", - "multiaccess", - "multiply", - "neg_privkey", - "neg_pubkey", - "new", - "num_to_var_int", - "os", - "privkey_to_address", - "privkey_to_pubkey", - "privtoaddr", - "privtopub", - "pubkey_to_address", - "pubkey_to_hash", - "pubkey_to_hash_hex", - "pubtoaddr", - "random", - "random_electrum_seed", - "random_key", - "random_string", - "re", - "ripemd160", - "safe_from_hex", - "safe_hexlify", - "serialize_header", - "sha256", - "slice", - "slowsha", - "string_or_bytes_types", - "string_types", - "struct", - "subtract", - "subtract_privkeys", - "subtract_pubkeys", - "sum", - "sys", - "time", - "to_jacobian", -] diff --git a/cryptnox_cli/lib/cryptos/coins/bitcoin.py b/cryptnox_cli/lib/cryptos/coins/bitcoin.py index 9a5bbe8..e5d9929 100644 --- a/cryptnox_cli/lib/cryptos/coins/bitcoin.py +++ b/cryptnox_cli/lib/cryptos/coins/bitcoin.py @@ -44,12 +44,3 @@ class Bitcoin(BaseCoin): 'p2wsh': 0x2aa7ed3 }, } - - -# Explicit public API (added to satisfy CodeQL py/polluting-import). -# Lists the names this module already exported via 'import *', so wildcard -# import behaviour is unchanged. -__all__ = [ - "BaseCoin", - "Bitcoin", -] diff --git a/cryptnox_cli/lib/cryptos/composite.py b/cryptnox_cli/lib/cryptos/composite.py index de1f656..7de81e0 100644 --- a/cryptnox_cli/lib/cryptos/composite.py +++ b/cryptnox_cli/lib/cryptos/composite.py @@ -53,230 +53,3 @@ def sign_coinvault_tx(tx, priv): scr = [None] + filter(lambda x: x, scr[1:-1])[:k] + [scr[-1]] txobj['ins'][j]['script'] = serialize_script(scr) return serialize(txobj) - - -# Explicit public API (added to satisfy CodeQL py/polluting-import). -# Lists the names this module already exported via 'import *', so wildcard -# import behaviour is unchanged. -__all__ = [ - "A", - "B", - "DEFAULT", - "F0", - "F1", - "F2", - "F3", - "F4", - "G", - "Gx", - "Gy", - "K0", - "K1", - "K2", - "K3", - "K4", - "KK0", - "KK1", - "KK2", - "KK3", - "KK4", - "MAINNET_PRIVATE", - "MAINNET_PUBLIC", - "N", - "P", - "PADDING", - "PRIVATE", - "PUBLIC", - "R", - "RIPEMD160", - "RMD160Final", - "RMD160Transform", - "RMD160Update", - "RMDContext", - "ROL", - "SIGHASH_ALL", - "SIGHASH_ANYONECANPAY", - "SIGHASH_FORKID", - "SIGHASH_NONE", - "SIGHASH_SINGLE", - "TESTNET_PRIVATE", - "TESTNET_PUBLIC", - "access", - "add", - "add_privkeys", - "add_pubkeys", - "apply_multisignatures", - "b58check_to_bin", - "b58check_to_hex", - "base64", - "bin_dbl_sha256", - "bin_hash160", - "bin_ripemd160", - "bin_sha256", - "bin_slowsha", - "bin_to_b58check", - "bin_txhash", - "binascii", - "bip32_bin_extract_key", - "bip32_ckd", - "bip32_derive_key", - "bip32_descend", - "bip32_deserialize", - "bip32_extract_key", - "bip32_hdm_addr", - "bip32_hdm_script", - "bip32_master_key", - "bip32_privtopub", - "bip32_serialize", - "bytes_to_hex_string", - "change_curve", - "changebase", - "code_strings", - "coinvault_priv_to_bip32", - "coinvault_pub_to_bip32", - "compress", - "copy", - "count", - "crack_bip32_privkey", - "crack_electrum_wallet", - "dbl_sha256", - "dbl_sha256_list", - "decode", - "decode_privkey", - "decode_pubkey", - "decode_sig", - "decompress", - "der_decode_sig", - "der_encode_sig", - "deserialize", - "deserialize_script", - "deterministic_generate_k", - "digest_size", - "digestsize", - "divide", - "ecdsa_raw_recover", - "ecdsa_raw_sign", - "ecdsa_raw_verify", - "ecdsa_recover", - "ecdsa_sign", - "ecdsa_tx_recover", - "ecdsa_tx_sign", - "ecdsa_tx_verify", - "ecdsa_verify", - "ecdsa_verify_addr", - "electrum_address", - "electrum_mpk", - "electrum_privkey", - "electrum_pubkey", - "electrum_sig_hash", - "electrum_stretch", - "encode", - "encode_1_byte", - "encode_4_bytes", - "encode_8_bytes", - "encode_privkey", - "encode_pubkey", - "encode_sig", - "fast_add", - "fast_multiply", - "from_byte_to_int", - "from_int_representation_to_bytes", - "from_int_to_byte", - "from_jacobian", - "from_string_to_bytes", - "getG", - "get_code_string", - "get_privkey_format", - "get_pubkey_format", - "get_version_byte", - "hash160", - "hash160High", - "hash160Low", - "hash_to_int", - "hashlib", - "hex_to_b58check", - "hex_to_hash160", - "hmac", - "int_types", - "inv", - "is_bip66", - "is_inp", - "is_privkey", - "is_pubkey", - "is_python2", - "is_segwit", - "is_xprv", - "is_xpub", - "isinf", - "jacobian_add", - "jacobian_double", - "jacobian_multiply", - "json_changebase", - "json_is_base", - "list_to_bytes", - "lpad", - "magicbyte_to_prefix", - "mk_multisig_script", - "mk_p2w_scripthash_script", - "mk_p2wpkh_redeemscript", - "mk_p2wpkh_script", - "mk_p2wpkh_scriptcode", - "mk_pubkey_script", - "mk_scripthash_script", - "mul_privkeys", - "multiaccess", - "multiply", - "multisign", - "neg_privkey", - "neg_pubkey", - "new", - "num_to_var_int", - "os", - "output_script_to_address", - "p2wpkh_nested_script", - "parse_bip32_path", - "privkey_to_address", - "privkey_to_pubkey", - "privtoaddr", - "privtopub", - "pubkey_to_address", - "pubkey_to_hash", - "pubkey_to_hash_hex", - "public_txhash", - "pubtoaddr", - "random", - "random_electrum_seed", - "random_key", - "random_string", - "raw_bip32_ckd", - "raw_bip32_privtopub", - "raw_crack_bip32_privkey", - "re", - "reduce", - "ripemd160", - "safe_from_hex", - "safe_hexlify", - "select", - "serialize", - "serialize_script", - "serialize_script_unit", - "setup_coinvault_tx", - "sha256", - "sign_coinvault_tx", - "signature_form", - "slice", - "slowsha", - "string_or_bytes_types", - "string_types", - "struct", - "subtract", - "subtract_privkeys", - "subtract_pubkeys", - "sum", - "sys", - "time", - "to_jacobian", - "txhash", - "uahf_digest", - "verify_tx_input", -] diff --git a/cryptnox_cli/lib/cryptos/deterministic.py b/cryptnox_cli/lib/cryptos/deterministic.py index a660b47..7045d69 100644 --- a/cryptnox_cli/lib/cryptos/deterministic.py +++ b/cryptnox_cli/lib/cryptos/deterministic.py @@ -248,181 +248,3 @@ def parse_bip32_path(path): v = int(v) & 0x7fffffff patharr.append(v) return patharr - - -# Explicit public API (added to satisfy CodeQL py/polluting-import). -# Lists the names this module already exported via 'import *', so wildcard -# import behaviour is unchanged. -__all__ = [ - "A", - "B", - "DEFAULT", - "F0", - "F1", - "F2", - "F3", - "F4", - "G", - "Gx", - "Gy", - "K0", - "K1", - "K2", - "K3", - "K4", - "KK0", - "KK1", - "KK2", - "KK3", - "KK4", - "MAINNET_PRIVATE", - "MAINNET_PUBLIC", - "N", - "P", - "PADDING", - "PRIVATE", - "PUBLIC", - "R", - "RIPEMD160", - "RMD160Final", - "RMD160Transform", - "RMD160Update", - "RMDContext", - "ROL", - "TESTNET_PRIVATE", - "TESTNET_PUBLIC", - "access", - "add", - "add_privkeys", - "add_pubkeys", - "b58check_to_bin", - "b58check_to_hex", - "base64", - "bin_dbl_sha256", - "bin_hash160", - "bin_ripemd160", - "bin_sha256", - "bin_slowsha", - "bin_to_b58check", - "binascii", - "bip32_bin_extract_key", - "bip32_ckd", - "bip32_derive_key", - "bip32_descend", - "bip32_deserialize", - "bip32_extract_key", - "bip32_master_key", - "bip32_privtopub", - "bip32_serialize", - "bytes_to_hex_string", - "change_curve", - "changebase", - "code_strings", - "coinvault_priv_to_bip32", - "coinvault_pub_to_bip32", - "compress", - "count", - "crack_bip32_privkey", - "crack_electrum_wallet", - "dbl_sha256", - "decode", - "decode_privkey", - "decode_pubkey", - "decode_sig", - "decompress", - "deterministic_generate_k", - "digest_size", - "digestsize", - "divide", - "ecdsa_raw_recover", - "ecdsa_raw_sign", - "ecdsa_raw_verify", - "ecdsa_recover", - "ecdsa_sign", - "ecdsa_verify", - "ecdsa_verify_addr", - "electrum_address", - "electrum_mpk", - "electrum_privkey", - "electrum_pubkey", - "electrum_sig_hash", - "electrum_stretch", - "encode", - "encode_privkey", - "encode_pubkey", - "encode_sig", - "fast_add", - "fast_multiply", - "from_byte_to_int", - "from_int_representation_to_bytes", - "from_int_to_byte", - "from_jacobian", - "from_string_to_bytes", - "getG", - "get_code_string", - "get_privkey_format", - "get_pubkey_format", - "get_version_byte", - "hash160", - "hash160High", - "hash160Low", - "hash_to_int", - "hashlib", - "hex_to_b58check", - "hex_to_hash160", - "hmac", - "int_types", - "inv", - "is_privkey", - "is_pubkey", - "is_python2", - "is_xprv", - "is_xpub", - "isinf", - "jacobian_add", - "jacobian_double", - "jacobian_multiply", - "lpad", - "magicbyte_to_prefix", - "mul_privkeys", - "multiaccess", - "multiply", - "neg_privkey", - "neg_pubkey", - "new", - "num_to_var_int", - "os", - "parse_bip32_path", - "privkey_to_address", - "privkey_to_pubkey", - "privtoaddr", - "privtopub", - "pubkey_to_address", - "pubkey_to_hash", - "pubkey_to_hash_hex", - "pubtoaddr", - "random", - "random_electrum_seed", - "random_key", - "random_string", - "raw_bip32_ckd", - "raw_bip32_privtopub", - "raw_crack_bip32_privkey", - "re", - "ripemd160", - "safe_from_hex", - "safe_hexlify", - "sha256", - "slice", - "slowsha", - "string_or_bytes_types", - "string_types", - "struct", - "subtract", - "subtract_privkeys", - "subtract_pubkeys", - "sum", - "sys", - "time", - "to_jacobian", -] diff --git a/cryptnox_cli/lib/cryptos/keystore.py b/cryptnox_cli/lib/cryptos/keystore.py index 283b855..781aada 100644 --- a/cryptnox_cli/lib/cryptos/keystore.py +++ b/cryptnox_cli/lib/cryptos/keystore.py @@ -574,251 +574,3 @@ def from_master_key(text, coin): else: raise BaseException('Invalid key') return k - - -# Explicit public API (added to satisfy CodeQL py/polluting-import). -# Lists the names this module already exported via 'import *', so wildcard -# import behaviour is unchanged. -__all__ = [ - "A", - "B", - "BIP32_KeyStore", - "CJK_INTERVALS", - "DEFAULT", - "Deterministic_KeyStore", - "ELECTRUM_VERSION", - "F0", - "F1", - "F2", - "F3", - "F4", - "G", - "Gx", - "Gy", - "Hardware_KeyStore", - "Imported_KeyStore", - "InvalidPassword", - "K0", - "K1", - "K2", - "K3", - "K4", - "KK0", - "KK1", - "KK2", - "KK3", - "KK4", - "KeyStore", - "MAINNET_PRIVATE", - "MAINNET_PUBLIC", - "N", - "P", - "PADDING", - "PBKDF2", - "PRIVATE", - "PROTOCOL_VERSION", - "PUBLIC", - "R", - "RIPEMD160", - "RMD160Final", - "RMD160Transform", - "RMD160Update", - "RMDContext", - "ROL", - "SEED_PREFIX", - "SEED_PREFIX_2FA", - "SEED_PREFIX_SW", - "Software_KeyStore", - "TESTNET_PRIVATE", - "TESTNET_PUBLIC", - "Xpub", - "access", - "add", - "add_privkeys", - "add_pubkeys", - "b58check_to_bin", - "b58check_to_hex", - "base64", - "bin_dbl_sha256", - "bin_hash160", - "bin_ripemd160", - "bin_sha256", - "bin_slowsha", - "bin_to_b58check", - "binascii", - "bip32_bin_extract_key", - "bip32_ckd", - "bip32_derive_key", - "bip32_descend", - "bip32_deserialize", - "bip32_extract_key", - "bip32_master_key", - "bip32_privtopub", - "bip32_serialize", - "bip39_is_checksum_valid", - "bip39_mnemonic_to_seed", - "bip39_normalize_passphrase", - "bip39_to_seed", - "bisect_left", - "bytes_to_hex_string", - "change_curve", - "changebase", - "code_strings", - "coinvault_priv_to_bip32", - "coinvault_pub_to_bip32", - "compress", - "count", - "crack_bip32_privkey", - "crack_electrum_wallet", - "dbl_sha256", - "decode", - "decode_privkey", - "decode_pubkey", - "decode_sig", - "decompress", - "deterministic_generate_k", - "digest_size", - "digestsize", - "divide", - "ecdsa_raw_recover", - "ecdsa_raw_sign", - "ecdsa_raw_verify", - "ecdsa_recover", - "ecdsa_sign", - "ecdsa_verify", - "ecdsa_verify_addr", - "eint_to_bytes", - "electrum_address", - "electrum_mnemonic_to_seed", - "electrum_mpk", - "electrum_privkey", - "electrum_pubkey", - "electrum_sig_hash", - "electrum_stretch", - "encode", - "encode_privkey", - "encode_pubkey", - "encode_sig", - "entropy_cs", - "entropy_to_words", - "fast_add", - "fast_multiply", - "from_bip39_seed", - "from_byte_to_int", - "from_electrum_seed", - "from_int_representation_to_bytes", - "from_int_to_byte", - "from_jacobian", - "from_master_key", - "from_private_key_list", - "from_string_to_bytes", - "from_xprv", - "from_xpub", - "getG", - "get_code_string", - "get_private_keys", - "get_privkey_format", - "get_pubkey_format", - "get_version_byte", - "hardware_keystore", - "hash160", - "hash160High", - "hash160Low", - "hash_to_int", - "hashlib", - "hex_to_b58check", - "hex_to_hash160", - "hfu", - "hmac", - "hw_keystores", - "int_types", - "inv", - "is_CJK", - "is_address_list", - "is_bip32_key", - "is_master_key", - "is_mpk", - "is_new_seed", - "is_old_seed", - "is_private", - "is_private_key", - "is_private_key_list", - "is_privkey", - "is_pubkey", - "is_python2", - "is_seed", - "is_xprv", - "is_xpub", - "is_xpubkey", - "isinf", - "jacobian_add", - "jacobian_double", - "jacobian_multiply", - "lpad", - "magicbyte_to_prefix", - "mnemonic_int_to_words", - "mnemonic_to_seed", - "mul_privkeys", - "multiaccess", - "multiply", - "neg_privkey", - "neg_pubkey", - "new", - "normalize", - "normalize_text", - "num_to_var_int", - "os", - "p2wpkh_from_bip39_seed", - "p2wpkh_p2sh_from_bip39_seed", - "parse_bip32_path", - "parse_xpubkey", - "privkey_to_address", - "privkey_to_pubkey", - "privtoaddr", - "privtopub", - "pubkey_to_address", - "pubkey_to_hash", - "pubkey_to_hash_hex", - "pubtoaddr", - "pw_decode", - "pw_encode", - "random", - "random_electrum_seed", - "random_key", - "random_string", - "raw_bip32_ckd", - "raw_bip32_privtopub", - "raw_crack_bip32_privkey", - "re", - "register_keystore", - "ripemd160", - "safe_from_hex", - "safe_hexlify", - "seed_prefix", - "seed_type", - "sha256", - "slice", - "slowsha", - "standard_from_bip39_seed", - "string_or_bytes_types", - "string_types", - "struct", - "subtract", - "subtract_privkeys", - "subtract_pubkeys", - "sum", - "sys", - "time", - "to_jacobian", - "unicodedata", - "whitespace", - "wordlist_english", - "words_bisect", - "words_mine", - "words_split", - "words_to_mnemonic_int", - "words_verify", - "xpubkey_to_address", - "xpubkey_to_pubkey", - "xtype_from_derivation", -] diff --git a/cryptnox_cli/lib/cryptos/main.py b/cryptnox_cli/lib/cryptos/main.py index aebf222..d82da9f 100644 --- a/cryptnox_cli/lib/cryptos/main.py +++ b/cryptnox_cli/lib/cryptos/main.py @@ -689,150 +689,3 @@ def magicbyte_to_prefix(magicbyte): first = bin_to_b58check(hash160Low, magicbyte=magicbyte)[0] last = bin_to_b58check(hash160High, magicbyte=magicbyte)[0] return (first, last) - - -# Explicit public API (added to satisfy CodeQL py/polluting-import). -# Lists the names this module already exported via 'import *', so wildcard -# import behaviour is unchanged. -__all__ = [ - "A", - "B", - "F0", - "F1", - "F2", - "F3", - "F4", - "G", - "Gx", - "Gy", - "K0", - "K1", - "K2", - "K3", - "K4", - "KK0", - "KK1", - "KK2", - "KK3", - "KK4", - "N", - "P", - "PADDING", - "R", - "RIPEMD160", - "RMD160Final", - "RMD160Transform", - "RMD160Update", - "RMDContext", - "ROL", - "access", - "add", - "add_privkeys", - "add_pubkeys", - "b58check_to_bin", - "b58check_to_hex", - "base64", - "bin_dbl_sha256", - "bin_hash160", - "bin_ripemd160", - "bin_sha256", - "bin_slowsha", - "bin_to_b58check", - "binascii", - "bytes_to_hex_string", - "change_curve", - "changebase", - "code_strings", - "compress", - "count", - "dbl_sha256", - "decode", - "decode_privkey", - "decode_pubkey", - "decode_sig", - "decompress", - "deterministic_generate_k", - "digest_size", - "digestsize", - "divide", - "ecdsa_raw_recover", - "ecdsa_raw_sign", - "ecdsa_raw_verify", - "ecdsa_recover", - "ecdsa_sign", - "ecdsa_verify", - "ecdsa_verify_addr", - "electrum_sig_hash", - "encode", - "encode_privkey", - "encode_pubkey", - "encode_sig", - "fast_add", - "fast_multiply", - "from_byte_to_int", - "from_int_representation_to_bytes", - "from_int_to_byte", - "from_jacobian", - "from_string_to_bytes", - "getG", - "get_code_string", - "get_privkey_format", - "get_pubkey_format", - "get_version_byte", - "hash160", - "hash160High", - "hash160Low", - "hash_to_int", - "hashlib", - "hex_to_b58check", - "hex_to_hash160", - "hmac", - "int_types", - "inv", - "is_privkey", - "is_pubkey", - "is_python2", - "isinf", - "jacobian_add", - "jacobian_double", - "jacobian_multiply", - "lpad", - "magicbyte_to_prefix", - "mul_privkeys", - "multiaccess", - "multiply", - "neg_privkey", - "neg_pubkey", - "new", - "num_to_var_int", - "os", - "privkey_to_address", - "privkey_to_pubkey", - "privtoaddr", - "privtopub", - "pubkey_to_address", - "pubkey_to_hash", - "pubkey_to_hash_hex", - "pubtoaddr", - "random", - "random_electrum_seed", - "random_key", - "random_string", - "re", - "ripemd160", - "safe_from_hex", - "safe_hexlify", - "sha256", - "slice", - "slowsha", - "string_or_bytes_types", - "string_types", - "struct", - "subtract", - "subtract_privkeys", - "subtract_pubkeys", - "sum", - "sys", - "time", - "to_jacobian", -] diff --git a/cryptnox_cli/lib/cryptos/mnemonic.py b/cryptnox_cli/lib/cryptos/mnemonic.py index 4a083cc..acf784b 100644 --- a/cryptnox_cli/lib/cryptos/mnemonic.py +++ b/cryptnox_cli/lib/cryptos/mnemonic.py @@ -257,66 +257,3 @@ def words_mine(prefix, entbits, satisfunction, wordlist=wordlist_english, random print("Searched %f percent of the space" % (float(count) / float(1 << mine_bits))) return entropy_to_words(eint_to_bytes(pint + dint, entbits)) - - -# Explicit public API (added to satisfy CodeQL py/polluting-import). -# Lists the names this module already exported via 'import *', so wildcard -# import behaviour is unchanged. -__all__ = [ - "CJK_INTERVALS", - "ELECTRUM_VERSION", - "PBKDF2", - "PROTOCOL_VERSION", - "SEED_PREFIX", - "SEED_PREFIX_2FA", - "SEED_PREFIX_SW", - "bin_dbl_sha256", - "bin_to_b58check", - "binascii", - "bip39_is_checksum_valid", - "bip39_mnemonic_to_seed", - "bip39_normalize_passphrase", - "bisect_left", - "bytes_to_hex_string", - "changebase", - "code_strings", - "decode", - "eint_to_bytes", - "electrum_mnemonic_to_seed", - "encode", - "entropy_cs", - "entropy_to_words", - "from_byte_to_int", - "from_int_representation_to_bytes", - "from_int_to_byte", - "from_string_to_bytes", - "get_code_string", - "hashlib", - "hmac", - "int_types", - "is_CJK", - "is_new_seed", - "is_old_seed", - "is_seed", - "lpad", - "mnemonic_int_to_words", - "mnemonic_to_seed", - "normalize_text", - "os", - "random", - "random_string", - "safe_from_hex", - "safe_hexlify", - "seed_prefix", - "seed_type", - "string_or_bytes_types", - "string_types", - "unicodedata", - "whitespace", - "wordlist_english", - "words_bisect", - "words_mine", - "words_split", - "words_to_mnemonic_int", - "words_verify", -] diff --git a/cryptnox_cli/lib/cryptos/ripemd.py b/cryptnox_cli/lib/cryptos/ripemd.py index 48ca00d..8415a3c 100644 --- a/cryptnox_cli/lib/cryptos/ripemd.py +++ b/cryptnox_cli/lib/cryptos/ripemd.py @@ -410,39 +410,3 @@ def RMD160Final(ctx): new('The quick brown fox jumps over the lazy cog').hexdigest() assert '9c1185a5c5e9fc54612808977ee8f548b2258d31' == \ new('').hexdigest() - - -# Explicit public API (added to satisfy CodeQL py/polluting-import). -# Lists the names this module already exported via 'import *', so wildcard -# import behaviour is unchanged. -__all__ = [ - "F0", - "F1", - "F2", - "F3", - "F4", - "K0", - "K1", - "K2", - "K3", - "K4", - "KK0", - "KK1", - "KK2", - "KK3", - "KK4", - "PADDING", - "R", - "RIPEMD160", - "RMD160Final", - "RMD160Transform", - "RMD160Update", - "RMDContext", - "ROL", - "digest_size", - "digestsize", - "is_python2", - "new", - "struct", - "sys", -] diff --git a/cryptnox_cli/lib/cryptos/specials.py b/cryptnox_cli/lib/cryptos/specials.py index ebb92fe..b3bfa0b 100644 --- a/cryptnox_cli/lib/cryptos/specials.py +++ b/cryptnox_cli/lib/cryptos/specials.py @@ -138,32 +138,3 @@ def extract(d, cs): def random_string(x): return str(os.urandom(x)) - - -# Explicit public API (added to satisfy CodeQL py/polluting-import). -# Lists the names this module already exported via 'import *', so wildcard -# import behaviour is unchanged. -__all__ = [ - "bin_dbl_sha256", - "bin_to_b58check", - "binascii", - "bytes_to_hex_string", - "changebase", - "code_strings", - "decode", - "encode", - "from_byte_to_int", - "from_int_representation_to_bytes", - "from_int_to_byte", - "from_string_to_bytes", - "get_code_string", - "hashlib", - "int_types", - "lpad", - "os", - "random_string", - "safe_from_hex", - "safe_hexlify", - "string_or_bytes_types", - "string_types", -] diff --git a/cryptnox_cli/lib/cryptos/stealth.py b/cryptnox_cli/lib/cryptos/stealth.py index 3028825..6a6c0c2 100644 --- a/cryptnox_cli/lib/cryptos/stealth.py +++ b/cryptnox_cli/lib/cryptos/stealth.py @@ -104,21 +104,3 @@ def ephem_pubkey_from_tx_script(stealth_tx_script): if len(stealth_tx_script) != 80: raise Exception('Wrong format for stealth tx output') return stealth_tx_script[14:] - - -# Explicit public API (added to satisfy CodeQL py/polluting-import). -# Lists the names this module already exported via 'import *', so wildcard -# import behaviour is unchanged. -__all__ = [ - "basic_stealth_address_to_pubkeys", - "ephem_pubkey_from_tx_script", - "main", - "mk_stealth_metadata_script", - "mk_stealth_tx_outputs", - "pubkeys_to_basic_stealth_address", - "shared_secret_receiver", - "shared_secret_sender", - "uncover_pay_privkey", - "uncover_pay_pubkey_receiver", - "uncover_pay_pubkey_sender", -] diff --git a/cryptnox_cli/lib/cryptos/transaction.py b/cryptnox_cli/lib/cryptos/transaction.py index 8b29cd4..e442ad2 100644 --- a/cryptnox_cli/lib/cryptos/transaction.py +++ b/cryptnox_cli/lib/cryptos/transaction.py @@ -508,195 +508,3 @@ def select(unspent, value): if tv < value: raise Exception("Not enough funds") return low[:i] - - -# Explicit public API (added to satisfy CodeQL py/polluting-import). -# Lists the names this module already exported via 'import *', so wildcard -# import behaviour is unchanged. -__all__ = [ - "A", - "B", - "F0", - "F1", - "F2", - "F3", - "F4", - "G", - "Gx", - "Gy", - "K0", - "K1", - "K2", - "K3", - "K4", - "KK0", - "KK1", - "KK2", - "KK3", - "KK4", - "N", - "P", - "PADDING", - "R", - "RIPEMD160", - "RMD160Final", - "RMD160Transform", - "RMD160Update", - "RMDContext", - "ROL", - "SIGHASH_ALL", - "SIGHASH_ANYONECANPAY", - "SIGHASH_FORKID", - "SIGHASH_NONE", - "SIGHASH_SINGLE", - "access", - "add", - "add_privkeys", - "add_pubkeys", - "apply_multisignatures", - "b58check_to_bin", - "b58check_to_hex", - "base64", - "bin_dbl_sha256", - "bin_hash160", - "bin_ripemd160", - "bin_sha256", - "bin_slowsha", - "bin_to_b58check", - "bin_txhash", - "binascii", - "bytes_to_hex_string", - "change_curve", - "changebase", - "code_strings", - "compress", - "copy", - "count", - "dbl_sha256", - "dbl_sha256_list", - "decode", - "decode_privkey", - "decode_pubkey", - "decode_sig", - "decompress", - "der_decode_sig", - "der_encode_sig", - "deserialize", - "deserialize_script", - "deterministic_generate_k", - "digest_size", - "digestsize", - "divide", - "ecdsa_raw_recover", - "ecdsa_raw_sign", - "ecdsa_raw_verify", - "ecdsa_recover", - "ecdsa_sign", - "ecdsa_tx_recover", - "ecdsa_tx_sign", - "ecdsa_tx_verify", - "ecdsa_verify", - "ecdsa_verify_addr", - "electrum_sig_hash", - "encode", - "encode_1_byte", - "encode_4_bytes", - "encode_8_bytes", - "encode_privkey", - "encode_pubkey", - "encode_sig", - "fast_add", - "fast_multiply", - "from_byte_to_int", - "from_int_representation_to_bytes", - "from_int_to_byte", - "from_jacobian", - "from_string_to_bytes", - "getG", - "get_code_string", - "get_privkey_format", - "get_pubkey_format", - "get_version_byte", - "hash160", - "hash160High", - "hash160Low", - "hash_to_int", - "hashlib", - "hex_to_b58check", - "hex_to_hash160", - "hmac", - "int_types", - "inv", - "is_bip66", - "is_inp", - "is_privkey", - "is_pubkey", - "is_python2", - "is_segwit", - "isinf", - "jacobian_add", - "jacobian_double", - "jacobian_multiply", - "json_changebase", - "json_is_base", - "list_to_bytes", - "lpad", - "magicbyte_to_prefix", - "mk_multisig_script", - "mk_p2w_scripthash_script", - "mk_p2wpkh_redeemscript", - "mk_p2wpkh_script", - "mk_p2wpkh_scriptcode", - "mk_pubkey_script", - "mk_scripthash_script", - "mul_privkeys", - "multiaccess", - "multiply", - "multisign", - "neg_privkey", - "neg_pubkey", - "new", - "num_to_var_int", - "os", - "output_script_to_address", - "p2wpkh_nested_script", - "privkey_to_address", - "privkey_to_pubkey", - "privtoaddr", - "privtopub", - "pubkey_to_address", - "pubkey_to_hash", - "pubkey_to_hash_hex", - "public_txhash", - "pubtoaddr", - "random", - "random_electrum_seed", - "random_key", - "random_string", - "re", - "reduce", - "ripemd160", - "safe_from_hex", - "safe_hexlify", - "select", - "serialize", - "serialize_script", - "serialize_script_unit", - "sha256", - "signature_form", - "slice", - "slowsha", - "string_or_bytes_types", - "string_types", - "struct", - "subtract", - "subtract_privkeys", - "subtract_pubkeys", - "sum", - "sys", - "time", - "to_jacobian", - "txhash", - "uahf_digest", - "verify_tx_input", -] diff --git a/cryptnox_cli/lib/cryptos/wallet.py b/cryptnox_cli/lib/cryptos/wallet.py index 1725990..a509642 100644 --- a/cryptnox_cli/lib/cryptos/wallet.py +++ b/cryptnox_cli/lib/cryptos/wallet.py @@ -151,152 +151,3 @@ def details(self, password=None): 'receiving': [self.account(a, password=password) for a in self.receiving_addresses], 'change': [self.account(a, password=password) for a in self.change_addresses] } - - -# Explicit public API (added to satisfy CodeQL py/polluting-import). -# Lists the names this module already exported via 'import *', so wildcard -# import behaviour is unchanged. -__all__ = [ - "A", - "B", - "F0", - "F1", - "F2", - "F3", - "F4", - "G", - "Gx", - "Gy", - "HDWallet", - "K0", - "K1", - "K2", - "K3", - "K4", - "KK0", - "KK1", - "KK2", - "KK3", - "KK4", - "N", - "P", - "PADDING", - "R", - "RIPEMD160", - "RMD160Final", - "RMD160Transform", - "RMD160Update", - "RMDContext", - "ROL", - "access", - "add", - "add_privkeys", - "add_pubkeys", - "b58check_to_bin", - "b58check_to_hex", - "base64", - "bin_dbl_sha256", - "bin_hash160", - "bin_ripemd160", - "bin_sha256", - "bin_slowsha", - "bin_to_b58check", - "binascii", - "bytes_to_hex_string", - "change_curve", - "changebase", - "code_strings", - "compress", - "count", - "dbl_sha256", - "decode", - "decode_privkey", - "decode_pubkey", - "decode_sig", - "decompress", - "deterministic_generate_k", - "digest_size", - "digestsize", - "divide", - "ecdsa_raw_recover", - "ecdsa_raw_sign", - "ecdsa_raw_verify", - "ecdsa_recover", - "ecdsa_sign", - "ecdsa_verify", - "ecdsa_verify_addr", - "electrum_sig_hash", - "encode", - "encode_privkey", - "encode_pubkey", - "encode_sig", - "fast_add", - "fast_multiply", - "from_byte_to_int", - "from_int_representation_to_bytes", - "from_int_to_byte", - "from_jacobian", - "from_string_to_bytes", - "getG", - "get_code_string", - "get_privkey_format", - "get_pubkey_format", - "get_version_byte", - "hash160", - "hash160High", - "hash160Low", - "hash_to_int", - "hashlib", - "hex_to_b58check", - "hex_to_hash160", - "hmac", - "int_types", - "inv", - "is_privkey", - "is_pubkey", - "is_python2", - "isinf", - "jacobian_add", - "jacobian_double", - "jacobian_multiply", - "lpad", - "magicbyte_to_prefix", - "mul_privkeys", - "multiaccess", - "multiply", - "neg_privkey", - "neg_pubkey", - "new", - "num_to_var_int", - "os", - "privkey_to_address", - "privkey_to_pubkey", - "privtoaddr", - "privtopub", - "pubkey_to_address", - "pubkey_to_hash", - "pubkey_to_hash_hex", - "pubtoaddr", - "random", - "random_electrum_seed", - "random_key", - "random_string", - "re", - "ripemd160", - "safe_from_hex", - "safe_hexlify", - "sha256", - "slice", - "slowsha", - "string_or_bytes_types", - "string_types", - "struct", - "subtract", - "subtract_privkeys", - "subtract_pubkeys", - "sum", - "sys", - "time", - "to_jacobian", - "xpubkey_to_address", -] From a68d9aa7a839bdd4bc3a14bb0e9ec9245333d992 Mon Sep 17 00:00:00 2001 From: YanNaingWinn Date: Thu, 18 Jun 2026 18:43:33 +0700 Subject: [PATCH 4/5] Re-encode requirements files as UTF-8 --- dev-requirements.txt | Bin 7688 -> 3759 bytes requirements.txt | Bin 5686 -> 2783 bytes 2 files changed, 0 insertions(+), 0 deletions(-) diff --git a/dev-requirements.txt b/dev-requirements.txt index 55dc49e3fd14ff2032caf7a1858cd38ca22314d3..ec683d3a235f84779b02527ead604e7e65bbf6a5 100644 GIT binary patch literal 3759 zcmbVPO>g5i5WVYHxF=sKMv@)d>8|n{7U-deq6lb-wg^)sm!z5~zrJrMJ6R*9g63kt z&Tzio%$t{7F1iq`|Ksk?j#e_`j(1-6R*8(OaCF>ubzQJ>%hnn9!5P`s^@^?7{kMf3 zLud5UVNmMnU*Wtodhu8f=@ypWxKP*ktX#3`&Fn^+J4&-}8on14f17l= zf!S!sx-Q9QD)er$%Ee0%n!4fXK|0m@WoCJE;zy~esP!+&UY8HYRve^4mQ_)qD7H;^ z^U~o~I>cY2t7!chs*i5fa6HDk?&r#~qtrfdrG%^N4J*-x4?e#W@a1~B;JQu6dv}y~ z#+-Z(OoNmASlODDGrhH=k{Y+~4Gu1kB;ych9`G*juzOf;>J*QR_(P-(?BH~9&pvXGhxtoVI_8KjSjK34RxhU?Jf zd=G%;@Za6^4PLxBXc{vRgT<9wC))R!myY}HZ#%{og9du>&;0HB%->0j(`hLfDC3Js z!AT^!O>!zeOT#Iwf26T5rZDjoA(Wn~&ypB|B)0l0$OmU$g;tX8PC3tbop{;P=^;Z@ z{e_xkt1;{t)^{cLfhwSccAKJ{Z|pWXwzU0n`4%CwhZgJXMu7hl1^>Z`v zW(hIkNMo^TI|B*KeZw7eFbtE`<5*3+l()D-G+1O$YQ!2JZgVGe-AycR(o^&gc7!5? zazwDBP?g znhQun>&(jJxa>Ie$rO`|isR`e(!q&Lo%8?MMITyedhSm|qXpY!f$s-2B#tNWN~|Uh z)Z2NQt0N1JYY%_){{WOONqtBPl2yXzS1rRZF+#H}%9$RSz$152)Rj;LiI!uf{saCsq@4f& literal 7688 zcmchcOK&1q5QXnLQvQRpnoUT6@nf9VZ-|sd7Ev_97~9C^5gKRA{P-m2yQhn8JdDk4 zlo0}B=&m~TI#sv$_n%&xrjvA+)_N>cm3~Oy>#6(>fOw)C~;;p{pd6s^ZRZJ7@RHn% zt<);pvCh)YByEs=Gu$KZFt5JLh>UqAykmLmN>KfN@xUf~6GnhL@Wd)3J(pA} zhS%5Y;ioMV3}oXQ{WnsKuJyNzjr%b5G9xXN0afbNwF`?)RS`|>@bBO#Z#-mwxQ2-o z&wU;^tb*ITXirRp-_rdZ8eaErn`_&#qtcMq%YJTSr`Co!exIUVNvX^>=7!se<2v&YRs^e2d-h3rpZHBk?{Wm6a({v$iQq-PjJEV5!S09F zS3CZfH6tQ#CVBU=*BRwbkG)+P(a|u!exA!+Wyk0l3G+gJV@jbeCi!_)bC5lRACKX- z(BT=1>~bv|eOb+g&n=VAb}N2^F_B9Yky=_6QE71HT>gNAsc2`VbE~O~F5N!r&VFup zqQD$8A@d|XmQLkv7*{xtK?dJOY&_p|x0zU@=}dKC{_a){F&|vzDgZyTue&4h_RQhA zl-{=1b@Y7eq~F^TS7K@1#56UQ%tmTxb&l=MxJJ1Y-b6Tdrt=r)g*Raw-- zSoq2Qb++tD7FMc>d;P_CQE~2Yj%-}N$o6%Fw+cYoZ`?s|VIg70Mk zr=W?V2yS9I-pK&_cA`(OWo2_(8mQBj@i-nQ9}k_q%s3~?7*2CO$Mw^8F&RCjW$LXWAn;ws1rGD;7x0&I-v?tmV z7&+_-X#W}HwG-oU`N6Eq+1OF}@^yWqF0jbmY%Ua2;c!*csqK~W*uYs#`%mI4SUt`i z$aKuhWp?v2yEl3RF*e`s+rGUN;g~(}%tCd0u8J9Cd0n%Y{#$Adb?RQgobyp$Wp~L= zl9{C8VK5DI&zOm!*;3*Gws5}2`-W~+PgG-eMK@a~CaA|ccijhg^(?#0nYEN|c1q+! zbPG^+;TH2FZ<88+nu|4Bw7hnPB_NGdrwmOZD!Bod6gd zRr=Sy9mz}C8z&Pitb~?%*4t>yERRE+(U2JX>t6Nft*koaYlib`8V<_^sS`!6is<_A}11zPQD?^ZX>^{S4l1@9uwB z_Obh0NK#dE1Nm~R=Tn_EVUstEUALh~{Y&2P4lGWlYz47&6yQxkxi`xvkvPS& zS+I|M9xa^=|L@GCQebU1Pt3RXIiAiqP9HD^C)g`R#o5wut1GT7CUGMC^!$Z?N@|vj z2+m=T0Z&#nMxVB^jeT2t=)bJXsj#W TKW}m$Yqo-ee4Z-J)3EJ7;drXv diff --git a/requirements.txt b/requirements.txt index a917212f5e2b88dfea7525c68eb8b5fa7e219588..815dd6d4db0311f252b83d4d544a10d320deb0c3 100644 GIT binary patch literal 2783 zcmbVO&2rm347}?p)RQk2Bg#KyDEe`TH(CByiu~CRB+AeqLnVFgMwd8 zFTl6SV6a&f?IBr`Ba8+S4#tg-7id!hMyXLcA^ZUde~n)wym~4pR2s%&P-p4r@joFv zOvCU`Yk(L$Pv;|5R5M<*W)Qj~U;Ld(5iqna+MvyI<-1d5Q6@lRtBgJ8ixNTqCCBGP z4!*iXGe;+Ek5H>EWs-?SZ^vNFaDI6cIsT2vqZXqqcZl7-AhsxE+j&9!;1BFN>rY*vV*Maj58EQd9&Trd>+{Q zENw|N262uRM$foJ+=ey9I1NE{s>MGxvkfaqdDUpNGE<@lCylhu*jBWCqFi2mAmw0r z((a^E&GnH^Yv<2#AWRyBg?A@(P;IJyjuUT|RcjowLXGz`ErGdjh3k@Gmaf=wFS=B9 zSYAXdvVQhF808(KPv#Eg?Ha;o6Y=Bk01$|z3 zkB>gcF{$b|r91QF7lo5Y`Fwc>3vH8O8`|aM&q?}#PB&}`DV?#TVaI(iW0Mgr>|C#q z4mNA<3izKW`p_ve3V$L6tl6drVm|?pL{Ic9Qw0{(+j^R-qXPrr^G)7O7jKKZ58!yus z>^Qi4)1D+TVE+08`EXEB7XkU6=PT?pb_0marqoI; zA<1q}_vzE8d*=LfpF;l0-2u7#c`!z7%9?|Nbut@3#%eAN9rVK?-3 z|DoQSYnX3XhvN`AuYPl|}kn4QPUu}m$*6}W?K_&5%CF;0*Fcf33c z%UEkq*OGD0SG|<&^L4g}F^k;DwLVc!#4s@Se75CAE*r3a5hJ@*gmYQG)H~Q=-Izz! zrR9q}?+Q`#^-rpDtd(3<&<)4Iy(@(VY?~?{=GUIsY}rrcv1>stOAFx%qIVmy8k$e> zt2ZA4h*5`j897QdLCF;)~%(G^wmarML5j zPC6GhUt+fF`YDy?GBV=p+Q+tiWIGQp#mZIGNM-=Xi)u-&l80EIU{eM)X}WIn*8j-KQdKk-B9@hZU)N_+@-p_$iM$xg536eOVyL8b z8gj!FdLg#oO0Q5RpXRV>IZwCQt_sJ}0eS;tG?3_O7fJ~__x37xHwqh?GFEtwK z)Np0qxD%@EK-gI@0o6JTy1j`1b)0kH7SnHD-9yEapJ8tif^})k=smM}ckLV1mV; z&TNmWX|*HEWY#dVtkS>Q^bEH@mreEwqqWa%^58o{F!OzBCn7?fyPAO<)|sxr1)icT zDOu`wQaAs=k@dVb>C@--taEX;Lp{qp$T3 zD`mRBZ<_0Fuq#w^^?ds|KF^eMqhBo|_;Rl6w#u-_WV^imMCJ49!0I=lfr>A5d2ahr zQByM7thss$uycuYG}EU5-!pTLVHlx>S@H?P-)1H_quNZc%(s^jb5mBPHY%Du|EaQK zY^k-?DlSchd=K_;|Fuo8;M4@2oL4^D-k#WIk-Ii|v4Wk&)F(fksCMUYfW9u^$<>DthR8xlS&KXS=?bO4x*7`?Rv6AWZEZ5PQj&csQsj#)C)|zZFu42Ee P&pNZ}lq1ax@0h;;gN}79 From 823f290916b770a3c0f633731ac5e299d7951210 Mon Sep 17 00:00:00 2001 From: YanNaingWinn Date: Thu, 18 Jun 2026 19:02:05 +0700 Subject: [PATCH 5/5] return run_execute() result from Command._handle_execution --- cryptnox_cli/command/command.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/cryptnox_cli/command/command.py b/cryptnox_cli/command/command.py index d74bbc7..affc36c 100644 --- a/cryptnox_cli/command/command.py +++ b/cryptnox_cli/command/command.py @@ -66,9 +66,7 @@ def _handle_execution(self, serial_number: int = None) -> int: print(f"Error in retrieving information: {error}") return -1 - self.run_execute(card) - - return None + return self.run_execute(card) def run_execute(self, card) -> int: print(f"Using card with serial number {card.serial_number}")