Cómo “robar” bitcoins con una modesta tarjeta gráfica NVIDIA

Hola amigos de Tardígrados. El propósito principal del siguiente documento informático, no es enseñar a robar Bitcoins, eso estaría muy feo sino demostrar la robustez de la protección criptográfica de Bitcoin, y mostrar de paso, con un caso práctico, la casi inexpugnable muralla que ofrece esa criptografía contra posibles ataques, que los hay. ¿Es tan segura esa protección criptográfica?. Sí. Estamos hablando de cadenas de 256 bits. Esas contraseñas serán las semillas para generar las llaves privadas y las direcciones públicas de Bitcoin. O sea, estamos hablando de un número monstruosamente grande de combinaciones. Ese número entero es:

que, como vemos, tiene 78 cifras decimales. Para intentar hacernos una idea de lo que ese número representa, supongamos que tenemos una lista de 135 direcciones de Bitcoins, que queremos atacar. Atacar, aquí quiere decir descubrir la clave privada desde la dirección publica. Entonces la probabilidad de dar con una de esas 135 claves sería de:

Es decir, aun suponiendo que nuestra computadora fuera capaz de procesar 1 millón de direcciones por segundo, tendríamos por delante aún unos

para encontrar la primera de esas 135 direcciones de la lista que queremos atacar. Creo que ni Matusalén conseguiría vivir tanto para ver como se consigue ese primer hallazgo 🙂

Mi tarjeta gráfica es una NVIDIA GeForce GT 430. Escribiremos un pequeño programa para Node.JS , en el que aceleraremos la computación mediante tarjeta gráfica, es decir, usaremos la GPU de la tarjeta gráfica, en lugar de la CPU de la computadora. Para la computación con tarjeta gráfica usaremos el módulo gpu.js, el cual posee un javascript de aceleración muy interesante. Para trabajar con bitcoins, yo uso el módulo bitcore-lib, donde además de las herramientas para bitcoin también trae otras interesantes utilidades. Empecemos abriendo un editor de texto cualquiera, y escribamos las primeras instrucciones de nuestro programilla, que como sabemos deberá ser escrito en lenguaje javascript, ya que es para Node.JS .

1. const {GPU} = require(‘./gpu.js’);
2. const bitcore = require(‘bitcore-lib’);
3. const crypto = require(‘crypto’);
4. const fs = require(‘fs’);
5. const gpu = new GPU();
6. var argv = require(‘yargs’)
7. .usage(‘Usage: $0 –range [num] –samples [num]’)
8. /*.demand([‘range’,’samples’])*/
9. .argv;
12. const jsonutil = require(‘jsonutil’);
13. const JSONStream = require(‘JSONStream’);

Los módulos gpu.js, yargs, jsonutil y bitcore-lib, los puedes decargar desde npm. Los módulos crypto y fs, no, porque ya vienen incluidos en el propio Node.js.

