SHARE
TWEET

Untitled

a guest Apr 22nd, 2013 4,465 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. // Copyright "Remember remember the 5th of November" 2013
  2.  
  3. #include <stdlib.h>
  4. #include <stdio.h>
  5. #include <stdbool.h>
  6. #include <inttypes.h>
  7. #include <ctype.h>
  8. #include <string.h>
  9. #include <time.h>
  10. #include <openssl/sha.h>
  11.  
  12. //Copied from Bitcoin source
  13. const uint64_t COIN = 100000000;
  14. const uint64_t CENT = 1000000;
  15.  
  16. uint32_t OP_CHECKSIG = 172; // This is expressed as 0xAC
  17. bool generateBlock = false;
  18. uint32_t startNonce = 0;
  19. uint32_t unixtime = 0;
  20.  
  21. typedef struct {
  22.         /* Hash of Tx */
  23.         uint8_t merkleHash[32];
  24.        
  25.         /* Tx serialization before hashing */
  26.         uint8_t *serializedData;
  27.        
  28.         /* Tx version */
  29.         uint32_t version;
  30.        
  31.         /* Input */
  32.         uint8_t numInputs; // Program assumes one input
  33.         uint8_t prevOutput[32];
  34.         uint32_t prevoutIndex;
  35.         uint8_t *scriptSig;
  36.         uint32_t sequence;
  37.        
  38.         /* Output */
  39.         uint8_t numOutputs; // Program assumes one output
  40.         uint64_t outValue;
  41.         uint8_t *pubkeyScript;
  42.        
  43.         /* Final */
  44.         uint32_t locktime;
  45. } Transaction;
  46.  
  47. // Got this off the internet. Am not sure if it can fail in some circumstances
  48. void byteswap(uint8_t *buf, int length)
  49. {
  50.         int i;
  51.         uint8_t temp;
  52.  
  53.         for(i = 0; i < length / 2; i++)
  54.         {
  55.                 temp = buf[i];
  56.                 buf[i] = buf[length - i - 1];
  57.                 buf[length - i - 1] = temp;
  58.         }  
  59. }
  60.  
  61. // Following two functions are borrowed from cgminer.
  62. char *bin2hex(const unsigned char *p, size_t len)
  63. {
  64.         char *s = malloc((len * 2) + 1);
  65.         unsigned int i;
  66.  
  67.         if (!s)
  68.                 return NULL;
  69.  
  70.         for (i = 0; i < len; i++)
  71.                 sprintf(s + (i * 2), "%02x", (unsigned int) p[i]);
  72.  
  73.         return s;
  74. }
  75.  
  76. size_t hex2bin(unsigned char *p, const char *hexstr, size_t len)
  77. {
  78.         int ret = 0;
  79.         size_t retlen = len;
  80.  
  81.         while (*hexstr && len) {
  82.                 char hex_byte[4];
  83.                 unsigned int v;
  84.  
  85.                 if (!hexstr[1]) {
  86.                         return ret;
  87.                 }
  88.  
  89.                 memset(hex_byte, 0, 4);
  90.                 hex_byte[0] = hexstr[0];
  91.                 hex_byte[1] = hexstr[1];
  92.  
  93.                 if (sscanf(hex_byte, "%x", &v) != 1) {
  94.                         return ret;
  95.                 }
  96.  
  97.                 *p = (unsigned char) v;
  98.  
  99.                 p++;
  100.                 hexstr += 2;
  101.                 len--;
  102.         }
  103.  
  104.         if (len == 0 && *hexstr == 0)
  105.                 ret = retlen;
  106.                
  107.         return ret;
  108. }
  109.  
  110. Transaction *InitTransaction()
  111. {
  112.         Transaction *transaction;
  113.        
  114.         transaction = calloc(1, sizeof(*transaction));
  115.         if(!transaction)
  116.         {
  117.                 return NULL;
  118.         }
  119.        
  120.         // Set some initial data that will remain constant throughout the program
  121.         transaction->version = 1;
  122.         transaction->numInputs = 1;
  123.         transaction->numOutputs = 1;
  124.         transaction->locktime = 0;
  125.         transaction->prevoutIndex = 0xFFFFFFFF;
  126.         transaction->sequence = 0xFFFFFFFF;
  127.         transaction->outValue = 50*COIN;
  128.        
  129.         // We initialize the previous output to 0 as there is none
  130.         memset(transaction->prevOutput, 0, 32);
  131.        
  132.         return transaction;
  133. }
  134.  
  135. int main(int argc, char *argv[])
  136. {
  137.         Transaction *transaction;
  138.         unsigned char hash1[32], hash2[32];
  139.         char timestamp[255], pubkey[132];
  140.         uint32_t timestamp_len = 0, scriptSig_len = 0, pubkey_len = 0, pubkeyScript_len = 0;
  141.         uint32_t nBits = 0;
  142.        
  143.         if((argc-1) < 3)
  144.         {
  145.                 fprintf(stderr, "Usage: genesisgen [options] <pubkey> \"<timestamp>\" <nBits>\n");
  146.                 return 0;              
  147.         }
  148.        
  149.         pubkey_len = strlen(argv[1]) / 2; // One byte is represented as two hex characters, thus we divide by two to get real length.
  150.         timestamp_len = strlen(argv[2]);
  151.        
  152.         if(pubkey_len != 65)
  153.         {
  154.                 fprintf(stderr, "Invalid public key length! %s\n", argv[1]);
  155.                 return 0;
  156.         }
  157.        
  158.         if(timestamp_len > 254 || timestamp_len <= 0)
  159.         {
  160.                 fprintf(stderr, "Size of timestamp is 0 or exceeds maximum length of 254 characters!\n");
  161.                 return 0;
  162.         }      
  163.  
  164.         transaction = InitTransaction();
  165.         if(!transaction)
  166.         {
  167.                 fprintf(stderr, "Could not allocate memory! Exiting...\n");
  168.                 return 0;      
  169.         }
  170.        
  171.         strncpy(pubkey, argv[1], sizeof(pubkey));
  172.         strncpy(timestamp, argv[2], sizeof(timestamp));
  173.         sscanf(argv[3], "%lu", (long unsigned int *)&nBits);
  174.        
  175.         pubkey_len = strlen(pubkey) >> 1;
  176.         scriptSig_len = timestamp_len;
  177.        
  178.         // Encode pubkey to binary and prepend pubkey size, then append the OP_CHECKSIG byte
  179.         transaction->pubkeyScript = malloc((pubkey_len+2)*sizeof(uint8_t));
  180.         pubkeyScript_len = hex2bin(transaction->pubkeyScript+1, pubkey, pubkey_len); // No error checking, yeah.
  181.         transaction->pubkeyScript[0] = 0x41; // A public key is 32 bytes X coordinate, 32 bytes Y coordinate and one byte 0x04, so 65 bytes i.e 0x41 in Hex.
  182.         pubkeyScript_len+=1;
  183.         transaction->pubkeyScript[pubkeyScript_len++] = OP_CHECKSIG;
  184.        
  185.         // Encode timestamp to binary
  186.         transaction->scriptSig = malloc(scriptSig_len*sizeof(uint8_t));
  187.         uint32_t scriptSig_pos = 0;
  188.        
  189.        
  190.         // This is basically how I believe the size of the nBits is calculated
  191.         if(nBits <= 255)
  192.         {
  193.                 transaction->scriptSig[scriptSig_pos++] = 0x01;
  194.                 transaction->scriptSig[scriptSig_pos++] = (uint8_t)nBits;
  195.         }
  196.         else if(nBits <= 65535)
  197.         {
  198.                 transaction->scriptSig[scriptSig_pos++] = 0x02;
  199.                 memcpy(transaction->scriptSig+scriptSig_pos, &nBits, 2);
  200.                 scriptSig_pos+=2;
  201.         }      
  202.         else if(nBits <= 16777215)
  203.         {
  204.                 transaction->scriptSig[scriptSig_pos++] = 0x03;
  205.                 memcpy(transaction->scriptSig+scriptSig_pos, &nBits, 3);
  206.                 scriptSig_pos+=3;
  207.         }
  208.         else //else if(nBits <= 4294967296LL)
  209.         {
  210.                 transaction->scriptSig[scriptSig_pos++] = 0x04;
  211.                 memcpy(transaction->scriptSig+scriptSig_pos, &nBits, 4);
  212.                 scriptSig_pos+=4;
  213.         }
  214.        
  215.         // Important! In the Bitcoin code there is a statement 'CBigNum(4)'
  216.         // i've been wondering for a while what it is but
  217.         // seeing as alt-coins keep it the same, we'll do it here as well
  218.         // It should essentially mean PUSH 1 byte on the stack which in this case is 0x04 or just 4
  219.         transaction->scriptSig[scriptSig_pos++] = 0x01;
  220.         transaction->scriptSig[scriptSig_pos++] = 0x04;
  221.        
  222.         transaction->scriptSig[scriptSig_pos++] = (uint8_t)scriptSig_len;
  223.        
  224.         scriptSig_len += scriptSig_pos;
  225.         transaction->scriptSig = realloc(transaction->scriptSig, scriptSig_len*sizeof(uint8_t));
  226.         memcpy(transaction->scriptSig+scriptSig_pos, (const unsigned char *)timestamp, timestamp_len);
  227.        
  228.         // Here we are asuming some values will have the same size
  229.         uint32_t serializedLen =
  230.         4    // tx version
  231.         +1   // number of inputs
  232.         +32  // hash of previous output
  233.         +4   // previous output's index
  234.         +1   // 1 byte for the size of scriptSig
  235.         +scriptSig_len
  236.         +4   // size of sequence
  237.         +1   // number of outputs
  238.         +8   // 8 bytes for coin value
  239.         +1   // 1 byte to represent size of the pubkey Script
  240.         +pubkeyScript_len
  241.         +4;   // 4 bytes for lock time
  242.        
  243.         // Now let's serialize the data
  244.         uint32_t serializedData_pos = 0;
  245.         transaction->serializedData = malloc(serializedLen*sizeof(uint8_t));
  246.         memcpy(transaction->serializedData+serializedData_pos, &transaction->version, 4);
  247.         serializedData_pos += 4;
  248.         memcpy(transaction->serializedData+serializedData_pos, &transaction->numInputs, 1);
  249.         serializedData_pos += 1;
  250.         memcpy(transaction->serializedData+serializedData_pos, transaction->prevOutput, 32);
  251.         serializedData_pos += 32;
  252.         memcpy(transaction->serializedData+serializedData_pos, &transaction->prevoutIndex, 4);
  253.         serializedData_pos += 4;
  254.         memcpy(transaction->serializedData+serializedData_pos, &scriptSig_len, 1);
  255.         serializedData_pos += 1;
  256.         memcpy(transaction->serializedData+serializedData_pos, transaction->scriptSig, scriptSig_len);
  257.         serializedData_pos += scriptSig_len;
  258.         memcpy(transaction->serializedData+serializedData_pos, &transaction->sequence, 4);
  259.         serializedData_pos += 4;
  260.         memcpy(transaction->serializedData+serializedData_pos, &transaction->numOutputs, 1);
  261.         serializedData_pos += 1;
  262.         memcpy(transaction->serializedData+serializedData_pos, &transaction->outValue, 8);
  263.         serializedData_pos += 8;
  264.         memcpy(transaction->serializedData+serializedData_pos, &pubkeyScript_len, 1);
  265.         serializedData_pos += 1;
  266.         memcpy(transaction->serializedData+serializedData_pos, transaction->pubkeyScript, pubkeyScript_len);
  267.         serializedData_pos += pubkeyScript_len;
  268.         memcpy(transaction->serializedData+serializedData_pos, &transaction->locktime, 4);
  269.         serializedData_pos += 4;       
  270.        
  271.         // Now that the data is serialized
  272.         // we hash it with SHA256 and then hash that result to get merkle hash
  273.         SHA256(transaction->serializedData, serializedLen, hash1);
  274.         SHA256(hash1, 32, hash2);
  275.        
  276.         // This copy isn't necessary imo, but here for clarity
  277.         memcpy(transaction->merkleHash, hash2, 32);
  278.        
  279.         char *merkleHash = bin2hex(transaction->merkleHash, 32);
  280.         byteswap(transaction->merkleHash, 32);
  281.         char *merkleHashSwapped = bin2hex(transaction->merkleHash, 32);
  282.         char *txScriptSig = bin2hex(transaction->scriptSig, scriptSig_len);
  283.         char *pubScriptSig = bin2hex(transaction->pubkeyScript, pubkeyScript_len);
  284.         printf("\nCoinbase: %s\n\nPubkeyScript: %s\n\nMerkle Hash: %s\nByteswapped: %s\n",txScriptSig, pubScriptSig, merkleHash, merkleHashSwapped);
  285.        
  286.         //if(generateBlock)
  287.         {
  288.                 printf("Generating block...\n");
  289.                 if(!unixtime)
  290.                 {
  291.                         unixtime = time(NULL);
  292.                 }
  293.                
  294.                 unsigned char block_header[80], block_hash1[32], block_hash2[32];
  295.                 uint32_t blockversion = 1;
  296.                 memcpy(block_header, &blockversion, 4);
  297.                 memset(block_header+4, 0, 32);
  298.                 byteswap(transaction->merkleHash, 32); // We swapped it before, so do it again now.
  299.                 memcpy(block_header+36, transaction->merkleHash, 32);
  300.                 memcpy(block_header+68, &unixtime, 4);
  301.                 memcpy(block_header+72, &nBits, 4);
  302.                 memcpy(block_header+76, &startNonce, 4);
  303.                
  304.                 uint32_t *pNonce = (uint32_t *)(block_header + 76);
  305.                 uint32_t *pUnixtime = (uint32_t *)(block_header + 68);
  306.                 unsigned int counter, start = time(NULL);
  307.                 while(1)
  308.                 {
  309.                         SHA256(block_header, 80, block_hash1);
  310.                         SHA256(block_hash1, 32, block_hash2);
  311.                        
  312.                         unsigned int check = *((uint32_t *)(block_hash2 + 28)); // The hash is in little-endian, so we check the last 4 bytes.
  313.                         if(check == 0) // \x00\x00\x00\x00
  314.                         {
  315.                                 byteswap(block_hash2, 32);
  316.                                 char *blockHash = bin2hex(block_hash2, 32);
  317.                                 printf("\nBlock found!\nHash: %s\nNonce: %u\nUnix time: %u", blockHash, startNonce, unixtime);
  318.                                 free(blockHash);
  319.                                 break;
  320.                         }
  321.                        
  322.                         startNonce++;
  323.                         counter+=1;
  324.                         if(time(NULL)-start >= 1)
  325.                         {
  326.                                 printf("\r%d Hashes/s, Nonce %u\r", counter, startNonce);
  327.                                 counter = 0;
  328.                                 start = time(NULL);
  329.                         }
  330.                         *pNonce = startNonce;
  331.                         if(startNonce > 4294967294LL)
  332.                         {
  333.                                 //printf("\nBlock found!\nHash: %s\nNonce: %u\nUnix time: %u", blockHash, startNonce, unixtime);
  334.                                 unixtime++;
  335.                                 *pUnixtime = unixtime;
  336.                                 startNonce = 0;
  337.                         }
  338.                 }
  339.         }
  340.        
  341.                
  342.         // Lots of cleanup
  343.         free(merkleHash);
  344.         free(merkleHashSwapped);
  345.         free(txScriptSig);
  346.         free(pubScriptSig);
  347.         free(transaction->serializedData);
  348.         free(transaction->scriptSig);
  349.         free(transaction->pubkeyScript);
  350.         free(transaction);
  351.  
  352.         return 0;
  353. }
RAW Paste Data
Top