API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 19th, 2010
3,031
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 16.89 KB | None | 0 0
raw download clone embed print report
  1. import struct
  2. import socket
  3. import asyncore
  4. import binascii
  5. import time
  6. import sys
  7. import random
  8. import cStringIO
  9. from Crypto.Hash import SHA256
  10.  
  11. MY_VERSION = 312
  12. MY_SUBVERSION = ".4"
  13.  
  14. def deser_string(f):
  15. nit = struct.unpack("<B", f.read(1))[0]
  16. if nit == 253:
  17. nit = struct.unpack("<H", f.read(2))[0]
  18. elif nit == 254:
  19. nit = struct.unpack("<I", f.read(4))[0]
  20. elif nit == 255:
  21. nit = struct.unpack("<Q", f.read(8))[0]
  22. return f.read(nit)
  23.  
  24. def ser_string(s):
  25. if len(s) < 253:
  26. return chr(len(s)) + s
  27. elif len(s) < 0x10000:
  28. return chr(253) + struct.pack("<H", len(s)) + s
  29. elif len(s) < 0x100000000L:
  30. return chr(254) + struct.pack("<I", len(s)) + s
  31. return chr(255) + struct.pack("<Q", len(s)) + s
  32.  
  33. def deser_uint256(f):
  34. r = 0L
  35. for i in xrange(8):
  36. t = struct.unpack("<I", f.read(4))[0]
  37. r += t << (i * 32)
  38. return r
  39.  
  40. def ser_uint256(u):
  41. rs = ""
  42. for i in xrange(8):
  43. rs += struct.pack("<I", u & 0xFFFFFFFFL)
  44. u >>= 32
  45. return rs
  46.  
  47. def uint256_from_str(s):
  48. r = 0L
  49. t = struct.unpack("<IIIIIIII", s[:32])
  50. for i in xrange(8):
  51. r += t[i] << (i * 32)
  52. return r
  53.  
  54. def uint256_from_compact(c):
  55. nbytes = (c >> 24) & 0xFF
  56. v = (c & 0xFFFFFFL) << (8 * (nbytes - 3))
  57. return v
  58.  
  59. def deser_vector(f, c):
  60. nit = struct.unpack("<B", f.read(1))[0]
  61. if nit == 253:
  62. nit = struct.unpack("<H", f.read(2))[0]
  63. elif nit == 254:
  64. nit = struct.unpack("<I", f.read(4))[0]
  65. elif nit == 255:
  66. nit = struct.unpack("<Q", f.read(8))[0]
  67. r = []
  68. for i in xrange(nit):
  69. t = c()
  70. t.deserialize(f)
  71. r.append(t)
  72. return r
  73.  
  74. def ser_vector(l):
  75. r = ""
  76. if len(l) < 253:
  77. r = chr(len(l))
  78. elif len(l) < 0x10000:
  79. r = chr(253) + struct.pack("<H", len(l))
  80. elif len(l) < 0x100000000L:
  81. r = chr(254) + struct.pack("<I", len(l))
  82. else:
  83. r = chr(255) + struct.pack("<Q", len(l))
  84. for i in l:
  85. r += i.serialize()
  86. return r
  87.  
  88. def deser_uint256_vector(f):
  89. nit = struct.unpack("<B", f.read(1))[0]
  90. if nit == 253:
  91. nit = struct.unpack("<H", f.read(2))[0]
  92. elif nit == 254:
  93. nit = struct.unpack("<I", f.read(4))[0]
  94. elif nit == 255:
  95. nit = struct.unpack("<Q", f.read(8))[0]
  96. r = []
  97. for i in xrange(nit):
  98. t = deser_uint256(f)
  99. r.append(t)
  100. return r
  101.  
  102. def ser_uint256_vector(l):
  103. r = ""
  104. if len(l) < 253:
  105. r = chr(len(l))
  106. elif len(s) < 0x10000:
  107. r = chr(253) + struct.pack("<H", len(l))
  108. elif len(s) < 0x100000000L:
  109. r = chr(254) + struct.pack("<I", len(l))
  110. else:
  111. r = chr(255) + struct.pack("<Q", len(l))
  112. for i in l:
  113. r += ser_uint256(i)
  114. return r
  115.  
  116. class CAddress(object):
  117. def __init__(self):
  118. self.nServices = 1
  119. self.pchReserved = "\x00" * 10 + "\xff" * 2
  120. self.ip = "0.0.0.0"
  121. self.port = 0
  122. def deserialize(self, f):
  123. self.nServices = struct.unpack("<Q", f.read(8))[0]
  124. self.pchReserved = f.read(12)
  125. self.ip = socket.inet_ntoa(f.read(4))
  126. self.port = struct.unpack(">H", f.read(2))[0]
  127. def serialize(self):
  128. r = ""
  129. r += struct.pack("<Q", self.nServices)
  130. r += self.pchReserved
  131. r += socket.inet_aton(self.ip)
  132. r += struct.pack(">H", self.port)
  133. return r
  134. def __repr__(self):
  135. return "CAddress(nServices=%i ip=%s port=%i)" % (self.nServices, self.ip, self.port)
  136.  
  137. class CInv(object):
  138. typemap = {
  139. 0: "Error",
  140. 1: "TX",
  141. 2: "Block"}
  142. def __init__(self):
  143. self.type = 0
  144. self.hash = 0L
  145. def deserialize(self, f):
  146. self.type = struct.unpack("<i", f.read(4))[0]
  147. self.hash = deser_uint256(f)
  148. def serialize(self):
  149. r = ""
  150. r += struct.pack("<i", self.type)
  151. r += ser_uint256(self.hash)
  152. return r
  153. def __repr__(self):
  154. return "CInv(type=%s hash=%064x)" % (self.typemap[self.type], self.hash)
  155.  
  156. class CBlockLocator(object):
  157. def __init__(self):
  158. self.nVersion = MY_VERSION
  159. self.vHave = []
  160. def deserialize(self, f):
  161. self.nVersion = struct.unpack("<i", f.read(4))[0]
  162. self.vHave = deser_uint256_vector(f)
  163. def serialize(self):
  164. r = ""
  165. r += struct.pack("<i", self.nVersion)
  166. r += ser_uint256_vector(self.vHave)
  167. return r
  168. def __repr__(self):
  169. return "CBlockLocator(nVersion=%i vHave=%s)" % (self.nVersion, repr(self.vHave))
  170.  
  171. class COutPoint(object):
  172. def __init__(self):
  173. self.hash = 0
  174. self.n = 0
  175. def deserialize(self, f):
  176. self.hash = deser_uint256(f)
  177. self.n = struct.unpack("<I", f.read(4))[0]
  178. def serialize(self):
  179. r = ""
  180. r += ser_uint256(self.hash)
  181. r += struct.pack("<I", self.n)
  182. return r
  183. def __repr__(self):
  184. return "COutPoint(hash=%064x n=%i)" % (self.hash, self.n)
  185.  
  186. class CTxIn(object):
  187. def __init__(self):
  188. self.prevout = COutPoint()
  189. self.scriptSig = ""
  190. self.nSequence = 0
  191. def deserialize(self, f):
  192. self.prevout = COutPoint()
  193. self.prevout.deserialize(f)
  194. self.scriptSig = deser_string(f)
  195. self.nSequence = struct.unpack("<I", f.read(4))[0]
  196. def serialize(self):
  197. r = ""
  198. r += self.prevout.serialize()
  199. r += ser_string(self.scriptSig)
  200. r += struct.pack("<I", self.nSequence)
  201. return r
  202. def __repr__(self):
  203. return "CTxIn(prevout=%s scriptSig=%s nSequence=%i)" % (repr(self.prevout), binascii.hexlify(self.scriptSig), self.nSequence)
  204.  
  205. class CTxOut(object):
  206. def __init__(self):
  207. self.nValue = 0
  208. self.scriptPubKey = ""
  209. def deserialize(self, f):
  210. self.nValue = struct.unpack("<q", f.read(8))[0]
  211. self.scriptPubKey = deser_string(f)
  212. def serialize(self):
  213. r = ""
  214. r += struct.pack("<q", self.nValue)
  215. r += ser_string(self.scriptPubKey)
  216. return r
  217. def __repr__(self):
  218. return "CTxOut(nValue=%i.%08i scriptPubKey=%s)" % (self.nValue // 100000000, self.nValue % 100000000, binascii.hexlify(self.scriptPubKey))
  219.  
  220. class CTransaction(object):
  221. def __init__(self):
  222. self.nVersion = 1
  223. self.vin = []
  224. self.vout = []
  225. self.nLockTime = 0
  226. self.sha256 = None
  227. def deserialize(self, f):
  228. self.nVersion = struct.unpack("<i", f.read(4))[0]
  229. self.vin = deser_vector(f, CTxIn)
  230. self.vout = deser_vector(f, CTxOut)
  231. self.nLockTime = struct.unpack("<I", f.read(4))[0]
  232. def serialize(self):
  233. r = ""
  234. r += struct.pack("<i", self.nVersion)
  235. r += ser_vector(self.vin)
  236. r += ser_vector(self.vout)
  237. r += struct.pack("<I", self.nLockTime)
  238. return r
  239. def calc_sha256(self):
  240. if self.sha256 is None:
  241. self.sha256 = uint256_from_str(SHA256.new(SHA256.new(self.serialize()).digest()).digest())
  242. def is_valid(self):
  243. self.calc_sha256()
  244. for tout in self.vout:
  245. if tout.nValue < 0 or tout.nValue > 21000000L * 100000000L:
  246. return False
  247. return True
  248. def __repr__(self):
  249. return "CTransaction(nVersion=%i vin=%s vout=%s nLockTime=%i)" % (self.nVersion, repr(self.vin), repr(self.vout), self.nLockTime)
  250.  
  251. class CBlock(object):
  252. def __init__(self):
  253. self.nVersion = 1
  254. self.hashPrevBlock = 0
  255. self.hashMerkleRoot = 0
  256. self.nTime = 0
  257. self.nBits = 0
  258. self.nNonce = 0
  259. self.vtx = []
  260. self.sha256 = None
  261. def deserialize(self, f):
  262. self.nVersion = struct.unpack("<i", f.read(4))[0]
  263. self.hashPrevBlock = deser_uint256(f)
  264. self.hashMerkleRoot = deser_uint256(f)
  265. self.nTime = struct.unpack("<I", f.read(4))[0]
  266. self.nBits = struct.unpack("<I", f.read(4))[0]
  267. self.nNonce = struct.unpack("<I", f.read(4))[0]
  268. self.vtx = deser_vector(f, CTransaction)
  269. def serialize(self):
  270. r = ""
  271. r += struct.pack("<i", self.nVersion)
  272. r += ser_uint256(self.hashPrevBlock)
  273. r += ser_uint256(self.hashMerkleRoot)
  274. r += struct.pack("<I", self.nTime)
  275. r += struct.pack("<I", self.nBits)
  276. r += struct.pack("<I", self.nNonce)
  277. r += ser_vector(self.vtx)
  278. return r
  279. def calc_sha256(self):
  280. if self.sha256 is None:
  281. r = ""
  282. r += struct.pack("<i", self.nVersion)
  283. r += ser_uint256(self.hashPrevBlock)
  284. r += ser_uint256(self.hashMerkleRoot)
  285. r += struct.pack("<I", self.nTime)
  286. r += struct.pack("<I", self.nBits)
  287. r += struct.pack("<I", self.nNonce)
  288. self.sha256 = uint256_from_str(SHA256.new(SHA256.new(r).digest()).digest())
  289. def is_valid(self):
  290. self.calc_sha256()
  291. target = uint256_from_compact(self.nBits)
  292. if self.sha256 > target:
  293. return False
  294. hashes = []
  295. for tx in self.vtx:
  296. if not tx.is_valid():
  297. return False
  298. tx.calc_sha256()
  299. hashes.append(ser_uint256(tx.sha256))
  300. while len(hashes) > 1:
  301. newhashes = []
  302. for i in xrange(0, len(hashes), 2):
  303. i2 = min(i+1, len(hashes)-1)
  304. newhashes.append(SHA256.new(SHA256.new(hashes[i] + hashes[i2]).digest()).digest())
  305. hashes = newhashes
  306. if uint256_from_str(hashes[0]) != self.hashMerkleRoot:
  307. return False
  308. return True
  309. def __repr__(self):
  310. return "CBlock(nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x vtx=%s)" % (self.nVersion, self.hashPrevBlock, self.hashMerkleRoot, time.ctime(self.nTime), self.nBits, self.nNonce, repr(self.vtx))
  311.  
  312. class msg_version(object):
  313. command = "version"
  314. def __init__(self):
  315. self.nVersion = MY_VERSION
  316. self.nServices = 1
  317. self.nTime = time.time()
  318. self.addrTo = CAddress()
  319. self.addrFrom = CAddress()
  320. self.nNonce = random.getrandbits(64)
  321. self.strSubVer = MY_SUBVERSION
  322. self.nStartingHeight = -1
  323. def deserialize(self, f):
  324. self.nVersion = struct.unpack("<i", f.read(4))[0]
  325. if self.nVersion == 10300:
  326. self.nVersion = 300
  327. self.nServices = struct.unpack("<Q", f.read(8))[0]
  328. self.nTime = struct.unpack("<q", f.read(8))[0]
  329. self.addrTo = CAddress()
  330. self.addrTo.deserialize(f)
  331. if self.nVersion >= 106:
  332. self.addrFrom = CAddress()
  333. self.addrFrom.deserialize(f)
  334. self.nNonce = struct.unpack("<Q", f.read(8))[0]
  335. self.strSubVer = deser_string(f)
  336. if self.nVersion >= 209:
  337. self.nStartingHeight = struct.unpack("<i", f.read(4))[0]
  338. else:
  339. self.nStartingHeight = None
  340. else:
  341. self.addrFrom = None
  342. self.nNonce = None
  343. self.strSubVer = None
  344. self.nStartingHeight = None
  345. def serialize(self):
  346. r = ""
  347. r += struct.pack("<i", self.nVersion)
  348. r += struct.pack("<Q", self.nServices)
  349. r += struct.pack("<q", self.nTime)
  350. r += self.addrTo.serialize()
  351. r += self.addrFrom.serialize()
  352. r += struct.pack("<Q", self.nNonce)
  353. r += ser_string(self.strSubVer)
  354. r += struct.pack("<i", self.nStartingHeight)
  355. return r
  356. def __repr__(self):
  357. return "msg_version(nVersion=%i nServices=%i nTime=%s addrTo=%s addrFrom=%s nNonce=0x%016X strSubVer=%s nStartingHeight=%i)" % (self.nVersion, self.nServices, time.ctime(self.nTime), repr(self.addrTo), repr(self.addrFrom), self.nNonce, self.strSubVer, self.nStartingHeight)
  358.  
  359. class msg_verack(object):
  360. command = "verack"
  361. def __init__(self):
  362. pass
  363. def deserialize(self, f):
  364. pass
  365. def serialize(self):
  366. return ""
  367. def __repr__(self):
  368. return "msg_verack()"
  369.  
  370. class msg_addr(object):
  371. command = "addr"
  372. def __init__(self):
  373. self.addrs = []
  374. def deserialize(self, f):
  375. self.addrs = deser_vector(f, CAddress)
  376. def serialize(self):
  377. return ser_vector(self.addrs)
  378. def __repr__(self):
  379. return "msg_addr(addrs=%s)" % (repr(self.addrs))
  380.  
  381. class msg_inv(object):
  382. command = "inv"
  383. def __init__(self):
  384. self.inv = []
  385. def deserialize(self, f):
  386. self.inv = deser_vector(f, CInv)
  387. def serialize(self):
  388. return ser_vector(self.inv)
  389. def __repr__(self):
  390. return "msg_inv(inv=%s)" % (repr(self.inv))
  391.  
  392. class msg_getdata(object):
  393. command = "getdata"
  394. def __init__(self):
  395. self.inv = []
  396. def deserialize(self, f):
  397. self.inv = deser_vector(f, CInv)
  398. def serialize(self):
  399. return ser_vector(self.inv)
  400. def __repr__(self):
  401. return "msg_getdata(inv=%s)" % (repr(self.inv))
  402.  
  403. class msg_getblocks(object):
  404. command = "getblocks"
  405. def __init__(self):
  406. self.locator = CBlockLocator()
  407. self.hashstop = 0L
  408. def deserialize(self, f):
  409. self.locator = CBlockLocator()
  410. self.locator.deserialize(f)
  411. self.hashstop = deser_uint256(f)
  412. def serialize(self):
  413. r = ""
  414. r += self.locator.serialize()
  415. r += ser_uint256(self.hashstop)
  416. return r
  417. def __repr__(self):
  418. return "msg_getblocks(locator=%s hashstop=%064x)" % (repr(self.locator), self.hashstop)
  419.  
  420. class msg_tx(object):
  421. command = "tx"
  422. def __init__(self):
  423. self.tx = CTransaction()
  424. def deserialize(self, f):
  425. self.tx.deserialize(f)
  426. def serialize(self):
  427. return self.tx.serialize()
  428. def __repr__(self):
  429. return "msg_tx(tx=%s)" % (repr(self.tx))
  430.  
  431. class msg_block(object):
  432. command = "block"
  433. def __init__(self):
  434. self.block = CBlock()
  435. def deserialize(self, f):
  436. self.block.deserialize(f)
  437. def serialize(self):
  438. return self.block.serialize()
  439. def __repr__(self):
  440. return "msg_block(block=%s)" % (repr(self.block))
  441.  
  442. class msg_getaddr(object):
  443. command = "getaddr"
  444. def __init__(self):
  445. pass
  446. def deserialize(self, f):
  447. pass
  448. def serialize(self):
  449. return ""
  450. def __repr__(self):
  451. return "msg_getaddr()"
  452.  
  453. #msg_checkorder
  454. #msg_submitorder
  455. #msg_reply
  456.  
  457. class msg_ping(object):
  458. command = "ping"
  459. def __init__(self):
  460. pass
  461. def deserialize(self, f):
  462. pass
  463. def serialize(self):
  464. return ""
  465. def __repr__(self):
  466. return "msg_ping()"
  467.  
  468.  
  469.  
  470.  
  471.  
  472. class NodeConn(asyncore.dispatcher):
  473. messagemap = {
  474. "version": msg_version,
  475. "verack": msg_verack,
  476. "addr": msg_addr,
  477. "inv": msg_inv,
  478. "getdata": msg_getdata,
  479. "getblocks": msg_getblocks,
  480. "tx": msg_tx,
  481. "block": msg_block,
  482. "getaddr": msg_getaddr,
  483. "ping": msg_ping
  484. }
  485. def __init__(self, dstaddr, dstport):
  486. asyncore.dispatcher.__init__(self)
  487. self.dstaddr = dstaddr
  488. self.dstport = dstport
  489. self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
  490. self.sendbuf = ""
  491. self.recvbuf = ""
  492. self.ver_send = 0
  493. self.ver_recv = 0
  494. self.last_sent = 0
  495. self.state = "connecting"
  496. print "connecting"
  497. try:
  498. self.connect((dstaddr, dstport))
  499. except:
  500. self.handle_close()
  501. def handle_connect(self):
  502. print "connected"
  503. self.state = "connected"
  504. #send version msg
  505. t = msg_version()
  506. t.addrTo.ip = self.dstaddr
  507. t.addrTo.port = self.dstport
  508. t.addrFrom.ip = "0.0.0.0"
  509. t.addrFrom.port = 0
  510. self.send_message(t)
  511. def handle_close(self):
  512. print "close"
  513. self.state = "closed"
  514. self.recvbuf = ""
  515. self.sendbuf = ""
  516. try:
  517. self.close()
  518. except:
  519. pass
  520. def handle_read(self):
  521. try:
  522. t = self.recv(8192)
  523. except:
  524. self.handle_close()
  525. return
  526. if len(t) == 0:
  527. self.handle_close()
  528. return
  529. self.recvbuf += t
  530. self.got_data()
  531. def readable(self):
  532. return True
  533. def writable(self):
  534. return (len(self.sendbuf) > 0)
  535. def handle_write(self):
  536. try:
  537. sent = self.send(self.sendbuf)
  538. except:
  539. self.handle_close()
  540. return
  541. self.sendbuf = self.sendbuf[sent:]
  542. def got_data(self):
  543. while True:
  544. if len(self.recvbuf) < 4:
  545. return
  546. if self.recvbuf[:4] != "\xf9\xbe\xb4\xd9":
  547. raise ValueError("got garbage %s" % repr(self.recvbuf))
  548. if self.ver_recv < 209:
  549. if len(self.recvbuf) < 4 + 12 + 4:
  550. return
  551. command = self.recvbuf[4:4+12].split("\x00", 1)[0]
  552. msglen = struct.unpack("<i", self.recvbuf[4+12:4+12+4])[0]
  553. checksum = None
  554. if len(self.recvbuf) < 4 + 12 + 4 + msglen:
  555. return
  556. msg = self.recvbuf[4+12+4:4+12+4+msglen]
  557. self.recvbuf = self.recvbuf[4+12+4+msglen:]
  558. else:
  559. if len(self.recvbuf) < 4 + 12 + 4 + 4:
  560. return
  561. command = self.recvbuf[4:4+12].split("\x00", 1)[0]
  562. msglen = struct.unpack("<i", self.recvbuf[4+12:4+12+4])[0]
  563. checksum = self.recvbuf[4+12+4:4+12+4+4]
  564. if len(self.recvbuf) < 4 + 12 + 4 + 4 + msglen:
  565. return
  566. msg = self.recvbuf[4+12+4+4:4+12+4+4+msglen]
  567. th = SHA256.new(msg).digest()
  568. h = SHA256.new(th).digest()
  569. if checksum != h[:4]:
  570. raise ValueError("got bad checksum %s" % repr(self.recvbuf))
  571. self.recvbuf = self.recvbuf[4+12+4+4+msglen:]
  572. if command in self.messagemap:
  573. f = cStringIO.StringIO(msg)
  574. t = self.messagemap[command]()
  575. t.deserialize(f)
  576. self.got_message(t)
  577. else:
  578. print "UNKNOWN COMMAND", command, repr(msg)
  579. def send_message(self, message):
  580. if self.state != "connected":
  581. return
  582. print "send %s" % repr(message)
  583. command = message.command
  584. data = message.serialize()
  585. tmsg = "\xf9\xbe\xb4\xd9"
  586. tmsg += command
  587. tmsg += "\x00" * (12 - len(command))
  588. tmsg += struct.pack("<I", len(data))
  589. if self.ver_send >= 209:
  590. th = SHA256.new(data).digest()
  591. h = SHA256.new(th).digest()
  592. tmsg += h[:4]
  593. tmsg += data
  594. self.sendbuf += tmsg
  595. self.last_sent = time.time()
  596. def got_message(self, message):
  597. if self.last_sent + 30 * 60 < time.time():
  598. self.send_message(msg_ping())
  599. print "recv %s" % repr(message)
  600. if message.command == "version":
  601. if message.nVersion >= 209:
  602. self.send_message(msg_verack())
  603. self.ver_send = min(MY_VERSION, message.nVersion)
  604. if message.nVersion < 209:
  605. self.ver_recv = self.ver_send
  606. elif message.command == "verack":
  607. self.ver_recv = self.ver_send
  608. elif message.command == "inv":
  609. want = msg_getdata()
  610. for i in message.inv:
  611. if i.type == 1:
  612. want.inv.append(i)
  613. elif i.type == 2:
  614. want.inv.append(i)
  615. if len(want.inv):
  616. self.send_message(want)
  617. elif message.command == "tx":
  618. if not message.tx.is_valid():
  619. print "invalid TX"
  620. elif message.command == "block":
  621. if not message.block.is_valid():
  622. print "invalid block"
  623.  
  624. c = NodeConn("127.0.0.1", 8333)
  625. asyncore.loop()
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!