contrib/chash/chash.php

   1 <?php
   2 error_reporting(E_ALL | E_STRICT);
   3
   4 define('START_TIME'            , microtime(TRUE));
   5 define('CHECK_POINT'           , 'chash.pos');
   6
   7 $GLOBALS['block_size']          = 100;
   8 $GLOBALS['none_increment']      = (1 / pow(10, 12));
   9 $GLOBALS['hash_algo']           = MHASH_RIPEMD320;
  10 $GLOBALS['flush_file_time']     = 30;
  11 $GLOBALS['restart_search_time'] = 1800;
  12
  13 // Hashes per call
  14 $GLOBALS['hash_cycles'] = 3;
  15
  16 // Found hashes
  17 $GLOBALS['found_hashes'] = array(0 => array());
  18
  19 /**
  20  * Continued-hashing
  21  *
  22  * @author              Roland Haeder <roland@mxchange.org>
  23  * @copyright   Copyright (c) 2013 by Core Developer Team
  24  * @license             See LICENSE (public-domain)
  25  */
  26
  27 /**
  28  * Calculates a simple but stronger hash from given string. No salts are being
  29  * added here.
  30  *
  31  * @param       $str    The string to be hashed
  32  * @return      $hash   The hash from string $str
  33  */
  34 function hashString ($str) {
  35         // Calculate strong hash from given string
  36         $hash = mhash($GLOBALS['hash_algo'], $str);
  37
  38         // Return it hexadecimal-encoded
  39         return bin2hex($hash);
  40 }
  41
  42 /**
  43  * Multiple-hashes given string. This is done by hashing the given string and
  44  * then hashing the generated hash again.
  45  *
  46  * @param       $str    The string to be hashed 4 times
  47  * @return      $hash   The generated hash
  48  */
  49 function multipleHashString ($str) {
  50         // Generate hash from given hash
  51         $hash = hashString($str);
  52
  53         // Now over-hash it
  54         for ($idx = 0; $idx < ($GLOBALS['hash_cycles'] - 1); $idx++) {
  55                 // Over-hash the given hash
  56                 $hash = hashString($hash);
  57         } // END - for
  58
  59         // Return it
  60         return $hash;
  61 }
  62
  63 /**
  64  * Calculates a "modula-hash" based given two hashes.
  65  *
  66  * @param       $hash1  Hash 1
  67  * @param       $hash2  Hash 2
  68  */
  69 function modulaHash ($hash1, $hash2) {
  70         // Both must have same length
  71         assert(strlen($hash1) === strlen($hash2));
  72
  73         // Init new hash
  74         $modulaHash = '';
  75
  76         // "Walk" trough first hash and get every 2 byte of both hashes
  77         for ($idx = 0; $idx < strlen($hash1); $idx += 2) {
  78                 // Init modula value
  79                 $mod = 0;
  80
  81                 // Get both hash parts and convert to ASCII number
  82                 $part1 = hexdec(substr($hash1, $idx, 2));
  83                 $part2 = hexdec(substr($hash2, $idx, 2));
  84
  85                 /*
  86                  * If part1 is larget part2, part1 is divident and vise-versa. But don't do it
  87                  * if one is zero
  88                  */
  89                 if (($part1 > $part2) && ($part2 > 0)) {
  90                         // 'part1' is larger than 'part2'
  91                         $mod = $part1 % $part2;
  92                 } elseif (($part1 < $part2) && ($part1 > 0)) {
  93                         // 'part2' is larger than 'part1'
  94                         $mod = $part2 % $part1;
  95                 }
  96
  97                 // "Invert" the result against 255
  98                 $mod = 255 - $mod;
  99
 100                 // Encode to hex, pre-pad it with zeros and add to new hash
 101                 $modulaHash .= padHex($mod);
 102         } // END - for
 103
 104         // Modula hash must have same length as input hash
 105         assert(strlen($modulaHash) === strlen($hash1));
 106
 107         // Return modula hash
 108         return $modulaHash;
 109 }
 110
 111 /**
 112  * Calculates a "sqrt-hash" based given two hashes and single-hash it
 113  *
 114  * @param       $hash1  Hash 1
 115  * @param       $hash2  Hash 2
 116  */
 117 function sqrtHash ($hash1, $hash2) {
 118         // Both must have same length
 119         assert(strlen($hash1) === strlen($hash2));
 120
 121         // Init new hash
 122         $sqrtHash = '';
 123
 124         // "Walk" trough first hash and get every 2 byte of both hashes
 125         for ($idx = 0; $idx < strlen($hash1); $idx += 2) {
 126                 // Init modula value
 127                 $mod = 0;
 128
 129                 // Get both hash parts and convert to ASCII number
 130                 $part1 = hexdec(substr($hash1, $idx, 2));
 131                 $part2 = hexdec(substr($hash2, $idx, 2));
 132
 133                 // Calculate square root of both parts being multiplied and round up, then "invert" it against 255
 134                 $sqrt = intval(255 - ceil(sqrt($part1 * $part2)));
 135
 136                 // Encode to hex, pre-pad it with zeros and add to new hash
 137                 $sqrtHash .= padHex($sqrt);
 138         } // END - for
 139
 140         // "sqrt-hash" must have same length as input hash
 141         assert(strlen($sqrtHash) === strlen($hash1));
 142
 143         // Hash reversed "sqrt-hash" again and return it
 144         return hashString(strrev($sqrtHash));
 145 }
 146
 147 /**
 148  * Converts a number between 0 and 255 into a zero-padded hexadecimal string
 149  *
 150  * @param       $num    Number between 0 and 255
 151  * @return      $hex    Hexadecimal string, padded with zeros
 152  */
 153 function padHex ($num) {
 154         // Must be a integer number and between 0 and 255
 155         assert(is_int($num));
 156         assert($num >= 0);
 157         assert($num <= 255);
 158
 159         // Convert it
 160         $hex = str_pad(dechex($num), 2, '0', STR_PAD_LEFT);
 161
 162         // ... and return it
 163         return $hex;
 164 }
 165
 166 /**
 167  * Calculates sum from given hash
 168  *
 169  * @param       $hash   Hash to calculate sum from
 170  * @return      $sum    Sum from given hash
 171  */
 172 function calculateSumFromHash ($hash) {
 173         // Everything starts with zero ...
 174         $sum = 0;
 175
 176         // Loop through hash
 177         for ($idx = 0; $idx < (strlen($hash) / 2); $idx++) {
 178                 // And add it
 179                 $sum = $sum + hexdec(substr($hash, $idx, 2));
 180         } // END - for
 181
 182         // And return it
 183         return $sum;
 184 }
 185
 186 /**
 187  * Calculates new nonce
 188  *
 189  * @return      void
 190  */
 191 function calculateNonce () {
 192         // Linear incrementation
 193         $GLOBALS['nonce'] += $GLOBALS['none_increment'];
 194 }
 195
 196 /**
 197  * Writes/flushes check-point file
 198  *
 199  * @param       $hash   Modula hash (or hash to save)
 200  * @return      void
 201  */
 202 function flushCheckPointFile ($hash) {
 203         // Display message
 204         print ('FLUSHING: Writing ' . count($GLOBALS['found_hashes']) . ' blocks ...' . PHP_EOL);
 205
 206         // Start timer
 207         $timer = microtime(TRUE);
 208
 209         // Flush data
 210         file_put_contents(CHECK_POINT, $GLOBALS['total_blocks'] . ':' . $GLOBALS['total_reward'] . ':' . $GLOBALS['total_hashes'] . ':' . $GLOBALS['hash_cycles'] . ':' . base64_encode($GLOBALS['nonce']) . ':' . $hash . ':' . $GLOBALS['root_hash'] . ':' . base64_encode(gzcompress(serialize($GLOBALS['found_hashes']))));
 211
 212         // Set time
 213         $GLOBALS['time_flush'] = microtime(TRUE);
 214         print ('FLUSHING: Took ' . ($GLOBALS['time_flush'] - $timer) . ' seconds.' . PHP_EOL);
 215 }
 216
 217 /**
 218  * Adds a found hash and flushes the checkpoint file
 219  *
 220  * @param       $hash   Hash to save
 221  */
 222 function addFoundHash ($hash) {
 223         // Increment counter
 224         $GLOBALS['current_hashes']++;
 225
 226         // Add hash to array
 227         array_push($GLOBALS['found_hashes'][$GLOBALS['total_blocks']], array(
 228                 'modula_hash'  => $GLOBALS['modula_hash'],
 229                 'genesis_hash' => $GLOBALS['genesis_hash'],
 230                 'root_hash'    => $GLOBALS['root_hash'],
 231                 'nonce'        => $GLOBALS['nonce'],
 232                 'iter'         => $GLOBALS['iteration'],
 233                 'hashes_block' => $GLOBALS['hashes_block'],
 234                 'hash_cycles'  => $GLOBALS['hash_cycles'],
 235                 'nonce_hash'   => $hash
 236         ));
 237
 238         // Found hash:
 239         print ('FOUND: hash=' . $hash . ',nonce=' . $GLOBALS['nonce'] . ',current_hashes=' . $GLOBALS['current_hashes'] . PHP_EOL);
 240
 241         // Set time as a new hash was found
 242         $GLOBALS['found_time'] = microtime(TRUE);
 243
 244         // Flush check-point file after new hash is found
 245         flushCheckPointFile($hash);
 246
 247         // Use nonceHash as next modula hash
 248         setModulaHash($hash);
 249 }
 250
 251 /**
 252  * Initializes nonce
 253  *
 254  * @return      void
 255  */
 256 function initNonce () {
 257         $GLOBALS['nonce'] = 1 / (mt_rand() ^ pi());
 258         print (__FUNCTION__ . ': nonce=' . $GLOBALS['nonce'] . PHP_EOL);
 259 }
 260
 261 /**
 262  * Sets modula hash and calculates sum of it
 263  *
 264  * @param       $hash   Hash to set as "modula hash"
 265  * @return      void
 266  */
 267 function setModulaHash ($hash) {
 268         $GLOBALS['modula_hash']  = $hash;
 269         $GLOBALS['sum_modula'] = calculateSumFromHash($GLOBALS['modula_hash']);
 270 }
 271
 272 /*
 273  * Calculate "genesis" hashes, please note that these "genesis strings" are now
 274  * known to the public as you can read them here in source code and therefore I
 275  * will not use them for the real genesis hashes.
 276  */
 277 $gensisHashes = array(
 278         // A famous quote from Deus Ex 2 - Invisible War
 279         multiplehashString('"Informations must be free." - AI Helios from Deus Ex'),
 280         // My name + URL of my first StatusNet instance
 281         multipleHashString('Roland Haeder, https://status.mxchange.org'),
 282         // A famous quote from Linus Torwalds
 283         multipleHashString('"Software is like sex. Its better when its free." - Linus Torwalds'),
 284         // Well ...
 285         multipleHashString('September 11 is a big lie.'),
 286
 287         // GNU is not Uni*
 288         multipleHashString('GNU is Not Uni*.'),
 289         // WINE is not an emulator
 290         multipleHashString('WINE Is Not an Emulator.'),
 291         // FlightGear - Fly free!
 292         multipleHashString('FlightGear - Fly free!'),
 293         // Quote from Linus Torwalds
 294         multipleHashString('Your code is shit.. your argument is shit.'),
 295 );
 296
 297 // Calculate "modula hash" from 1st/4th and 2nd/3rd
 298 $modulaHashes = array(
 299         // "Block" 0
 300         modulaHash($gensisHashes[0], $gensisHashes[3]),
 301         modulaHash($gensisHashes[1], $gensisHashes[2]),
 302
 303         // "Block" 1
 304         modulaHash($gensisHashes[4], $gensisHashes[7]),
 305         modulaHash($gensisHashes[5], $gensisHashes[6]),
 306 );
 307
 308 // Calculate "sqrt hash"
 309 $sqrtHashes = array(
 310         sqrtHash($modulaHashes[0], $modulaHashes[1]),
 311         sqrtHash($modulaHashes[2], $modulaHashes[3])
 312 );
 313
 314 // Calulcate modula hash
 315 setModulaHash(multipleHashString(modulaHash($sqrtHashes[0], $sqrtHashes[1])));
 316
 317 // This is also the "genesis" hash and first root hash
 318 $GLOBALS['genesis_hash'] = $GLOBALS['modula_hash'];
 319 $GLOBALS['root_hash']    = $GLOBALS['modula_hash'];
 320
 321 // Output results
 322 print ('hashes=' . print_r($gensisHashes, TRUE));
 323 print ('modulaHashes=' . print_r($modulaHashes, TRUE));
 324 print ('sqrtHashes=' . print_r($sqrtHashes, TRUE));
 325 print ('modulaHash=' . $GLOBALS['modula_hash'] . PHP_EOL);
 326
 327 // Total reward + hashes
 328 $GLOBALS['total_reward']   = 0;
 329 $GLOBALS['total_hashes']   = 0;
 330 $GLOBALS['total_blocks']   = 0;
 331 $GLOBALS['current_hashes'] = 0;
 332 $GLOBALS['found_time']     = microtime(TRUE);
 333
 334 // Is the check point there?
 335 if (is_readable(CHECK_POINT)) {
 336         // Then load it
 337         $checkPoint = file_get_contents(CHECK_POINT);
 338
 339         // Explode it
 340         $data = explode(':', $checkPoint);
 341
 342         // Assert on count
 343         assert(count($data) == 8);
 344
 345         // 1st element is nonce, 2nd hash, 3rd found hashes
 346         $GLOBALS['total_blocks'] = $data[0];
 347         $GLOBALS['total_reward'] = $data[1];
 348         $GLOBALS['total_hashes'] = $data[2];
 349         $GLOBALS['hash_cycles']  = intval($data[3]);
 350         $GLOBALS['nonce']        = base64_decode($data[4]);
 351         $GLOBALS['root_hash']    = $data[6];
 352         $GLOBALS['found_hashes'] = unserialize(gzuncompress(base64_decode($data[7])));
 353
 354         // Set modula hash
 355         setModulaHash($data[5]);
 356 } else {
 357         // Create nonce (small)
 358         initNonce();
 359 }
 360
 361 // Output again
 362 print ('modulaHash=' . $GLOBALS['modula_hash'] . PHP_EOL);
 363 print ('nonce=' . $GLOBALS['nonce'] . PHP_EOL);
 364 print ('found=' . count($GLOBALS['found_hashes'][$GLOBALS['total_blocks']]) . PHP_EOL);
 365
 366 // Start "mining"
 367 while (TRUE) {
 368         // Init hash-per-block counter and hashrate
 369         $GLOBALS['hashes_block'] = 0;
 370         $hashrate = 0;
 371
 372         // Wait for block_size iterations (= found hashes). This is one block
 373         $timeBlock   = microtime(TRUE);
 374         $timeDisplay = $timeBlock;
 375         $GLOBALS['time_flush'] = $timeBlock;
 376
 377         // Time waited for a good block again (no iteration)
 378         $timeBadHashes = 0;
 379
 380         while (count($GLOBALS['found_hashes'][$GLOBALS['total_blocks']]) <= $GLOBALS['block_size']) {
 381                 // Create hash from modulaHash ("genesis hash") and nonce
 382                 $nonceHash = multipleHashString($GLOBALS['nonce'] . $GLOBALS['modula_hash']);
 383
 384                 // Calculate sums
 385                 $sumNonce  = calculateSumFromHash($nonceHash);
 386
 387                 // Init counter
 388                 $GLOBALS['iteration'] = 0;
 389                 $GLOBALS['iteration_second'] = 0;
 390
 391                 // Now start the "mining" ...
 392                 $timeHash = microtime(TRUE);
 393                 while ($sumNonce < $GLOBALS['sum_modula']) {
 394                         // Calculate new nonce
 395                         calculateNonce();
 396
 397                         // And hash again
 398                         $nonceHash = multipleHashString($GLOBALS['nonce'] . $GLOBALS['modula_hash']);
 399
 400                         // Calculate sums
 401                         $sumNonce  = calculateSumFromHash($nonceHash);
 402
 403                         // Time spend in loop
 404                         $testTime = abs(microtime(TRUE) - $timeDisplay);
 405
 406                         // Calculate hashrate/sec
 407                         $hashrate = 1 / $testTime * $GLOBALS['iteration_second'] * $GLOBALS['hash_cycles'];
 408
 409                         // Only every second
 410                         if ($testTime >= 1) {
 411                                 // Display hash rate
 412                                 print ('hashrate=' . round($hashrate) . ' hashes/sec,iterSecond=' . $GLOBALS['iteration_second'] . ' iterations/sec' . PHP_EOL);
 413
 414                                 // Reset timer
 415                                 $timeDisplay = microtime(TRUE);
 416                                 $GLOBALS['iteration_second']  = 0;
 417                         } // END - if
 418
 419                         // Time spend from last flush
 420                         $testTime = abs(microtime(TRUE) - $GLOBALS['time_flush']);
 421
 422                         // Only once per 10 seconds
 423                         if ($testTime >= $GLOBALS['flush_file_time']) {
 424                                 // Flush check-point file
 425                                 flushCheckPointFile($GLOBALS['modula_hash']);
 426                         } // END - if
 427
 428                         // Time spend from last found block
 429                         $testTime = abs(microtime(TRUE) - $GLOBALS['found_time']);
 430
 431                         // Is the last found time to far away?
 432                         if ($testTime >= $GLOBALS['restart_search_time']) {
 433                                 // Count all root (genesis) hashes
 434                                 $rootHashes = array();
 435                                 foreach ($GLOBALS['found_hashes'] as $block) {
 436                                         // "Walk" through all blocks
 437                                         foreach ($block as $hash) {
 438                                                 if (!isset($hash['root_hash'])) {
 439                                                         // Bad file
 440                                                         die('INCONSISTENCY: hash=' . print_r($hash, TRUE));
 441                                                 } // END - if
 442
 443                                                 if (isset($rootHashes[$hash['root_hash']])) {
 444                                                         // Count up
 445                                                         $rootHashes[$hash['root_hash']]++;
 446                                                 } else {
 447                                                         // First entry found
 448                                                         $rootHashes[$hash['root_hash']] = 1;
 449                                                 }
 450                                         } // END - foreach
 451                                 } // END - foreach
 452
 453                                 // Find best root hash
 454                                 $bestRootHash = '';
 455                                 $bestRootCount = 0;
 456                                 foreach ($rootHashes as $hash => $count) {
 457                                         // Debug message
 458                                         //* NOISY-DEBUG: */ print ('hash=' . $hash . ',count=' . $count . ',bestRootHash=' . $bestRootHash . ',bestRootCount=' . $bestRootCount . PHP_EOL);
 459
 460                                         // Is a better one found?
 461                                         if ($count > $bestRootCount) {
 462                                                 // Remember it
 463                                                 $bestRootHash  = $hash;
 464                                                 $bestRootCount = $count;
 465                                         } // END - if
 466                                 } // END - foreach
 467
 468                                 // Output message
 469                                 print ('bestRootHash=' . $bestRootHash . ',bestRootCount=' . $bestRootCount . PHP_EOL);
 470
 471                                 // Search for latest best root hash
 472                                 foreach ($GLOBALS['found_hashes'] as $block) {
 473                                         // "Walk" through whole block and search for first appearance of best root hash
 474                                         foreach ($block as $idx => $hash) {
 475                                                 // Is the root hash there?
 476                                                 if ($hash['root_hash'] == $bestRootHash) {
 477                                                         // Set found modula hash as new root and current modula hash
 478                                                         $GLOBALS['root_hash']   = $hash['nonce_hash'];
 479                                                         setModulaHash($hash['nonce_hash']);
 480                                                         print ('idx=' . $idx . ',modulaHash=' . $GLOBALS['root_hash'] . ' - Is now new root hash!' . PHP_EOL);
 481
 482                                                         // Reset "found time" (when a hash was found)
 483                                                         $GLOBALS['found_time'] = microtime(TRUE);
 484
 485                                                         // Re-initialize nonce
 486                                                         initNonce();
 487
 488                                                         // Abort search
 489                                                         break;
 490                                                 } // END - if
 491                                         } // END - for
 492                                 } // END - foreach
 493                         } // END - if
 494
 495                         // Next round
 496                         $GLOBALS['iteration']++;
 497                         $GLOBALS['iteration_second']++;
 498                         //print ('nonce=' . $GLOBALS['nonce'] . ',iteration=' . $GLOBALS['iteration'] . PHP_EOL);
 499                         //print ('nonceHash=' . $nonceHash . PHP_EOL);
 500                         //print ('sumNonce=' . $sumNonce . PHP_EOL);
 501                         //print ('sumModula=' . $GLOBALS['sum_modula'] . PHP_EOL);
 502                 } // END - while
 503
 504                 // If the iteration is zero, then no hash is found
 505                 if ($GLOBALS['iteration'] == 0) {
 506                         // Bad hash found
 507                         $timeBadHashes += abs(microtime(TRUE) - $timeHash);
 508
 509                         // And next round
 510                         print('BAD:nonce=' . $GLOBALS['nonce'] . PHP_EOL);
 511
 512                         // Nothing found, so calculate new nonce
 513                         calculateNonce();
 514                         continue;
 515                 } // END - if
 516
 517                 // Add amount of hashes per block (multiple-hash)
 518                 $GLOBALS['hashes_block'] += $GLOBALS['iteration'] * $GLOBALS['hash_cycles'] + $GLOBALS['hash_cycles'];
 519
 520                 // Push found hash
 521                 addFoundHash($nonceHash);
 522         } // END - while
 523
 524         // Time taken for one
 525         $timeBlock = abs(microtime(TRUE) - $timeBlock);
 526
 527         // Calculate reward
 528         $reward = abs($timeBlock - $timeBadHashes) / $hashrate * $GLOBALS['hashes_block'] / $GLOBALS['block_size'] * 1000;
 529         print ('timeBlock=' . $timeBlock . ',timeBadHashes=' . $timeBadHashes . ',hashesPerBlock=' . $GLOBALS['hashes_block'] .',reward=' . $reward . PHP_EOL);
 530
 531         // Block completed
 532         $GLOBALS['total_hashes'] += $GLOBALS['hashes_block'];
 533         $GLOBALS['total_blocks']++;
 534         $GLOBALS['hashes_block'] = 0;
 535
 536         // Init next block
 537         $GLOBALS['found_hashes'][$GLOBALS['total_blocks']] = array();
 538
 539         // Calculate new nonce
 540         calculateNonce();
 541
 542         // Add reward to total
 543         $GLOBALS['total_reward'] += $reward;
 544
 545         // Calculate average block value
 546         $blockValue = $GLOBALS['total_reward'] / $GLOBALS['total_blocks'] * $GLOBALS['total_hashes'] / ($GLOBALS['block_size'] * $GLOBALS['total_blocks']);
 547
 548         // Calculate reward per hour (= 3600 seconds)
 549         $rewardPerHour = $GLOBALS['total_reward'] / abs(microtime(TRUE) - START_TIME) * 3600;
 550
 551         print ('totalReward=' . $GLOBALS['total_reward'] . ',blockValue=' . $blockValue . ',rewardPerHour=' . $rewardPerHour . PHP_EOL);
 552 } // END - while
 553
 554 // [EOF]
 555 ?>