# Copyright (C) 2012-2015 The python-bitcoinlib developers # # This file is part of python-bitcoinlib. # # It is subject to the license terms in the LICENSE file found in the top-level # directory of this distribution. # # No part of python-bitcoinlib, including this file, may be copied, modified, # propagated, or distributed except according to the terms contained in the # LICENSE file. from __future__ import absolute_import, division, print_function, unicode_literals import hashlib import random import struct import time # Py3 compatibility import sys if sys.version > '3': _bchr = lambda x: bytes([x]) _bord = lambda x: x[0] from io import BytesIO as _BytesIO else: _bchr = chr _bord = ord from cStringIO import StringIO as _BytesIO # Bad practice, so we have a __all__ at the end; this should be cleaned up # later. from bitcoin.core import * from bitcoin.core.serialize import * from bitcoin.net import * import bitcoin MSG_TX = 1 MSG_BLOCK = 2 MSG_FILTERED_BLOCK = 3 class MsgSerializable(Serializable): def __init__(self, protover=PROTO_VERSION): self.protover = protover def msg_ser(self, f): raise NotImplementedError @classmethod def msg_deser(cls, f, protover=PROTO_VERSION): raise NotImplementedError def to_bytes(self): f = _BytesIO() self.msg_ser(f) body = f.getvalue() res = bitcoin.params.MESSAGE_START res += self.command res += b"\x00" * (12 - len(self.command)) res += struct.pack(b"<I", len(body)) # add checksum th = hashlib.sha256(body).digest() h = hashlib.sha256(th).digest() res += h[:4] res += body return res @classmethod def from_bytes(cls, b, protover=PROTO_VERSION): f = _BytesIO(b) return MsgSerializable.stream_deserialize(f, protover=protover) @classmethod def stream_deserialize(cls, f, protover=PROTO_VERSION): recvbuf = ser_read(f, 4 + 12 + 4 + 4) # check magic if recvbuf[:4] != bitcoin.params.MESSAGE_START: raise ValueError("Invalid message start '%s', expected '%s'" % (b2x(recvbuf[:4]), b2x(bitcoin.params.MESSAGE_START))) # remaining header fields: command, msg length, checksum command = recvbuf[4:4+12].split(b"\x00", 1)[0] msglen = struct.unpack(b"<i", recvbuf[4+12:4+12+4])[0] checksum = recvbuf[4+12+4:4+12+4+4] # read message body recvbuf += ser_read(f, msglen) msg = recvbuf[4+12+4+4:4+12+4+4+msglen] th = hashlib.sha256(msg).digest() h = hashlib.sha256(th).digest() if checksum != h[:4]: raise ValueError("got bad checksum %s" % repr(recvbuf)) recvbuf = recvbuf[4+12+4+4+msglen:] if command in messagemap: cls = messagemap[command] # print("Going to deserialize '%s'" % msg) return cls.msg_deser(_BytesIO(msg)) else: print("Command '%s' not in messagemap" % repr(command)) return None def stream_serialize(self, f): data = self.to_bytes() f.write(data) class msg_version(MsgSerializable): command = b"version" def __init__(self, protover=PROTO_VERSION): super(msg_version, self).__init__(protover) self.nVersion = protover self.nServices = 1 self.nTime = int(time.time()) self.addrTo = CAddress(PROTO_VERSION) self.addrFrom = CAddress(PROTO_VERSION) self.nNonce = random.getrandbits(64) self.strSubVer = (b'/python-bitcoinlib:' + bitcoin.__version__.encode('ascii') + b'/') self.nStartingHeight = -1 @classmethod def msg_deser(cls, f, protover=PROTO_VERSION): c = cls() c.nVersion = struct.unpack(b"<i", ser_read(f, 4))[0] if c.nVersion == 10300: c.nVersion = 300 c.nServices = struct.unpack(b"<Q", ser_read(f, 8))[0] c.nTime = struct.unpack(b"<q", ser_read(f, 8))[0] c.addrTo = CAddress.stream_deserialize(f, True) if c.nVersion >= 106: c.addrFrom = CAddress.stream_deserialize(f, True) c.nNonce = struct.unpack(b"<Q", ser_read(f, 8))[0] c.strSubVer = VarStringSerializer.stream_deserialize(f) if c.nVersion >= 209: c.nStartingHeight = struct.unpack(b"<i", ser_read(f,4))[0] else: c.nStartingHeight = None else: c.addrFrom = None c.nNonce = None c.strSubVer = None c.nStartingHeight = None return c def msg_ser(self, f): f.write(struct.pack(b"<i", self.nVersion)) f.write(struct.pack(b"<Q", self.nServices)) f.write(struct.pack(b"<q", self.nTime)) self.addrTo.stream_serialize(f, True) self.addrFrom.stream_serialize(f, True) f.write(struct.pack(b"<Q", self.nNonce)) VarStringSerializer.stream_serialize(self.strSubVer, f) f.write(struct.pack(b"<i", self.nStartingHeight)) def __repr__(self): 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) class msg_verack(MsgSerializable): command = b"verack" def __init__(self, protover=PROTO_VERSION): super(msg_verack, self).__init__(protover) self.protover = protover @classmethod def msg_deser(cls, f, protover=PROTO_VERSION): return cls() def msg_ser(self, f): f.write(b"") def __repr__(self): return "msg_verack()" class msg_addr(MsgSerializable): command = b"addr" def __init__(self, protover=PROTO_VERSION): super(msg_addr, self).__init__(protover) self.addrs = [] @classmethod def msg_deser(cls, f, protover=PROTO_VERSION): c = cls() c.addrs = VectorSerializer.stream_deserialize(CAddress, f) return c def msg_ser(self, f): VectorSerializer.stream_serialize(CAddress, self.addrs, f) def __repr__(self): return "msg_addr(addrs=%s)" % (repr(self.addrs)) class msg_alert(MsgSerializable): command = b"alert" def __init__(self, protover=PROTO_VERSION): super(msg_alert, self).__init__(protover) self.alert = CAlert() @classmethod def msg_deser(cls, f, protover=PROTO_VERSION): c = cls() c.alert = CAlert.stream_deserialize(f) return c def msg_ser(self, f): self.alert.stream_serialize(f) def __repr__(self): return "msg_alert(alert=%s)" % (repr(self.alert), ) class msg_inv(MsgSerializable): command = b"inv" def __init__(self, protover=PROTO_VERSION): super(msg_inv, self).__init__(protover) self.inv = [] @classmethod def msg_deser(cls, f, protover=PROTO_VERSION): c = cls() c.inv = VectorSerializer.stream_deserialize(CInv, f) return c def msg_ser(self, f): VectorSerializer.stream_serialize(CInv, self.inv, f) def __repr__(self): return "msg_inv(inv=%s)" % (repr(self.inv)) class msg_getdata(MsgSerializable): command = b"getdata" def __init__(self, protover=PROTO_VERSION): super(msg_getdata, self).__init__(protover) self.inv = [] @classmethod def msg_deser(cls, f, protover=PROTO_VERSION): c = cls() c.inv = VectorSerializer.stream_deserialize(CInv, f) return c def msg_ser(self, f): VectorSerializer.stream_serialize(CInv, self.inv, f) def __repr__(self): return "msg_getdata(inv=%s)" % (repr(self.inv)) class msg_notfound(MsgSerializable): command = b"notfound" def __init__(self, protover=PROTO_VERSION): super(msg_notfound, self).__init__(protover) self.inv = [] @classmethod def msg_deser(cls, f, protover=PROTO_VERSION): c = cls() c.inv = VectorSerializer.stream_deserialize(CInv, f) return c def msg_ser(self, f): VectorSerializer.stream_serialize(CInv, self.inv, f) def __repr__(self): return "msg_notfound(inv=%s)" % (repr(self.inv)) class msg_getblocks(MsgSerializable): command = b"getblocks" def __init__(self, protover=PROTO_VERSION): super(msg_getblocks, self).__init__(protover) self.locator = CBlockLocator() self.hashstop = b'\x00'*32 @classmethod def msg_deser(cls, f, protover=PROTO_VERSION): c = cls() c.locator = CBlockLocator.stream_deserialize(f) c.hashstop = ser_read(f, 32) return c def msg_ser(self, f): self.locator.stream_serialize(f) f.write(self.hashstop) def __repr__(self): return "msg_getblocks(locator=%s hashstop=%s)" % (repr(self.locator), b2x(self.hashstop)) class msg_getheaders(MsgSerializable): command = b"getheaders" def __init__(self, protover=PROTO_VERSION): super(msg_getheaders, self).__init__(protover) self.locator = CBlockLocator() self.hashstop = b'\x00'*32 @classmethod def msg_deser(cls, f, protover=PROTO_VERSION): c = cls() c.locator = CBlockLocator.stream_deserialize(f) c.hashstop = ser_read(f, 32) return c def msg_ser(self, f): self.locator.stream_serialize(f) f.write(self.hashstop) def __repr__(self): return "msg_getheaders(locator=%s hashstop=%s)" % (repr(self.locator), b2x(self.hashstop)) class msg_headers(MsgSerializable): command = b"headers" def __init__(self, protover=PROTO_VERSION): super(msg_headers, self).__init__(protover) self.headers = [] @classmethod def msg_deser(cls, f, protover=PROTO_VERSION): c = cls() c.headers = VectorSerializer.stream_deserialize(CBlock, f) return c def msg_ser(self, f): VectorSerializer.stream_serialize(CBlock, self.headers, f) def __repr__(self): return "msg_headers(headers=%s)" % (repr(self.headers)) class msg_tx(MsgSerializable): command = b"tx" def __init__(self, protover=PROTO_VERSION): super(msg_tx, self).__init__(protover) self.tx = CTransaction() @classmethod def msg_deser(cls, f, protover=PROTO_VERSION): c = cls() c.tx = CTransaction.stream_deserialize(f) return c def msg_ser(self, f): self.tx.stream_serialize(f) def __repr__(self): return "msg_tx(tx=%s)" % (repr(self.tx)) class msg_block(MsgSerializable): command = b"block" def __init__(self, protover=PROTO_VERSION): super(msg_block, self).__init__(protover) self.block = CBlock() @classmethod def msg_deser(cls, f, protover=PROTO_VERSION): c = cls() c.block = CBlock.stream_deserialize(f) return c def msg_ser(self, f): self.block.stream_serialize(f) def __repr__(self): return "msg_block(block=%s)" % (repr(self.block)) class msg_getaddr(MsgSerializable): command = b"getaddr" def __init__(self, protover=PROTO_VERSION): super(msg_getaddr, self).__init__(protover) @classmethod def msg_deser(cls, f, protover=PROTO_VERSION): return cls() def msg_ser(self, f): pass def __repr__(self): return "msg_getaddr()" class msg_ping(MsgSerializable): command = b"ping" def __init__(self, protover=PROTO_VERSION, nonce=0): super(msg_ping, self).__init__(protover) self.nonce = nonce @classmethod def msg_deser(cls, f, protover=PROTO_VERSION): c = cls() c.nonce = struct.unpack(b"<Q", ser_read(f, 8))[0] return c def msg_ser(self, f): f.write(struct.pack(b"<Q", self.nonce)) def __repr__(self): return "msg_ping(0x%x)" % (self.nonce,) class msg_pong(MsgSerializable): command = b"pong" def __init__(self, protover=PROTO_VERSION, nonce=0): super(msg_pong, self).__init__(protover) self.nonce = nonce @classmethod def msg_deser(cls, f, protover=PROTO_VERSION): c = cls() c.nonce = struct.unpack(b"<Q", ser_read(f,8))[0] return c def msg_ser(self, f): f.write(struct.pack(b"<Q", self.nonce)) def __repr__(self): return "msg_pong(0x%x)" % (self.nonce,) class msg_reject(MsgSerializable): command = b"reject" def __init__(self, protover=PROTO_VERSION): super(msg_reject, self).__init__(protover) self.message = b'(Message Unitialized)' self.ccode = b'\0' self.reason = b'(Reason Unitialized)' @classmethod def msg_deser(cls, f, protover=PROTO_VERSION): c = cls() c.message = VarStringSerializer.stream_deserialize(f) c.ccode = struct.unpack(b"<c", ser_read(f,1))[0] c.reason = VarStringSerializer.stream_deserialize(f) return c def msg_ser(self, f): VarStringSerializer.stream_serialize(self.message, f) f.write(struct.pack(b"<c", self.ccode)) VarStringSerializer.stream_serialize(self.reason, f) def __repr__(self): return "msg_reject(messsage=%s, ccode=%s, reason=%s)" % (self.message, self.ccode, self.reason) class msg_mempool(MsgSerializable): command = b"mempool" def __init__(self, protover=PROTO_VERSION): super(msg_mempool, self).__init__(protover) @classmethod def msg_deser(cls, f, protover=PROTO_VERSION): return cls() def msg_ser(self, f): pass def __repr__(self): return "msg_mempool()" msg_classes = [msg_version, msg_verack, msg_addr, msg_alert, msg_inv, msg_getdata, msg_notfound, msg_getblocks, msg_getheaders, msg_headers, msg_tx, msg_block, msg_getaddr, msg_ping, msg_pong, msg_reject, msg_mempool] messagemap = {} for cls in msg_classes: messagemap[cls.command] = cls __all__ = ( 'MSG_TX', 'MSG_BLOCK', 'MSG_FILTERED_BLOCK', 'MsgSerializable', 'msg_version', 'msg_verack', 'msg_addr', 'msg_alert', 'msg_inv', 'msg_getdata', 'msg_getblocks', 'msg_getheaders', 'msg_headers', 'msg_tx', 'msg_block', 'msg_getaddr', 'msg_ping', 'msg_pong', 'msg_mempool', 'msg_classes', 'messagemap', )