Nuestro programilla, que trabajará desde una consola DOS de windows mediante comandos, tiene el módulo yargs, con el que definimos dos argumentos para pasar en la linea de comandos al ser ejecutado. Nuestro primer argumento será –range [num], y en él especificaremos el número de coincidencias que deseamos (obviamente, desearíamos un número de coincidencias pleno, pero como esta es sólo una herramienta demostrativa, tenemos que dar juego a las coincidencias. Las direcciones públicas de bitcoin poseen 34 caracteres, porque están codificadas en Base58, por lo tanto el juego podrá ir desde 1 coincidencias hasta el pleno de 34. ¿Por qué 34?. Porque son números hexadecimales de 50 dígitos, que están codificados en Base58. Después usaremos en nuestra linea de comando el argumento –samples [num], que será el número de direcciones que queremos en nuestra lista de resultados, Obviamente si nuestra lista de direcciones objetivo es de 135, el número num que sigue a –samples no podrá ser nunca mayor a esos 135.

Sigamos escribiendo nuestro código en nuestro editor de textos favorito:

14. const range = argv.range?parseInt(argv.range):4;
15. var max_limit = argv.samples?parseInt(argv.samples):10;
16. const file = “keys-“+range+“.json”;
17. var results_file = “keys-“+range+“.json”;
18. var jsonwriter = JSONStream.stringify();
19. var jsonwriter_file = fs.createWriteStream(results_file);
20. jsonwriter.pipe(jsonwriter_file);
22. const objetive_addrs =[// list of bitcoin public addreses, can’t be empty
23. //…TODO
24. ];
26. const objetive_size = 100;
27. const m = Fill(objetive_size);
28. const render = gpu.createKernel(function(a,m) {
30. var h = a[this.thread.y][this.thread.x];
31. var c = m[this.thread.y][this.thread.x];
32. if(h == c) return h;
33. return –1;
35. }).setOutput([42, objetive_size]);
37. var n=0;
38. var time0 = Date.now();
39. var total=0;
40. var stop = 8;
41. var keys = {
42. phrase:null,
43. private_key:null,
44. wif:null,
45. public_address:null,
46. objetive_addrs:null
47. };

En las lineas 14 y 15 pasamos los argumentos –range y –samples a sus respectivas variables range y max_limit. En las lineas 16 y 17 nombramos 2 archivos con el mismo nombre.. En las lineas 18 a 20 creamos los streams para escribir el archivo results_file.

El resto del programilla es como sigue:

48. /***********************************************************************************************************/
50. console.log(“\x1b[32m***************************************************\x1b[0m”);
51. console.log(“\x1b[32m*******************\x1b[0m\x1b[92m THE IMPOSSIBLE\x1b[0m\x1b[32m ****************\x1b[0m”);
52. console.log(“\x1b[32m*******\x1b[0m\x1b[92mIt’s kind of fun to do the impossible\x1b[0m\x1b[32m*******\x1b[0m”);
53. console.log(“\x1b[32m—————RANGE \x1b[1m%s\x1b[0m \x1b[35mwith samples\x1b[0m \x1b[1m%s\x1b[0m \x1b[35mSTARTED—————\x1b[0m”,range,max_limit);
54. console.log({miners_size:objetive_adrs.length});
55. while(n < max_limit){
56. var ar = FillArray(miners_size);
57. var a = ar[0];
58. var b = ar[1];
59. var p = ar[2];
60. var w = ar[3];
62. var r = render(a,m);
63. var t = filterArray(r, a, b, p, w, m, range);
64. if(t.length){
66. for(var i=0;i<t.length;i++){
68. keys.phrase = t[i][0];
69. keys.private_key = t[i][1];
70. keys.wif = t[i][2];
71. keys.public_address = t[i][3];
72. keys.miner__address = t[i][4];
73. jsonwriter.write(keys);
74. var pair = highlight(t[i]);
75. keys.phrase = pair[0];
76. keys.private_key = pair[1];
77. keys.wif = pair[2];
78. keys.public_address = pair[3];
79. keys.miner__address = pair[4];
80. consola(keys);
82. var time = Date.now()–time0;
83. total += time;
84. time0 = Date.now();
85. console.log(“\x1b[33mNew keys has been appended to file \x1b[1m%s\x1b[0m. \x1b[33mDuration of this sample: \x1b[31m\x1b[1m%s\x1b[0m \x1b[33mseconds\x1b[0m”,results_file, time/1000);
87. }
88. n++;
89. if(n==max_limit) {
90. jsonwriter.end();
91. console.log(“max-limit of %s samples reached. Job terminated.”,max_limit);
92. console.log(“\x1b[33m – Total \x1b[1mduration\x1b[0m \x1b[33mof job: \x1b[31m\x1b[1m%s\x1b[0m \x1b[33mseconds – \x1b[0m”,total/1000);
93. break;
94. }
97. }
99. }
102. /******************************************************/
103. function FillArray(size){
104. var a = [];
105. var b = [];
106. var p = [];
107. var w = [];
108. for(var j = 0;j < size;j++){
109. var t = [];
110. var hash = crypto.randomBytes(32);
111. //var hash = bitcore.crypto.Hash.sha256(crypto.randomBytes(32));
112. var bn = bitcore.crypto.BN.fromBuffer(hash);
113. var privateKey = new bitcore.PrivateKey(bn);
114. var address = privateKey.toAddress().toString(‘hex’);
115. b.push(hash.toString(‘hex’));
116. p.push(privateKey.toString(‘hex’));
117. w.push(privateKey.toWIF().toString(‘hex’));
119. for(var i = 0;i < address.length;i++){
120. t.push(address.charCodeAt(i));
121. }
122. a.push(t);
123. }
124. return [a,b,p,w];
125. }
127. function FillMiners(size){
129. var a = [];
130. var k = 0;
131. for(var j = 0;j < size;j++){
132. if(k == objetive_adrs.length)k=0;
133. var address = objetive_adrs[k];
134. k++;
135. var t = [];
136. for(var i = 0;i < 42;i++){
137. if(i<address.length)
138. t.push(address.charCodeAt(i));
139. else
140. t.push(0);
141. }
142. a.push(t);
143. }
144. return a;
145. }
147. function FillMiners2(size){
149. var a = [];
150. var k = 0;
151. for(var j = 0;j < size;j++){
152. if(k == objetive_addrs.length)k=0;
153. var address = objetive_addrs[k];
154. k++;
155. var t = [];
156. for(var i = 0;i < 42;i++){
157. if(i<address.length)
158. t.push(address.charCodeAt(i));
159. else
160. t.push(0);
161. }
162. a.push(t);
163. }
164. return a;
165. }
169. function check(a) {
170. return a != –1;
171. }
173. function filterArray(r, a, b, p, w, m, range){
175. var f = [];
176. for(i in r){
177. var s = r[i].filter(check);
178. if(s.length >= range){
179. var a1 = new Buffer.from(a[i]).toString();
180. var b1 = b[i];
181. var p1 = p[i];
182. var w1 = w[i];
183. var m1 = new Buffer.from(objetive_adrs[i]).toString();
184. f.push([b1,p1,w1,a1,m1]);
185. }
186. }
189. return f;
190. }
191. // funciones para imprimir resultados en la consols DOS de Winsdows
192. function highlight(keys){
194. var pa = keys[3].split(”);
195. var ma = keys[4].split(”);
196. const h =‘\x1b[1m’;
197. const t =‘\x1b[0m\x1b[32m’;
198. const y =‘\x1b[33m’;
199. const g =‘\x1b[32m’;
200. for(id in pa){
201. if(pa[id] == ma[id]){
202. pa[id] = ma[id] = h+ma[id]+t;
204. }
205. }
206. var b = y+keys[0]+‘\x1b[0m’;
207. var p = y+keys[1]+‘\x1b[0m’;
208. var w = y+keys[2]+‘\x1b[0m’;
209. var pa2 = g+pa.join(”)+‘\x1b[0m’;
210. var ma2 = g+ma.join(”)+‘\x1b[0m’;
212. return [b,p,w,pa2,ma2];
214. }
216. function consola(json){
217. var a = JSON.stringify(json,null,8);
218. a = a.replace(/”/g,”);
219. a = a.replace(/\\u001b/g,‘\x1b’);
220. process.stdout.write(a);
222. }
226. /******************************************************/

Saludos