Continued:
[core.git] / contrib / chash / lib / functions.php
1 <?php
2 /**
3  * Calculates a simple but stronger hash from given string. No salts are being
4  * added here.
5  *
6  * @param       $str    The string to be hashed
7  * @return      $hash   The hash from string $str
8  */
9 function hashString ($str) {
10         // Calculate strong hash from given string
11         $hash = Scrypt::hash($str, $GLOBALS['salt'], $GLOBALS['difficulty']);
12
13         // Return it directly
14         return $hash;
15 }
16
17 /**
18  * Multiple-hashes given string. This is done by hashing the given string and
19  * then hashing the generated hash again.
20  *
21  * @param       $str    The string to be hashed 4 times
22  * @return      $hash   The generated hash
23  */
24 function multipleHashString ($str) {
25         // Generate hash from given hash
26         $hash = hashString($str);
27
28         // Now over-hash it
29         for ($idx = 0; $idx < ($GLOBALS['hash_cycles'] - 1); $idx++) {
30                 // Over-hash the given hash
31                 $hash = hashString($hash);
32         } // END - for
33
34         // Return it
35         return $hash;
36 }
37
38 /**
39  * Calculates sum from given hash
40  *
41  * @param       $hash   Hash to calculate sum from
42  * @return      $sum    Sum from given hash
43  */
44 function calculateSumFromHash ($hash) {
45         // Everything starts with zero ...
46         $sum = 0;
47
48         // Loop through hash
49         for ($idx = 0; $idx < (strlen($hash) / 2); $idx++) {
50                 // And add it
51                 $sum = $sum + hexdec(substr($hash, $idx, 2));
52         } // END - for
53
54         // And return it
55         return $sum;
56 }
57
58 /**
59  * Calculates new nonce
60  *
61  * @return      void
62  */
63 function calculateNonce () {
64         // Linear incrementation
65         $GLOBALS['nonce'] += $GLOBALS['none_increment'];
66 }
67
68 /**
69  * Writes/flushes check-point file
70  *
71  * @param       $hash   Found hash or gensis hash
72  * @return      void
73  */
74 function flushCheckPointFile ($hash) {
75         // Display message
76         print ('FLUSHING: Writing ' . count($GLOBALS['found_hashes']) . ' blocks ...' . PHP_EOL);
77
78         // Start timer
79         $timer = microtime(true);
80
81         // Flush data
82         file_put_contents(
83                 CHECK_POINT,
84                 $GLOBALS['total_blocks'] . '|' .
85                 $GLOBALS['total_reward'] . '|' .
86                 $GLOBALS['total_hashes'] . '|' .
87                 $GLOBALS['total_found'] . '|' .
88                 $GLOBALS['total_restarts'] . '|' .
89                 $GLOBALS['hash_cycles'] . '|' .
90                 $GLOBALS['salt'] . '|' .
91                 $GLOBALS['difficulty'] . '|' .
92                 base64_encode((float) $GLOBALS['nonce']) . '|' .
93                 $hash . '|' .
94                 $GLOBALS['root_hash'] . '|' .
95                 base64_encode(gzcompress(json_encode($GLOBALS['found_hashes'])))
96         );
97
98         // Set time
99         $GLOBALS['time_flush'] = microtime(true);
100         print ('FLUSHING: Took ' . ($GLOBALS['time_flush'] - $timer) . ' seconds.' . PHP_EOL);
101 }
102
103 /**
104  * Adds a found hash and flushes the checkpoint file
105  *
106  * @param       $hash   Hash to save
107  */
108 function addFoundHash ($hash) {
109         // Increment counter
110         $GLOBALS['total_found']++;
111
112         // Add hash to array
113         array_push($GLOBALS['found_hashes'][$GLOBALS['total_blocks']], array(
114                 'current_hash' => $GLOBALS['current_hash'],
115                 'root_hash'    => $GLOBALS['root_hash'],
116                 'nonce'        => (float) $GLOBALS['nonce'],
117                 'iter'         => $GLOBALS['iteration'],
118                 'hashes_block' => $GLOBALS['hashes_block'],
119                 'hash_cycles'  => $GLOBALS['hash_cycles'],
120                 'difficulty'   => $GLOBALS['difficulty'],
121                 'nonce_hash'   => $hash,
122         ));
123
124         // Found hash:
125         print ('FOUND: hash=' . $hash . ',nonce=' . $GLOBALS['nonce'] . ',total_found=' . $GLOBALS['total_found'] . PHP_EOL);
126
127         // Set time as a new hash was found
128         $GLOBALS['found_time'] = microtime(true);
129
130         // Flush check-point file after new hash is found
131         flushCheckPointFile($hash);
132 }
133
134 /**
135  * Initializes nonce
136  *
137  * @return      void
138  */
139 function initNonce () {
140         $GLOBALS['nonce'] = 1 / (mt_rand() ^ (1 / pi()));
141         print (__FUNCTION__ . ': nonce=' . $GLOBALS['nonce'] . PHP_EOL);
142 }
143
144 /**
145  * Sums all hex parts of the hash to one final sum
146  *
147  * @param       $hash   Hex-hash to sum
148  * @return      Sum of hash
149  */
150 function sumHash ($hash) {
151         // Init it
152         $sum = 0;
153
154         for ($i = 0; $i < (strlen($hash) / 2); $i++) {
155                 $sum += hexdec(substr($hash, $i, 2));
156         }
157
158         return $sum;
159 }
160
161 /**
162  * Loads check-point file, if found
163  *
164  * @return      void
165  */
166 function loadCheckpointFile () {
167         // Is the check point there?
168         if (is_readable(CHECK_POINT)) {
169                 // Then load it
170                 $checkPoint = file_get_contents(CHECK_POINT);
171
172                 // Explode it
173                 $data = explode('|', $checkPoint);
174
175                 // Assert on count
176                 assert(count($data) == 10);
177
178                 // 1st element is nonce, 2nd hash, 3rd found hashes
179                 $GLOBALS['total_blocks']   = $data[0];
180                 $GLOBALS['total_reward']   = $data[1];
181                 $GLOBALS['total_hashes']   = $data[2];
182                 $GLOBALS['total_found']    = $data[3];
183                 $GLOBALS['total_restarts'] = $data[4];
184                 $GLOBALS['hash_cycles']    = intval($data[5]);
185                 $GLOBALS['salt']           = $data[6];
186                 $GLOBALS['difficulty']     = $data[7];
187                 $GLOBALS['nonce']          = (float) base64_decode($data[8]);
188                 $GLOBALS['current_hash']   = $data[9];
189                 $GLOBALS['root_hash']      = $data[9];
190                 $GLOBALS['found_hashes']   = json_decode(gzuncompress(base64_decode($data[11])));
191         } // END - if
192 }