Qui est exactement Selim Bradley?

Dans cette réponse, je vais aller à travers les étapes nécessaires pour racheter la deuxième sortie de la transaction répertorié ci-dessus. La réponse sera limitée à racheter une sortie de ce type présent dans cette transaction (une sortie qui nécessite de fournir une nouvelle transaction signée avec une clé privée dont la clé publique correspondante hachages pour le hachage dans le script de la sortie en question), que cette réponse est déjà assez long, même sans prendre en compte d'autres types de sortie.

Bref résumé: Nous commençons par la construction d'une nouvelle transaction, avec un scriptSig contenant le scriptPubKey de la sortie que nous voulons racheter. Le scriptPubKey de cette transaction va contenir un script qui paie pour un hachage de la clé publique (adresse Bitcoin). Nous avons effectuer un double-hachage SHA256 sur cette opération avec les quatre octets de code de hachage de type SIGHASH_ALL ajouté à la fin. Nous signons cette empreinte avec la clé privée fournies ci-dessus. Le scriptSig de cette nouvelle transaction est alors remplacé par un script dans un premier temps la DER-signature codée, ainsi qu'un octet de code de hachage de type SIGHASH_ALL, à la pile, suivie par la encodé DER clé privée correspondant à la clé publique.

Étape-par-étape de la description:

Nous commençons à créer un nouveau cru transaction qui nous hachage et de le signer.

1. Ajouter quatre octets champ version: 01000000
2. Un octet varint en précisant le nombre d'entrées: 01
3. 32 octets de hachage de l'opération à partir de laquelle nous voulons racheter une sortie: eccf7e3034189b851985d871f91384b8ee357cd47c3024736e5676eb2debb3f2
4. Quatre-octet champ indiquant l'indice de la production que nous voulons racheter de la transaction ci-dessus de hachage (numéro de sortie 2 = indice de la production 1): 01000000
5. Maintenant vient le scriptSig. Aux fins de la signature de la transaction, c'est temporairement rempli avec le scriptPubKey de la sortie que nous voulons racheter. Nous avons d'abord écrire un octet varint qui désigne la longueur de la scriptSig (0 x 19 = 25 octets): 19
6. Puis nous écrivons temporaire scriptSig qui, rappelons-le, est le scriptPubKey de la sortie que nous voulons racheter: 76a914010966776006953d5567439e5e39f86a0d273bee88ac
7. Puis nous écrivons un à quatre octets champ indiquant la séquence. Présentement, c'est toujours la valeur 0xffffffff: ffffffff
8. Vient ensuite un octet varint contenant le nombre de sorties dans notre nouvelle transaction. Nous allons définir à 1 dans cet exemple: 01
9. Nous avons ensuite écrire un champ de 8 octets (64 bits entier) contenant le montant que nous voulons racheter de la sortie spécifiée. Je vais mettre cela à la quantité totale disponible dans la production moins les frais de 0,001 BTC (0.999 BTC, ou 99900000 Satoshis): 605af40500000000
10. Nous commençons ensuite à l'écriture de notre opération de sortie. Nous commençons avec un octet varint désignant la longueur de la sortie du script (0x19 ou 25 octets): 19
11. Le script de sortie: 76a914097072524438d003d23a2f23edb65aae1bb3e46988ac
12. Puis nous écrivons les quatre octets "délai de verrouillage" champ: 00000000

13. Et enfin, nous allons écrire un à quatre octets "code de hachage de type" (1 dans notre cas): 01000000

    Nous avons maintenant les premières suivantes les données de la transaction:

    01000000
    01
    eccf7e3034189b851985d871f91384b8ee357cd47c3024736e5676eb2debb3f2
    01000000
    19
    76a914010966776006953d5567439e5e39f86a0d273bee88ac
    ffffffff
    01
    605af40500000000
    19
    76a914097072524438d003d23a2f23edb65aae1bb3e46988ac
    00000000
    01000000
    

