Topic: Script Python para extrair informação de uma wallet (Read 523 times)

BIP32 Masterkey: xpriv
BIP32 Extended Private Key (account Level): xpriv/ypriv/zpriv
Derivation Path usado: m/84'/0'/0'/0
Fingerprint da carteira: 00000000
BIP32 Root PrivKey (WIF): L1xxxxxxxx

import sys
import hashlib
from bip_utils import (
    Bip39MnemonicGenerator, Bip39MnemonicValidator, Bip39SeedGenerator,
    Bip44, Bip49, Bip84, Bip86, Bip44Coins, Bip49Coins, Bip84Coins, Bip86Coins,
    Bip44Changes, Bip32Slip10Secp256k1, Secp256k1PrivateKey, WifEncoder
)
from getpass import getpass

def main():
    # Perguntar se deseja criar um novo mnemônico
    mnemonic_choice = input("Digite o número de palavras para criar um novo mnemônico (12, 18, 24) ou pressione Enter para usar um mnemônico existente: ").strip()

    if mnemonic_choice in ['12', '18', '24']:
        # Gerar um novo mnemônico com o número de palavras especificado
        num_words = int(mnemonic_choice)
        mnemonic = Bip39MnemonicGenerator().FromWordsNumber(num_words)
        print(f"Novo mnemônico gerado ({num_words} palavras): {mnemonic}")
    else:
        # Perguntar pelo mnemônico
        mnemonic = input("Digite o mnemônico: ").strip()

    # Validar o mnemônico
    if not Bip39MnemonicValidator().IsValid(mnemonic):
        print("Mnemônico inválido!")
        sys.exit(1)

    # Perguntar pela passphrase (opcional)
    passphrase = getpass("Digite a passphrase (opcional): ").strip()

    # Gerar a seed BIP39
    seed = Bip39SeedGenerator(mnemonic).Generate(passphrase)

    # Definindo os paths padrões
    deriv_paths = {
        '1': "m/44'/0'",    # p2pkh
        '2': "m/49'/0'",    # p2wpkh-p2sh
        '3': "m/84'/0'",    # p2wpkh
        '4': "m/86'/0'"     # p2tr
    }

    print("Derivation path e tipos de endereços disponíveis:")
    print("1: p2pkh (m/44'/0')")
    print("2: p2wpkh-p2sh (m/49'/0')")
    print("3: p2wpkh (m/84'/0')")
    print("4: p2tr (m/86'/0')")

    address_type = input("Escolha o tipo de endereço (1-4): ").strip()

    if address_type not in deriv_paths:
        print("Tipo de endereço inválido!")
        sys.exit(1)

    # Caminho de derivação base
    base_derivation_path = deriv_paths[address_type]

    # Perguntar pela conta
    account_index = input("Digite o índice da conta (padrão 0): ").strip()
    account_index = int(account_index) if account_index.isdigit() else 0

    # Perguntar se quer gerar endereços de recebimento (0) ou de troco (1)
    address_purpose = input("Gerar endereços de recebimento (0) ou de troco (1)? ").strip()
    if address_purpose not in ['0', '1']:
        print("Opção inválida!")
        sys.exit(1)

    # Perguntar a partir de qual index mostrar os endereços
    start_index = int(input("A partir de qual index mostrar os endereços (padrão 0)? ").strip() or 0)

    # Perguntar quantos endereços mostrar
    address_count = int(input("Quantos endereços mostrar (padrão 50)? ").strip() or 50)

    # Inicializar a classe BIP adequada
    bip_cls_dict = {
        '1': (Bip44, Bip44Coins.BITCOIN),
        '2': (Bip49, Bip49Coins.BITCOIN),
        '3': (Bip84, Bip84Coins.BITCOIN),
        '4': (Bip86, Bip86Coins.BITCOIN)
    }
    bip_cls, coin_type = bip_cls_dict[address_type]
    bip_obj = bip_cls.FromSeed(seed, coin_type)

    # Derivar a conta principal
    bip_acc_obj = bip_obj.Purpose().Coin().Account(account_index)

    # Obter o fingerprint da chave pública da raiz BIP32
    root_pubkey = bip_obj.PublicKey().RawCompressed().ToBytes()
    fingerprint = hashlib.new('ripemd160', hashlib.sha256(root_pubkey).digest()).digest()[:4]

    # Derivar os endereços
    addresses = []
    for i in range(start_index, start_index + address_count):
        addr_obj = bip_acc_obj.Change(Bip44Changes(int(address_purpose))).AddressIndex(i)
        priv_key = addr_obj.PrivateKey().Raw().ToBytes()
        priv_key_wif = WifEncoder.Encode(Secp256k1PrivateKey.FromBytes(priv_key))
        addresses.append({
            'index': i,
            'address': addr_obj.PublicKey().ToAddress(),
            'private_key_wif': priv_key_wif,
            'hdkeypath': f"{base_derivation_path}/{account_index}'/{address_purpose}/{i}"
        })

    # Gerar a chave privada BIP32 raiz
    bip32_obj = Bip32Slip10Secp256k1.FromSeed(seed)
    root_xpriv = bip32_obj.PrivateKey().ToExtended()

    # Gerar a chave privada estendida BIP32 no nível da conta
    account_xpriv = bip_acc_obj.PrivateKey().ToExtended()

    # Gerar o WIF para a chave privada raiz
    root_priv_key_bytes = bip32_obj.PrivateKey().Raw().ToBytes()
    root_priv_key_wif = WifEncoder.Encode(Secp256k1PrivateKey.FromBytes(root_priv_key_bytes))

    # Mostrar os resultados
    print("\nMnemônico:", mnemonic)
    if passphrase:
        print("Passphrase:", passphrase)
    print("\nBIP32 Masterkey:", root_xpriv)
    print("BIP32 Extended Private Key (account Level):", account_xpriv)
    print("Derivation Path usado:", f"{base_derivation_path}/{account_index}'/{address_purpose}")
    print("Fingerprint da carteira:", fingerprint.hex())
    print("BIP32 Root PrivKey (WIF):", root_priv_key_wif)
    print()

    for addr in addresses:
        print(f"{addr['private_key_wif']} # addr={addr['address']} hdkeypath={addr['hdkeypath']}")

    # Perguntar se deseja gerar um arquivo dump.txt
    save_to_file = input("Deseja gerar um arquivo dump.txt para importar em uma carteira? (s/n): ").strip().lower()
    if save_to_file == 's':
        with open('dump.txt', 'w') as f:
            f.write(f"Mnemônico: {mnemonic}\n")
            if passphrase:
                f.write(f"Passphrase: {passphrase}\n")
            f.write(f"\nBIP32 Masterkey: {root_xpriv}\n")
            f.write(f"BIP32 Extended Private Key (account Level): {account_xpriv}\n")
            f.write(f"Derivation Path usado: {base_derivation_path}/{account_index}'/{address_purpose}\n")
            f.write(f"Fingerprint da carteira: {fingerprint.hex()}\n")
            f.write(f"BIP32 Root PrivKey (WIF): {root_priv_key_wif}\n\n")
            for addr in addresses:
                f.write(f"{addr['private_key_wif']} # addr={addr['address']} hdkeypath={addr['hdkeypath']}\n")
        print("Arquivo dump.txt exportado com sucesso!")
    else:
        print("Saída salva apenas na tela.")

