Помощ

[gendakov]

File "/home/gen/CryptoDeepTools/02BreakECDSAcryptography/txnUtils.py", line 33, in parseTxn
scriptLen = int(txn[41 * 2:42 * 2], 16)
^^^^^^^^^^^^^^^^^^^^^^^^^^^
ValueError: invalid literal for int() with base 16: ''

[demining]

Here is the corrected code with handling for variable script length:

import ecdsa
from Crypto.Hash import SHA256
import struct
import unittest
import utils
import keyUtils
import base58

def makeRawTransaction(outputTransactionHash, sourceIndex, scriptSig, outputs):
    def makeOutput(data):
        redemptionSatoshis, outputScript = data
        return (struct.pack("<Q", redemptionSatoshis).hex() +
                '%02x' % len(bytes.fromhex(outputScript)) + outputScript)
    
    formattedOutputs = ''.join(map(makeOutput, outputs))

    return ("01000000" +
            "01" +
            bytes.fromhex(outputTransactionHash)[::-1].hex() +
            struct.pack('<L', sourceIndex).hex() +
            '%02x' % len(bytes.fromhex(scriptSig)) + scriptSig +
            "ffffffff" +
            "%02x" % len(outputs) +
            formattedOutputs +
            "00000000")

def parseTxn(txn):
    cursor = 0
    first = txn[cursor:cursor+41*2]
    cursor += 41*2
    
    # Handling variable script length
    scriptLen_byte = txn[cursor:cursor+2]
    if not scriptLen_byte:
        raise ValueError("Unexpected end of transaction data")
    
    scriptLen = int(scriptLen_byte, 16)
    cursor += 2
    
    # Handling extended lengths
    if scriptLen == 0x4c:
        scriptLen = int(txn[cursor:cursor+2], 16)
        cursor += 2
    elif scriptLen == 0x4d:
        scriptLen = int(txn[cursor:cursor+4], 16)
        cursor += 4
    elif scriptLen == 0x4e:
        scriptLen = int(txn[cursor:cursor+8], 16)
        cursor += 8
    
    script = txn[cursor:cursor + scriptLen*2]
    cursor += scriptLen*2
    
    sigLen = int(txn[cursor:cursor+2], 16)
    cursor += 2
    sig = txn[cursor:cursor + sigLen*2]
    cursor += sigLen*2
    
    pubLen = int(txn[cursor:cursor+2], 16)
    cursor += 2
    pub = txn[cursor:cursor + pubLen*2]
    cursor += pubLen*2
    
    rest = txn[cursor:]
    
    return [first, sig, pub, rest]

def getSignableTxn(parsed):
    first, sig, pub, rest = parsed
    inputAddr = base58.b58decode_check(keyUtils.pubKeyToAddr(pub))
    return first + "1976a914" + inputAddr.hex() + "88ac" + rest + "01000000"

def verifyTxnSignature(txn):
    parsed = parseTxn(txn)
    signableTxn = getSignableTxn(parsed)

    hash1 = SHA256.new(bytes.fromhex(signableTxn)).digest()
    hashToSign = SHA256.new(hash1).digest().hex()

    assert parsed[1][-2:] == '01'  # hashtype

    sig = keyUtils.derSigToHexSig(parsed[1][:-2])
    public_key = parsed[2]

    vk = ecdsa.VerifyingKey.from_string(bytes.fromhex(public_key[2:]), curve=ecdsa.SECP256k1)
    assert vk.verify_digest(bytes.fromhex(sig), bytes.fromhex(hashToSign))

def makeSignedTransaction(privateKey, outputTransactionHash, sourceIndex, scriptPubKey, outputs):
    myTxn_forSig = (makeRawTransaction(outputTransactionHash, sourceIndex, scriptPubKey, outputs) +
                    "01000000")

    hash1 = SHA256.new(bytes.fromhex(myTxn_forSig)).digest()
    s256 = SHA256.new(hash1).digest()

    sk = ecdsa.SigningKey.from_string(bytes.fromhex(privateKey), curve=ecdsa.SECP256k1)
    sig = sk.sign_digest(s256, sigencode=ecdsa.util.sigencode_der) + b'\x01'

    pubKey = keyUtils.privateKeyToPublicKey(privateKey)
    scriptSig = utils.varstr(sig).hex() + utils.varstr(bytes.fromhex(pubKey)).hex()

    signed_txn = makeRawTransaction(outputTransactionHash, sourceIndex, scriptSig, outputs)
    verifyTxnSignature(signed_txn)

    return signed_txn

class TestTxnUtils(unittest.TestCase):
    # Add tests here
...
...
...

Key Changes:

1. Completely reworked the parseTxn function using a cursor.
2. Added handling for extended lengths (OP_PUSHDATA).
3. Fixed hex string conversions using bytes.fromhex().
4. Improved error handling.
5. Added checks for empty values.

The function now correctly handles:

• Transactions with different script length types.
• Properly calculates offsets in the hex string.
• Handles special length markers (0x4c, 0x4d, 0x4e).

It’s recommended to add unit tests to verify different transaction scenarios.

[gendakov]

спсб