Topic: R value parse from signature on Blockchain input transactions (Read 488 times)

std::cout <<"\nCoinbase: "<< txScriptSig <<"\nPubkeyScript: "<< pubScriptSig <<"\nMerkle Hash: "<< merkleHash <<"\nByteswapped: "<< merkleHashSw <<"\nGenerating block...\n\n";
unsigned char  block_hash1[32];
#ifdef _MSC_VER
_declspec(align(16)) unsigned char  block_hashfp[32];
#else
__attribute__((aligned(16))) unsigned char  block_hashfp[32];
#endif
unsigned int counter=0, start = time(NULL);
int drift = 4;
__m128i r, m, b, camp;
__m128i zero = _mm_setzero_si128();

unsigned short turt;
while(1) {

SHA256((unsigned char*)&block_header, 80, block_hash1);
SHA256(block_hash1, 32, block_hashfp);

r = _mm_load_si128((__m128i *)block_hashfp);
m = _mm_load_si128((__m128i *)(block_hashfp+16));
switch (drift)
{
case 0:
   break;
case 1:
b = _mm_alignr_epi8(m, r, 31);

   break;
case 2:
b = _mm_alignr_epi8(m, r, 30);

   break;
case 3:
b = _mm_alignr_epi8(m, r, 29);
   
break;
case 4:
b = _mm_alignr_epi8(m, r, 28);

   break;
case 5:
b = _mm_alignr_epi8(m, r, 27);

   break;
case 6:
b = _mm_alignr_epi8(m, r, 26);

   break;
case 7:
b = _mm_alignr_epi8(m, r, 25);

   break;
case 8:
b = _mm_alignr_epi8(m, r, 24);

   break;
case 9:
b = _mm_alignr_epi8(m, r, 23);

   break;
case 10:

b = _mm_alignr_epi8(m, r, 22);
   break;
case 11:
b = _mm_alignr_epi8(m, r, 21);

   break;
case 12:
b = _mm_alignr_epi8(m, r, 20);

   break;
case 13:

   break;
default:

   break;
}
/*now it turns out like:
* Hashes 6018c18fcd4bfabb523f2ee1f6c18880f38135f3eb0ff1aa76acbc2fa94eb8ce
* And
* b 0000000000000000 000000006018c18f
*/

camp = _mm_cmpeq_epi8(b ,zero);
turt = _mm_movemask_epi8(camp);
if (turt == 0xffff)
{
std::reverse(block_hashfp,block_hashfp +32);
std::cout << "\nBlock found!\nHash: " << bin2hex(block_hashfp, 32) <<"\nNonce: " << block_header.startNonce << "\nUnix time: "<< block_header.unixtime << std::endl;
break;
}
if(time(NULL) - start > 0) {
std::cout << counter <<" Hashes/s, Nonce "<< block_header.startNonce<<'\r';
start = time((time_t *)(counter = 0));
}
if( ++block_header.startNonce == 0 ) block_header.unixtime++ ; //trick is that to change pre-start time to find a block(really it's smth else) faster then nonce wraps
counter++;
}

def parse_element(hex_str, offset, element_size):
    """
    :param hex_str: string to parse the element from.
    :type hex_str: hex str
    :param offset: initial position of the object inside the hex_str.
    :type offset: int
    :param element_size: size of the element to extract.
    :type element_size: int
    :return: The extracted element from the provided string, and the updated offset after extracting it.
    :rtype tuple(str, int)
    """

    return hex_str[offset:offset+element_size], offset+element_size


def dissect_signature(hex_sig):
    """
    Extracts the r, s and ht components from a Bitcoin ECDSA signature.
    :param hex_sig: Signature in  hex format.
    :type hex_sig: hex str
    :return: r, s, t as a tuple.
    :rtype: tuple(str, str, str)
    """

    offset = 0
    # Check the sig contains at least the size and sequence marker
    assert len(hex_sig) > 4, "Wrong signature format."
    sequence, offset = parse_element(hex_sig, offset, 2)
    # Check sequence marker is correct
    assert sequence == '30', "Wrong sequence marker."
    signature_length, offset = parse_element(hex_sig, offset, 2)
    # Check the length of the remaining part matches the length of the signature + the length of the hashflag (1 byte)
    assert len(hex_sig[offset:])/2 == int(signature_length, 16) + 1, "Wrong length."
    # Get r
    marker, offset = parse_element(hex_sig, offset, 2)
    assert marker == '02', "Wrong r marker."
    len_r, offset = parse_element(hex_sig, offset, 2)
    len_r_int = int(len_r, 16) * 2   # Each byte represents 2 characters
    r, offset = parse_element(hex_sig, offset, len_r_int)
    # Get s
    marker, offset = parse_element(hex_sig, offset, 2)
    assert marker == '02', "Wrong s marker."
    len_s, offset = parse_element(hex_sig, offset, 2)
    len_s_int = int(len_s, 16) * 2  # Each byte represents 2 characters
    s, offset = parse_element(hex_sig, offset, len_s_int)
    # Get ht
    ht, offset = parse_element(hex_sig, offset, 2)
    assert offset == len(hex_sig), "Wrong parsing."

    return r, s, ht


example_sig = None  # insert_sig_here
r, s, ht = dissect_signature(example_sig)
print "r: %s\ns: %s\nht: %s\n" % (r, s, ht)

for (int i=0; i{
  sum1 += data[i+0];
  sum2 += data[i+1];
  sum3 += data[i+2];
  sum4 += data[i+3];
}
sum = sum1 + sum2 + sum3 + sum4;