if __name__ == "__main__":
    main()

listdescriptors true

wpkh(xpriv99999/84h/0h/0h/0/*)#pavne9dy

wpkh(xpriv99999/84h/0h/0h/1/*)#pavne9dy

KzTT1W3toHBjkNFh3YTTnfwN3WUJXPGaAy9E592oDCfZWDCJPMBF

from bitcoinlib.keys import HDKey
from bitcoinlib.mnemonic import Mnemonic
from bitcoinlib.encoding import base58encode
from bitcoinlib.encoding import double_sha256

# Example seed phrase (mnemonic)
mnemonic_phrase = "thunder trade sleep rack pair ranch sense hand inquiry gauge you know"

# Create a Mnemonic object
mnemonic = Mnemonic()
# Convert the mnemonic phrase to a seed (binary)
seed = mnemonic.to_seed(mnemonic_phrase)

# Create an HD wallet from the seed
hdkey = HDKey.from_seed(seed, network='bitcoin')

# Derive a private key using the specific derivation path (m/84'/0'/0'/0/2)
key = hdkey.subkey_for_path("m/84'/0'/0'/1/0")

# Get the corresponding native SegWit address
bitcoin_address = key.address(encoding='bech32')

# Prepend and append the network byte (0x80) and the compression flag (0x01)
prvKey_data = (b'\x80' + key.private_byte + b'\x01')

# Calculate the checksum
checksum = double_sha256(prvKey_data)

# Prepend the checksum to the double sha256'ed key
private_key_base58 = base58encode(prvKey_data + checksum[0:4])

print("Bitcoin address:", bitcoin_address)
print("Private key (Base58):", private_key_base58)

import { DescriptorSecretKey, Mnemonic } from "bdk-rn";
import { Network, WordCount } from "bdk-rn/lib/lib/enums";

export const getDescriptorSecretKey = async (
  network: Network,
  seedphrase?: string,
) => {
  let mnemonic = new Mnemonic();

  if (seedphrase) {
    mnemonic = await mnemonic.fromString(seedphrase);
  } else {
    mnemonic = await mnemonic.create(WordCount.WORDS12);
  }

  return new DescriptorSecretKey().create(network, mnemonic);
};

import RNFS from "react-native-fs";
import { encrypt } from "../crypto/encrypt";
import { error } from "../log/error";
import { info } from "../log/info";

export const writeFile = async (
  path: string,
  content: string,
  password?: string,
): Promise => {
  info(password ? "Writing encrypted file" : "Writing file", path);
  let encrypted;
  try {
    if (password) {
      encrypted = encrypt(content, password);
    } else {
      encrypted = content;
    }
  } catch (e) {
    error("Data could not be encrypted", e);
    return false;
  }
  try {
    await RNFS.writeFile(RNFS.DocumentDirectoryPath + path, encrypted, "utf8");
    return true;
  } catch (e) {
    error("File could not be written", e);
    return false;
  }
};

import RNFS from "react-native-fs";

export const readChunkOfFile = (
  uri: string,
  chunksize: number,
  index: number,
) => RNFS.read(uri, chunksize, index, "utf8");

from bitcoinlib.wallets import Wallet, wallet_create_or_open
from bitcoinlib.wallets import wallet_delete_if_exists
import asyncio


async def get_descriptor_secret_key(network: str, seedphrase: str = None,
                                    name='My Wallet'):
    delete_wallet(name)
    if seedphrase:
        # Use the provided seed phrase to generate a wallet
        wallet = Wallet.create(name=name, keys=seedphrase,
                               network=network, witness_type='segwit')
    else:
        # Generate a new wallet with a new seed phrase
        wallet = wallet_create_or_open(name, witness_type='segwit',
                                       network=network)

    # Print wallet info
    print("Wallet Info:")
    print("Address:", wallet.new_key().address)
    print("Key:", wallet.new_key())
    # print("Descriptor:", wallet.descriptor)
    return wallet


def delete_wallet(name="My Wallet"):
    try:
        wallet_delete_if_exists(name)
        print(f"Wallet '{name}' was deleted.")
    except Exception as e:
        print(f"Faile to delete wallet '{name}': {str(e)}")


# Define the network ('bitcoin' or 'testnet')
network_name = 'bitcoin'

# Optionally, provide a seed phrase
seed_phrase = "word1 word1 word1 word1 word1 word1 word1 word1 word1 word1 word1 word1"
# Example seed phrase
asyncio.run(get_descriptor_secret_key(network_name, seed_phrase))

const CryptoJS = require('crypto-js');
const fs = require('fs');

fs.readFile('./peach-account.json.enc', 'utf8', function(err, data) {
    const res = CryptoJS.AES.decrypt(data, "").toString(CryptoJS.enc.Utf8);
    fs.writeFile('./peach-account.json', res, function(err) {
        if(err) {
            return console.log(err);
        }
        console.log("The file was saved!");
    })
});