14. (signature de l'étape) Maintenant, nous double hachage SHA256 cet ensemble de la structure, ce qui donne de la valeur de hachage 9302bda273a887cb40c13e02a50b4071a31fd3aae3ae04021b0b843dd61ad18e

15. Nous créons ensuite une paire clé publique/privée de la condition de la clé privée. On signe le hachage à partir de l'étape 14 avec la clé privée, ce qui donne la suite de DER-signature codée (cette signature sera différent dans votre cas): 30460221009e0339f72c793a89e664a8a932df073962a3f84eda0bd9e02084a6a9567f75aa022100bd9cbaca2e5ec195751efdfac164b76250b1e21302e51ca86dd7ebd7020cdc06 À cette signature, nous ajoutons l'un octet de code de hachage de type: 01. La clé publique est: 0450863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b23522cd470243453a299fa9e77237716103abc11a1df38855ed6f2ee187e9c582ba6

16. Nous construisons la finale scriptSig par la concaténation:

    • Un octet script OPCODE contenant la longueur de la DER-signature codée plus 1 (la longueur d'un octet de code de hachage de type)
    • Le réel codé DER en plus de la signature d'un octet de code de hachage de type
    • Un octet script OPCODE contenant la longueur de la clé publique
    • La véritable clé publique

17. Nous avons ensuite remplacer l'un octet, varint longueur de champ à partir de l'étape 5 avec la longueur des données à partir de l'étape 16. La longueur est de 140 octets, ou 0x8C octets: 8c

18. Et nous remplaçons le temporaire scriptSig à partir de l'Étape 6 avec la structure de données construite à l'étape 16. Cela devient: 4930460221009e0339f72c793a89e664a8a932df073962a3f84eda0bd9e02084a6a9567f75aa022100bd9cbaca2e5ec195751efdfac164b76250b1e21302e51ca86dd7ebd7020cdc0601410450863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b23522cd470243453a299fa9e77237716103abc11a1df38855ed6f2ee187e9c582ba6

19. Nous finir par enlever les quatre octets de code de hachage de type, nous avons ajouté à l'étape 13, et nous nous retrouvons avec la suite de flux d'octets, ce qui est la finalité de la transaction:

    01000000
    01
    eccf7e3034189b851985d871f91384b8ee357cd47c3024736e5676eb2debb3f2
    01000000
    8c
    4930460221009e0339f72c793a89e664a8a932df073962a3f84eda0bd9e02084a6a9567f75aa022100bd9cbaca2e5ec195751efdfac164b76250b1e21302e51ca86dd7ebd7020cdc0601410450863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b23522cd470243453a299fa9e77237716103abc11a1df38855ed6f2ee187e9c582ba6
    ffffffff
    01
    605af40500000000
    19
    76a914097072524438d003d23a2f23edb65aae1bb3e46988ac
    00000000
    

Python exemple de code:

J'ai créé un exemple de script Python qui n'tous les ci-dessus. C'est intentionnellement que détaillé que possible, et très bien commenté, avec aussi peu que possible des tâches, afin de ressembler à l'étape par guide pas à pas ci-dessus. Le nombre de lignes de code peut être facilement réduit à la moitié, mais je choisis de poster dans ce sous forme de commentaires que je juge que c'est plus facile à suivre (c'est à dire. pas de "sauter" d'avant en arrière à travers les fonctions). Le script contient 76 non-vide, de non-lignes de commentaire. Le script dépend de Gavin Andresen est bitcointools (pour la sérialisation et la désérialisation des transactions, et base58 de codage/décodage) et ecdsa_ssl.py de ma fourchette de joric de brutus référentiel (pour la construction de public/privé, CE paires de clés et la signature ECDSA). La meilleure façon d'obtenir l'exécution du script est de cloner bitcointools dans un dossier, et de mettre ecdsa_ssl.py à partir de l'URL ci-dessus dans le même dossier avec ce script, et de l'exécution du script à partir de là. Vous voulez remplacer l'adresse dans la SEND_TO_ADDRESS variable dans ce script avec l'adresse que vous souhaitez les pièces envoyées, sauf si vous vous sentez généreux :).

#bitcointools
de désérialiser l'importation parse_Transaction, opcodes
de BCDataStream importation BCDataStream
de base58 importation bc_address_to_hash_160, b58decode, public_key_to_bc_address, hash_160_to_bc_address

importation ecdsa_ssl

l'importation de la Crypto.De hachage.SHA256 comme sha256
l'importation de la Crypto.Aléatoire

#transaction, à partir de laquelle nous voulons racheter une sortie
HEX_TRANSACTION="010000000126c07ece0bce7cda0ccd14d99e205f118cde27e83dd75da7b141fe487b5528fb000000008b48304502202b7e37831273d74c8b5b1956c23e79acd660635a8d1063d413c50b218eb6bc8a022100a10a3a7b5aaa0f07827207daf81f718f51eeac96695cf1ef9f2020f21a0de02f01410452684bce6797a0a50d028e9632be0c2a7e5031b710972c2a3285520fb29fcd4ecfb5fc2bf86a1e7578e4f8a305eeb341d1c6fc0173e5837e2d3c7b178aade078ffffffff02b06c191e010000001976a9143564a74f9ddb4372301c49154605573d7d1a88fe88ac00e1f505000000001976a914010966776006953d5567439e5e39f86a0d273bee88ac00000000"
#sortie à racheter. doit exister dans HEX_TRANSACTION
OUTPUT_INDEX=1
#l'adresse que nous voulons envoyer les rachetés de pièces de monnaie pour.
#REMPLACER par VOTRE PROPRE ADRESSE, sauf si vous vous sentez généreux 
SEND_TO_ADDRESS="1L4xtXCdJNiYnyqE6UsB8KSJvqEuXjz6ak"
#frais, nous voulons payer en BTC)
TX_FEE=0.001
#constante qui définit le nombre de Satoshis par la CTB
PIÈCE=100000000
#constante utilisée pour déterminer quelle partie de la transaction est haché.
SIGHASH_ALL=1
#clé privée dont la clé publique hachages pour le hachage contenues dans scriptPubKey de numéro de sortie *OUTPUT_INDEX* dans la transaction décrite dans HEX_TRANSACTION
PRIVATE_KEY=0x18E14A7B6A307F426A94F8114701E7c8e774e7f9a47e2c2035db29a206321725

def dsha256(données):
 retour sha256.nouveau(sha256.nouveau(de données).digest()).digest()

tx_data=HEX_TRANSACTION.decode('hex_codec')
tx_hash=dsha256(tx_data)

#ici, nous utilisons bitcointools pour analyser une transaction. cela donne un accès facile aux différents champs de l'opération à partir de laquelle nous voulons racheter une sortie
stream = BCDataStream()
flux de données.écrire(tx_data)
tx_info = parse_Transaction(stream)

si len(tx_info['txOut']) < (OUTPUT_INDEX+1):
 soulever RuntimeError, "il y a %d sortie(s) dans l'opération que vous tentez de convertir. vous voulez échanger sortie de l'indice %d" % (len(tx_info['txOut']), OUTPUT_INDEX)

#ce dictionnaire est utilisé pour stocker les valeurs des différents champs de transaction
# ceci est utile, car nous avons besoin de construire une opération de hachage et signe
# et un autre qui sera la transaction finale
tx_fields = {}

##ici, nous commençons la création de la transaction que nous hachage et signe
sign_tx = BCDataStream()
##nous avons d'abord écrire le numéro de version, qui est de 1
tx_fields['version'] = 1
sign_tx.write_int32(tx_fields['version'])
##puis nous écrivons le nombre d'entrées de transaction, qui est l'un
tx_fields['num_txin'] = 1
sign_tx.write_compact_size(tx_fields['num_txin'])

##puis on écrire le réel de la transaction de données
#'prevout_hash'
tx_fields['prevout_hash'] = tx_hash
sign_tx.écrire(tx_fields['prevout_hash']) #hash de l'opération à partir de laquelle nous voulons racheter une sortie
#'prevout_n'
tx_fields['output_index'] = OUTPUT_INDEX
sign_tx.write_uint32(tx_fields['output_index']) #sortie de la transaction avec tx id 'prevout_hash' nous ne voulons racheter?

##vient ensuite la partie de la transaction d'entrée. ici, on place le script de la *production* que nous voulons racheter
tx_fields['scriptSigHash'] = tx_info['txOut'][OUTPUT_INDEX]['scriptPubKey']
#premier à écrire de la taille
sign_tx.write_compact_size(len(tx_fields['scriptSigHash']))
#les données
sign_tx.écrire(tx_fields['scriptSigHash'])

#'séquence'
tx_fields['séquence'] = 0xffffffff
sign_tx.write_uint32(tx_fields['séquence'])

##puis nous écrivons le nombre de transactions sorties. nous allons simplement utiliser une seule sortie dans cet exemple
tx_fields['num_txout'] = 1
sign_tx.write_compact_size(tx_fields['num_txout'])
##puis on écrire le réel de la transaction de données de sortie
#nous allons racheter tout, de la sortie d'origine moins TX_FEE
tx_fields['valeur'] = tx_info['txOut'][OUTPUT_INDEX]['value']-(TX_FEE*PIÈCE de monnaie)
sign_tx.write_int64(tx_fields['valeur'])
##c'est là que notre scriptPubKey va (un script qui paie pour l'adresse)
#nous voulons le script suivant:
#"OP_DUP OP_HASH160 OP_EQUALVERIFY OP_CHECKSIG"
address_hash = bc_address_to_hash_160(SEND_TO_ADDRESS)
#chr(20) est la longueur de la address_hash (20 octets ou 160 bits)
scriptPubKey = chr(opcodes.OP_DUP) + chr(opcodes.OP_HASH160) + \
 chr(20) + address_hash + chr(opcodes.OP_EQUALVERIFY) + chr(opcodes.OP_CHECKSIG)
#premier à écrire de la longueur de ce morceau de données
tx_fields['scriptPubKey'] = scriptPubKey
sign_tx.write_compact_size(len(tx_fields['scriptPubKey']))
#les données
sign_tx.écrire(tx_fields['scriptPubKey'])

#écrire locktime (0)
tx_fields['locktime'] = 0
sign_tx.write_uint32(tx_fields['locktime'])
#et le code de hachage de type (1)
tx_fields['hash_type'] = SIGHASH_ALL
sign_tx.write_int32(tx_fields['hash_type'])

#ensuite, nous obtenons la valeur de hachage de la signature-moins de la transaction (la valeur de hachage qui nous connecter à l'aide de notre clé privée)
hash_scriptless = dsha256(sign_tx.d'entrée)

##maintenant, nous commençons avec le ECDSA choses.
## on créer une clé privée à partir de la condition de la clé privée de données, et de signer hash_scriptless avec elle
## on vérifie également que la clé privée correspondant à la clé publique peut effectivement racheter la sortie spécifiée

k = ecdsa_ssl.TOUCHE()
k.générer(('%064x' % PRIVATE_KEY).decode('hex'))

#ici, nous avons récupérer la clé publique de données générées à partir de la fourniture de la clé privée
pubkey_data = k.get_pubkey()
#ensuite, nous créons une signature sur le hachage de la signature de moins transaction
sig_data=k.signe(hash_scriptless)
#un octet "type de hachage" est ajouté à la fin de la signature (https://en.bitcoin.it/wiki/OP_CHECKSIG)
sig_data = sig_data + chr(SIGHASH_ALL)

#vérifiez que la condition privat clé peut effectivement racheter la sortie en question
si (bc_address_to_hash_160(public_key_to_bc_address(pubkey_data)) != tx_info['txOut'][OUTPUT_INDEX]['scriptPubKey'][3:-2]):
 octets = b58decode(SEND_TO_ADDRESS, 25)
 soulever RuntimeError, "La livrée clé privée ne peut pas être utilisé pour racheter la sortie de l'indice %d\nvous devez fournir la clé privée de l'adresse %s" % \
 (OUTPUT_INDEX, hash_160_to_bc_address(tx_info['txOut'][OUTPUT_INDEX]['scriptPubKey'][3:-2], les octets[0]))

##maintenant, nous commençons à créer de la transaction finale. c'est un doublon de la signature de moins de transactions,
## avec la scriptSig rempli avec un script qui pousse la signature de plus d'un octet de code de hachage de type, et la clé publique à partir de ci-dessus, à la pile

final_tx = BCDataStream()
final_tx.write_int32(tx_fields['version'])
final_tx.write_compact_size(tx_fields['num_txin'])
final_tx.écrire(tx_fields['prevout_hash'])
final_tx.write_uint32(tx_fields['output_index'])

##maintenant, nous devons écrire le réel scriptSig.
## il s'agit de la encodé DER valeurs de r et s à partir de la signature, un octet de code de hachage de type, et la clé publique au format non compressé
## nous avons aussi besoin de la faire précéder de la longueur de ces deux données (encodé sur un seul octet
## contenant la longueur), avant de chaque élément de données. cette longueur est un script opcode qui raconte l'
## Bitcoin interpréteur de script pour pousser le x à la suite d'octets sur la pile

scriptSig = chr(len(sig_data)) + sig_data + chr(len(pubkey_data)) + pubkey_data
#premier à écrire de la longueur de ces données
final_tx.write_compact_size(len(scriptSig))
#les données
final_tx.écrire(scriptSig)

##ensuite, il nous suffit d'écrire les mêmes données après la scriptSig qui est dans la signature-moins de la transaction,
# laissant les quatre octets de code de hachage de type (ce qui est codé dans le seul octet à la suite de la signature de données)

final_tx.write_uint32(tx_fields['séquence'])
final_tx.write_compact_size(tx_fields['num_txout'])
final_tx.write_int64(tx_fields['valeur'])
final_tx.write_compact_size(len(tx_fields['scriptPubKey']))
final_tx.écrire(tx_fields['scriptPubKey'])
final_tx.write_uint32(tx_fields['locktime'])

#imprime la transaction finale en format hexadécimal (peut être utilisé comme un argument pour bitcoind de sendrawtransaction)
imprimer final_tx.d'entrée.encode('hex')