def run(*args):
TESTNET = args[0]
# database
db = Database(TESTNET)
# key generation
keys = KeyChain(db)
# logging
# TODO: prune this log file and prevent it from getting too large?
logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log")
log.addObserver(log.FileLogObserver(logFile).emit)
log.startLogging(sys.stdout)
# stun
# TODO: accept port from command line
port = 18467 if not TESTNET else 28467
print "Finding NAT Type.."
# TODO: maintain a list of backup STUN servers and try them if ours fails
response = stun.get_ip_info(stun_host="seed.openbazaar.org", source_port=port)
print "%s on %s:%s" % (response[0], response[1], response[2])
ip_address = response[1]
port = response[2]
# TODO: try UPnP if restricted NAT
# TODO: maintain open connection to seed node if STUN/UPnP fail
# TODO: use TURN if symmetric NAT
def on_bootstrap_complete(resp):
mlistener = MessageListenerImpl(ws_factory, db)
mserver.get_messages(mlistener)
mserver.protocol.add_listener(mlistener)
nlistener = NotificationListenerImpl(ws_factory, db)
mserver.protocol.add_listener(nlistener)
# TODO: after bootstrap run through any pending contracts and see if the bitcoin address
# has been funded, if not listen on the address and start the 10 minute delete timer.
protocol = OpenBazaarProtocol((ip_address, port), testnet=TESTNET)
# kademlia
node = Node(keys.guid, ip_address, port, signed_pubkey=keys.guid_signed_pubkey)
try:
kserver = Server.loadState(DATA_FOLDER + 'cache.pickle', ip_address, port, protocol, db,
on_bootstrap_complete, storage=PersistentStorage(db.DATABASE))
except Exception:
kserver = Server(node, db, KSIZE, ALPHA, storage=PersistentStorage(db.DATABASE))
kserver.protocol.connect_multiplexer(protocol)
kserver.bootstrap(
kserver.querySeed("seed.openbazaar.org:8080",
"5b44be5c18ced1bc9400fe5e79c8ab90204f06bebacc04dd9c70a95eaca6e117"))\
.addCallback(on_bootstrap_complete)
# TODO: load seeds from config file
kserver.saveStateRegularly(DATA_FOLDER + 'cache.pickle', 10)
protocol.register_processor(kserver.protocol)
# market
mserver = network.Server(kserver, keys.signing_key, db)
mserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(mserver.protocol)
reactor.listenUDP(port, protocol)
# websockets api
ws_factory = WSFactory("ws://127.0.0.1:18466", mserver, kserver)
ws_factory.protocol = WSProtocol
ws_factory.setProtocolOptions(allowHixie76=True)
listenWS(ws_factory)
webdir = File(".")
web = Site(webdir)
reactor.listenTCP(9000, web, interface="127.0.0.1")
# rest api
api = OpenBazaarAPI(mserver, kserver, protocol)
site = Site(api, timeout=None)
reactor.listenTCP(18469, site, interface="127.0.0.1")
# TODO: add optional SSL on rest and websocket servers
# blockchain
# TODO: listen on the libbitcoin heartbeat port instead fetching height
def height_fetched(ec, height):
# TODO: re-broadcast any unconfirmed txs in the db using height to find confirmation status
print "Libbitcoin server online"
try:
timeout.cancel()
except Exception:
pass
def timeout(client):
print "Libbitcoin server offline"
client = None
if TESTNET:
libbitcoin_client = LibbitcoinClient("tcp://libbitcoin2.openbazaar.org:9091")
else:
libbitcoin_client = LibbitcoinClient("tcp://libbitcoin1.openbazaar.org:9091")
# TODO: load libbitcoin server url from config file
libbitcoin_client.fetch_last_height(height_fetched)
timeout = reactor.callLater(5, timeout, libbitcoin_client)
protocol.set_servers(ws_factory, libbitcoin_client)
reactor.run()
class KademliaProtocolTest(unittest.TestCase):
def setUp(self):
self.public_ip = '123.45.67.89'
self.port = 12345
self.own_addr = (self.public_ip, self.port)
self.addr1 = ('132.54.76.98', 54321)
self.addr2 = ('231.76.45.89', 15243)
self.clock = task.Clock()
connection.REACTOR.callLater = self.clock.callLater
self.proto_mock = mock.Mock(spec_set=rudp.ConnectionMultiplexer)
self.handler_mock = mock.Mock(spec_set=connection.Handler)
self.con = connection.Connection(
self.proto_mock,
self.handler_mock,
self.own_addr,
self.addr1
)
valid_key = "1a5c8e67edb8d279d1ae32fa2da97e236b95e95c837dc8c3c7c2ff7a7cc29855"
self.signing_key = nacl.signing.SigningKey(valid_key, encoder=nacl.encoding.HexEncoder)
verify_key = self.signing_key.verify_key
signed_pubkey = self.signing_key.sign(str(verify_key))
h = nacl.hash.sha512(signed_pubkey)
self.storage = ForgetfulStorage()
self.node = Node(unhexlify(h[:40]), self.public_ip, self.port, signed_pubkey, True)
self.db = datastore.Database(filepath="test.db")
self.protocol = KademliaProtocol(self.node, self.storage, 20, self.db)
self.wire_protocol = OpenBazaarProtocol(self.own_addr)
self.wire_protocol.register_processor(self.protocol)
self.protocol.connect_multiplexer(self.wire_protocol)
self.handler = self.wire_protocol.ConnHandler([self.protocol], self.wire_protocol)
self.handler.connection = self.con
transport = mock.Mock(spec_set=udp.Port)
ret_val = address.IPv4Address('UDP', self.public_ip, self.port)
transport.attach_mock(mock.Mock(return_value=ret_val), 'getHost')
self.wire_protocol.makeConnection(transport)
def tearDown(self):
if self.con.state != connection.State.SHUTDOWN:
self.con.shutdown()
self.wire_protocol.shutdown()
os.remove("test.db")
def test_invalid_datagram(self):
self.assertFalse(self.handler.receive_message("hi"))
self.assertFalse(self.handler.receive_message("hihihihihihihihihihihihihihihihihihihihih"))
def test_rpc_ping(self):
self._connecting_to_connected()
m = message.Message()
m.messageID = digest("msgid")
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("PING")
m.testnet = False
data = m.SerializeToString()
m.arguments.append(self.protocol.sourceNode.getProto().SerializeToString())
expected_message = m.SerializeToString()
self.handler.receive_message(data)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
m_calls = self.proto_mock.send_datagram.call_args_list
sent_packet = packet.Packet.from_bytes(self.proto_mock.send_datagram.call_args_list[0][0][0])
received_message = sent_packet.payload
self.assertEqual(received_message, expected_message)
self.assertEqual(len(m_calls), 2)
def test_rpc_store(self):
self._connecting_to_connected()
m = message.Message()
m.messageID = digest("msgid")
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("STORE")
m.testnet = False
m.arguments.extend([digest("Keyword"), "Key", self.protocol.sourceNode.getProto().SerializeToString()])
data = m.SerializeToString()
del m.arguments[-3:]
m.arguments.append("True")
expected_message = m.SerializeToString()
self.handler.receive_message(data)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
m_calls = self.proto_mock.send_datagram.call_args_list
sent_packet = packet.Packet.from_bytes(self.proto_mock.send_datagram.call_args_list[0][0][0])
received_message = sent_packet.payload
self.assertEqual(received_message, expected_message)
self.assertEqual(len(m_calls), 2)
self.assertTrue(
self.storage.getSpecific(digest("Keyword"), "Key") ==
self.protocol.sourceNode.getProto().SerializeToString())
def test_bad_rpc_store(self):
r = self.protocol.rpc_store(self.node, 'testkeyword', 'kw', 'val')
self.assertEqual(r, ['False'])
def test_rpc_delete(self):
self._connecting_to_connected()
# Set a keyword to store
m = message.Message()
m.messageID = digest("msgid")
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("STORE")
m.testnet = False
m.arguments.extend([digest("Keyword"), "Key", self.protocol.sourceNode.getProto().SerializeToString()])
data = m.SerializeToString()
del m.arguments[-3:]
m.arguments.append("True")
expected_message1 = m.SerializeToString()
self.handler.receive_message(data)
self.assertTrue(
self.storage.getSpecific(digest("Keyword"), "Key") ==
self.protocol.sourceNode.getProto().SerializeToString())
# Test bad signature
m = message.Message()
m.messageID = digest("msgid")
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("DELETE")
m.testnet = False
m.arguments.extend([digest("Keyword"), "Key", "Bad Signature"])
data = m.SerializeToString()
del m.arguments[-3:]
m.arguments.append("False")
expected_message2 = m.SerializeToString()
self.handler.receive_message(data)
self.assertTrue(
self.storage.getSpecific(digest("Keyword"), "Key") ==
self.protocol.sourceNode.getProto().SerializeToString())
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
sent_packets = tuple(
packet.Packet.from_bytes(call[0][0])
for call in self.proto_mock.send_datagram.call_args_list
)
self.assertEqual(sent_packets[0].payload, expected_message1)
self.assertEqual(sent_packets[1].payload, expected_message2)
self.proto_mock.send_datagram.call_args_list = []
# Test good signature
m = message.Message()
m.messageID = digest("msgid")
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("DELETE")
m.testnet = False
m.arguments.extend([digest("Keyword"), "Key", self.signing_key.sign("Key")[:64]])
data = m.SerializeToString()
del m.arguments[-3:]
m.arguments.append("True")
expected_message3 = m.SerializeToString()
self.handler.receive_message(data)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
sent_packet = packet.Packet.from_bytes(self.proto_mock.send_datagram.call_args_list[0][0][0])
self.assertEqual(sent_packet.payload, expected_message3)
self.assertTrue(self.storage.getSpecific(digest("Keyword"), "Key") is None)
def test_rpc_stun(self):
self._connecting_to_connected()
m = message.Message()
m.messageID = digest("msgid")
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("STUN")
m.testnet = False
data = m.SerializeToString()
m.arguments.extend([self.public_ip, str(self.port)])
expected_message = m.SerializeToString()
self.handler.receive_message(data)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
m_calls = self.proto_mock.send_datagram.call_args_list
sent_packet = packet.Packet.from_bytes(self.proto_mock.send_datagram.call_args_list[0][0][0])
received_message = sent_packet.payload
a = message.Message()
a.ParseFromString(received_message)
self.assertEqual(received_message, expected_message)
self.assertEqual(len(m_calls), 2)
def test_rpc_find_node(self):
self._connecting_to_connected()
node1 = Node(digest("id1"), "127.0.0.1", 12345, digest("key1"))
node2 = Node(digest("id2"), "127.0.0.1", 22222, digest("key2"))
node3 = Node(digest("id3"), "127.0.0.1", 77777, digest("key3"))
self.protocol.router.addContact(node1)
self.protocol.router.addContact(node2)
self.protocol.router.addContact(node3)
m = message.Message()
m.messageID = digest("msgid")
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("FIND_NODE")
m.testnet = False
m.arguments.append(digest("nodetofind"))
data = m.SerializeToString()
del m.arguments[-1]
m.arguments.extend([node2.getProto().SerializeToString(), node1.getProto().SerializeToString(),
node3.getProto().SerializeToString()])
expected_message = m.SerializeToString()
self.handler.receive_message(data)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
m_calls = self.proto_mock.send_datagram.call_args_list
sent_packet = packet.Packet.from_bytes(self.proto_mock.send_datagram.call_args_list[0][0][0])
received_message = sent_packet.payload
a = message.Message()
a.ParseFromString(received_message)
self.assertEqual(received_message, expected_message)
self.assertEqual(len(m_calls), 2)
def test_rpc_find_value(self):
self._connecting_to_connected()
# Set a value to find
m = message.Message()
m.messageID = digest("msgid")
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("STORE")
m.arguments.extend([digest("Keyword"), "Key", self.protocol.sourceNode.getProto().SerializeToString()])
data = m.SerializeToString()
self.handler.receive_message(data)
self.assertTrue(
self.storage.getSpecific(digest("Keyword"), "Key") ==
self.protocol.sourceNode.getProto().SerializeToString())
# Send the find_value rpc
m = message.Message()
m.messageID = digest("msgid")
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("FIND_VALUE")
m.testnet = False
m.arguments.append(digest("Keyword"))
data = m.SerializeToString()
self.handler.receive_message(data)
del m.arguments[-1]
value = objects.Value()
value.valueKey = "Key"
value.serializedData = self.protocol.sourceNode.getProto().SerializeToString()
m.arguments.append("value")
m.arguments.append(value.SerializeToString())
expected_message = m.SerializeToString()
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
m_calls = self.proto_mock.send_datagram.call_args_list
sent_packets = tuple(
packet.Packet.from_bytes(call[0][0])
for call in self.proto_mock.send_datagram.call_args_list
)
received_message = sent_packets[1].payload
self.assertEqual(received_message, expected_message)
self.assertEqual(len(m_calls), 3)
def test_rpc_find_without_value(self):
self._connecting_to_connected()
node1 = Node(digest("id1"), "127.0.0.1", 12345, digest("key1"))
node2 = Node(digest("id2"), "127.0.0.1", 22222, digest("key2"))
node3 = Node(digest("id3"), "127.0.0.1", 77777, digest("key3"))
self.protocol.router.addContact(node1)
self.protocol.router.addContact(node2)
self.protocol.router.addContact(node3)
m = message.Message()
m.messageID = digest("msgid")
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("FIND_VALUE")
m.testnet = False
m.arguments.append(digest("Keyword"))
data = m.SerializeToString()
self.handler.receive_message(data)
del m.arguments[-1]
m.arguments.extend([node3.getProto().SerializeToString(), node1.getProto().SerializeToString(),
node2.getProto().SerializeToString()])
expected_message = m.SerializeToString()
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
m_calls = self.proto_mock.send_datagram.call_args_list
sent_packet = packet.Packet.from_bytes(self.proto_mock.send_datagram.call_args_list[0][0][0])
received_message = sent_packet.payload
m = message.Message()
m.ParseFromString(received_message)
self.assertEqual(received_message, expected_message)
self.assertEqual(len(m_calls), 2)
def test_callPing(self):
self._connecting_to_connected()
n = Node(digest("S"), self.addr1[0], self.addr1[1])
self.wire_protocol[self.addr1] = self.con
self.protocol.callPing(n)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
sent_packet = packet.Packet.from_bytes(self.proto_mock.send_datagram.call_args_list[0][0][0])
sent_message = sent_packet.payload
m = message.Message()
m.ParseFromString(sent_message)
self.assertTrue(len(m.messageID) == 20)
self.assertEqual(self.protocol.sourceNode.getProto().guid, m.sender.guid)
self.assertEqual(self.protocol.sourceNode.getProto().signedPublicKey, m.sender.signedPublicKey)
self.assertTrue(m.command == message.PING)
self.assertEqual(self.proto_mock.send_datagram.call_args_list[0][0][1], self.addr1)
def test_callStore(self):
self._connecting_to_connected()
n = Node(digest("S"), self.addr1[0], self.addr1[1])
self.wire_protocol[self.addr1] = self.con
self.protocol.callStore(n, digest("Keyword"), digest("Key"),
self.protocol.sourceNode.getProto().SerializeToString())
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
sent_packet = packet.Packet.from_bytes(self.proto_mock.send_datagram.call_args_list[0][0][0])
sent_message = sent_packet.payload
m = message.Message()
m.ParseFromString(sent_message)
self.assertTrue(len(m.messageID) == 20)
self.assertEqual(self.protocol.sourceNode.getProto().guid, m.sender.guid)
self.assertEqual(self.protocol.sourceNode.getProto().signedPublicKey, m.sender.signedPublicKey)
self.assertTrue(m.command == message.STORE)
self.assertEqual(self.proto_mock.send_datagram.call_args_list[0][0][1], self.addr1)
self.assertEqual(m.arguments[0], digest("Keyword"))
self.assertEqual(m.arguments[1], digest("Key"))
self.assertEqual(m.arguments[2], self.protocol.sourceNode.getProto().SerializeToString())
def test_callFindValue(self):
self._connecting_to_connected()
n = Node(digest("S"), self.addr1[0], self.addr1[1])
self.wire_protocol[self.addr1] = self.con
keyword = Node(digest("Keyword"))
self.protocol.callFindValue(n, keyword)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
sent_packet = packet.Packet.from_bytes(self.proto_mock.send_datagram.call_args_list[0][0][0])
sent_message = sent_packet.payload
m = message.Message()
m.ParseFromString(sent_message)
self.assertTrue(len(m.messageID) == 20)
self.assertEqual(self.protocol.sourceNode.getProto().guid, m.sender.guid)
self.assertEqual(self.protocol.sourceNode.getProto().signedPublicKey, m.sender.signedPublicKey)
self.assertTrue(m.command == message.FIND_VALUE)
self.assertEqual(self.proto_mock.send_datagram.call_args_list[0][0][1], self.addr1)
self.assertEqual(m.arguments[0], keyword.id)
def test_callFindNode(self):
self._connecting_to_connected()
n = Node(digest("S"), self.addr1[0], self.addr1[1])
self.wire_protocol[self.addr1] = self.con
keyword = Node(digest("nodetofind"))
self.protocol.callFindNode(n, keyword)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
sent_packet = packet.Packet.from_bytes(self.proto_mock.send_datagram.call_args_list[0][0][0])
sent_message = sent_packet.payload
m = message.Message()
m.ParseFromString(sent_message)
self.assertTrue(len(m.messageID) == 20)
self.assertEqual(self.protocol.sourceNode.getProto().guid, m.sender.guid)
self.assertEqual(self.protocol.sourceNode.getProto().signedPublicKey, m.sender.signedPublicKey)
self.assertTrue(m.command == message.FIND_NODE)
self.assertEqual(self.proto_mock.send_datagram.call_args_list[0][0][1], self.addr1)
self.assertEqual(m.arguments[0], keyword.id)
def test_callDelete(self):
self._connecting_to_connected()
n = Node(digest("S"), self.addr1[0], self.addr1[1])
self.wire_protocol[self.addr1] = self.con
self.protocol.callDelete(n, digest("Keyword"), digest("Key"), digest("Signature"))
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
sent_packet = packet.Packet.from_bytes(self.proto_mock.send_datagram.call_args_list[0][0][0])
sent_message = sent_packet.payload
m = message.Message()
m.ParseFromString(sent_message)
self.assertEqual(self.proto_mock.send_datagram.call_args_list[0][0][1], self.addr1)
self.assertTrue(len(m.messageID) == 20)
self.assertEqual(self.protocol.sourceNode.getProto().guid, m.sender.guid)
self.assertEqual(self.protocol.sourceNode.getProto().signedPublicKey, m.sender.signedPublicKey)
self.assertTrue(m.command == message.DELETE)
self.assertEqual(m.arguments[0], digest("Keyword"))
self.assertEqual(m.arguments[1], digest("Key"))
self.assertEqual(m.arguments[2], digest("Signature"))
def test_acceptResponse(self):
self._connecting_to_connected()
def handle_response(resp):
self.assertTrue(resp[0])
self.assertEqual(resp[1][0], "test")
self.assertTrue(message_id not in self.protocol._outstanding)
self.assertFalse(timeout.active())
message_id = digest("msgid")
n = Node(digest("S"), self.addr1[0], self.addr1[1])
d = defer.Deferred()
timeout = reactor.callLater(5, self.protocol._timeout, message_id)
self.protocol._outstanding[message_id] = (d, timeout)
self.protocol._acceptResponse(message_id, ["test"], n)
return d.addCallback(handle_response)
def test_unknownRPC(self):
self.assertFalse(self.handler.receive_message(str(random.getrandbits(1400))))
def test_timeout(self):
self._connecting_to_connected()
self.wire_protocol[self.addr1] = self.con
def test_remove_outstanding():
self.assertTrue(len(self.protocol._outstanding) == 0)
def test_deffered(d):
self.assertFalse(d[0])
test_remove_outstanding()
n = Node(digest("S"), self.addr1[0], self.addr1[1])
d = self.protocol.callPing(n)
self.clock.advance(6)
connection.REACTOR.runUntilCurrent()
self.clock.advance(6)
return d.addCallback(test_deffered)
def test_transferKeyValues(self):
self._connecting_to_connected()
self.wire_protocol[self.addr1] = self.con
self.protocol.addToRouter(mknode())
self.protocol.storage[digest("keyword")] = (
digest("key"), self.protocol.sourceNode.getProto().SerializeToString())
self.protocol.transferKeyValues(Node(digest("id"), self.addr1[0], self.addr1[1]))
self.clock.advance(1)
connection.REACTOR.runUntilCurrent()
sent_packet = packet.Packet.from_bytes(self.proto_mock.send_datagram.call_args_list[0][0][0])
sent_message = sent_packet.payload
x = message.Message()
x.ParseFromString(sent_message)
m = message.Message()
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("STORE")
m.arguments.append(digest("keyword"))
m.arguments.append(digest("key"))
m.arguments.append(self.protocol.sourceNode.getProto().SerializeToString())
self.assertEqual(x.sender, m.sender)
self.assertEqual(x.command, m.command)
self.assertEqual(x.arguments[0], m.arguments[0])
self.assertEqual(x.arguments[1], m.arguments[1])
self.assertEqual(x.arguments[2], m.arguments[2])
def test_refreshIDs(self):
node1 = Node(digest("id1"), "127.0.0.1", 12345, signed_pubkey=digest("key1"))
node2 = Node(digest("id2"), "127.0.0.1", 22222, signed_pubkey=digest("key2"))
node3 = Node(digest("id3"), "127.0.0.1", 77777, signed_pubkey=digest("key3"))
self.protocol.router.addContact(node1)
self.protocol.router.addContact(node2)
self.protocol.router.addContact(node3)
for b in self.protocol.router.buckets:
b.lastUpdated = (time.time() - 5000)
ids = self.protocol.getRefreshIDs()
self.assertTrue(len(ids) == 1)
def _connecting_to_connected(self):
remote_synack_packet = packet.Packet.from_data(
42,
self.con.own_addr,
self.con.dest_addr,
ack=0,
syn=True
)
self.con.receive_packet(remote_synack_packet)
self.clock.advance(0)
connection.REACTOR.runUntilCurrent()
self.next_remote_seqnum = 43
m_calls = self.proto_mock.send_datagram.call_args_list
sent_syn_packet = packet.Packet.from_bytes(m_calls[0][0][0])
seqnum = sent_syn_packet.sequence_number
self.handler_mock.reset_mock()
self.proto_mock.reset_mock()
self.next_seqnum = seqnum + 1
def test_badRPCDelete(self):
n = mknode()
val = self.protocol.rpc_delete(n, 'testkeyword', 'key', 'testsig')
self.assertEqual(val, ["False"])
val = self.protocol.rpc_delete(n, '', '', '')
def run(*args):
TESTNET = args[0]
# Create the database
db = Database(testnet=TESTNET)
# logging
logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log")
log.addObserver(log.FileLogObserver(logFile).emit)
log.startLogging(sys.stdout)
# Load the keys
keychain = KeyChain(db)
if os.path.isfile(DATA_FOLDER + 'keys.pickle'):
keys = pickle.load(open(DATA_FOLDER + "keys.pickle", "r"))
signing_key_hex = keys["signing_privkey"]
signing_key = nacl.signing.SigningKey(signing_key_hex, encoder=nacl.encoding.HexEncoder)
else:
signing_key = nacl.signing.SigningKey.generate()
keys = {
'signing_privkey': signing_key.encode(encoder=nacl.encoding.HexEncoder),
'signing_pubkey': signing_key.verify_key.encode(encoder=nacl.encoding.HexEncoder)
}
pickle.dump(keys, open(DATA_FOLDER + "keys.pickle", "wb"))
# Stun
port = 18467 if not TESTNET else 28467
print "Finding NAT Type.."
response = stun.get_ip_info(stun_host="stun.l.google.com", source_port=port, stun_port=19302)
print "%s on %s:%s" % (response[0], response[1], response[2])
ip_address = response[1]
port = response[2]
# Start the kademlia server
this_node = Node(keychain.guid, ip_address, port, keychain.guid_signed_pubkey, vendor=Profile(db).get().vendor)
protocol = OpenBazaarProtocol((ip_address, port), testnet=TESTNET)
try:
kserver = Server.loadState('cache.pickle', ip_address, port, protocol, db)
except Exception:
kserver = Server(this_node, db)
kserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(kserver.protocol)
kserver.saveStateRegularly('cache.pickle', 10)
# start the market server
mserver = network.Server(kserver, keychain.signing_key, db)
mserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(mserver.protocol)
reactor.listenUDP(port, protocol)
class WebResource(resource.Resource):
def __init__(self, kserver_r):
resource.Resource.__init__(self)
self.kserver = kserver_r
self.nodes = {}
for bucket in self.kserver.protocol.router.buckets:
for node in bucket.getNodes():
self.nodes[(node.ip, node.port)] = node
self.nodes[(this_node.ip, this_node.port)] = this_node
loopingCall = task.LoopingCall(self.crawl)
loopingCall.start(60, True)
def crawl(self):
def gather_results(result):
for proto in result:
n = objects.Node()
try:
n.ParseFromString(proto)
node = Node(n.guid, n.ip, n.port, n.signedPublicKey, n.vendor)
self.nodes[(node.ip, node.port)] = node
except Exception:
pass
def start_crawl(results):
for node, result in results.items():
if not result[0]:
del self.nodes[(node.ip, node.port)]
node = Node(digest(random.getrandbits(255)))
nearest = self.kserver.protocol.router.findNeighbors(node)
spider = NodeSpiderCrawl(self.kserver.protocol, node, nearest, 100, 4)
spider.find().addCallback(gather_results)
ds = {}
for bucket in self.kserver.protocol.router.buckets:
for node in bucket.getNodes():
self.nodes[(node.ip, node.port)] = node
for node in self.nodes.values():
if node.id != this_node.id:
ds[node] = self.kserver.protocol.callPing(node)
deferredDict(ds).addCallback(start_crawl)
def getChild(self, child, request):
return self
def render_GET(self, request):
nodes = self.nodes.values()
shuffle(nodes)
log.msg("Received a request for nodes, responding...")
if "format" in request.args:
if request.args["format"][0] == "json":
json_list = []
if "type" in request.args and request.args["type"][0] == "vendors":
print "getting list of vendors"
for node in nodes:
if node.vendor is True:
print "found vendor"
node_dic = {}
node_dic["ip"] = node.ip
node_dic["port"] = node.port
json_list.append(node_dic)
sig = signing_key.sign(str(json_list))
resp = {"peers": json_list, "signature": hexlify(sig[:64])}
request.write(json.dumps(resp, indent=4))
else:
for node in nodes[:50]:
node_dic = {}
node_dic["ip"] = node.ip
node_dic["port"] = node.port
json_list.append(node_dic)
sig = signing_key.sign(str(json_list))
resp = {"peers": json_list, "signature": hexlify(sig[:64])}
request.write(json.dumps(resp, indent=4))
elif request.args["format"][0] == "protobuf":
proto = peers.PeerSeeds()
for node in nodes[:50]:
peer = peers.PeerData()
peer.ip_address = node.ip
peer.port = node.port
peer.vendor = node.vendor
proto.peer_data.append(peer.SerializeToString())
sig = signing_key.sign("".join(proto.peer_data))[:64]
proto.signature = sig
uncompressed_data = proto.SerializeToString()
request.write(uncompressed_data.encode("zlib"))
else:
proto = peers.PeerSeeds()
if "type" in request.args and request.args["type"][0] == "vendors":
for node in nodes:
if node.vendor is True:
peer = peers.PeerData()
peer.ip_address = node.ip
peer.port = node.port
peer.vendor = node.vendor
proto.peer_data.append(peer.SerializeToString())
sig = signing_key.sign("".join(proto.peer_data))[:64]
proto.signature = sig
uncompressed_data = proto.SerializeToString()
request.write(uncompressed_data.encode("zlib"))
else:
for node in nodes[:50]:
peer = peers.PeerData()
peer.ip_address = node.ip
peer.port = node.port
peer.vendor = node.vendor
proto.peer_data.append(peer.SerializeToString())
sig = signing_key.sign("".join(proto.peer_data))[:64]
proto.signature = sig
uncompressed_data = proto.SerializeToString()
request.write(uncompressed_data.encode("zlib"))
request.finish()
return server.NOT_DONE_YET
server_protocol = server.Site(WebResource(kserver))
reactor.listenTCP(8080, server_protocol)
reactor.run()
class NodeSpiderCrawlTest(unittest.TestCase):
def setUp(self):
self.public_ip = '123.45.67.89'
self.port = 12345
self.own_addr = (self.public_ip, self.port)
self.addr1 = ('132.54.76.98', 54321)
self.addr2 = ('231.76.45.89', 15243)
self.addr3 = ("193.193.111.00", 99999)
self.clock = task.Clock()
connection.REACTOR.callLater = self.clock.callLater
self.proto_mock = mock.Mock(spec_set=rudp.ConnectionMultiplexer)
self.handler_mock = mock.Mock(spec_set=connection.Handler)
self.con = connection.Connection(self.proto_mock, self.handler_mock,
self.own_addr, self.addr1)
valid_key = "1a5c8e67edb8d279d1ae32fa2da97e236b95e95c837dc8c3c7c2ff7a7cc29855"
self.signing_key = nacl.signing.SigningKey(
valid_key, encoder=nacl.encoding.HexEncoder)
verify_key = self.signing_key.verify_key
signed_pubkey = self.signing_key.sign(str(verify_key))
h = nacl.hash.sha512(signed_pubkey)
self.storage = ForgetfulStorage()
self.node = Node(unhexlify(h[:40]), self.public_ip, self.port,
signed_pubkey, True)
self.protocol = KademliaProtocol(self.node, self.storage, 20)
self.wire_protocol = OpenBazaarProtocol(self.own_addr)
self.wire_protocol.register_processor(self.protocol)
self.protocol.connect_multiplexer(self.wire_protocol)
self.handler = self.wire_protocol.ConnHandler([self.protocol])
transport = mock.Mock(spec_set=udp.Port)
ret_val = address.IPv4Address('UDP', self.public_ip, self.port)
transport.attach_mock(mock.Mock(return_value=ret_val), 'getHost')
self.wire_protocol.makeConnection(transport)
self.node1 = Node(digest("id1"), self.addr1[0], self.addr1[1],
digest("key1"), True)
self.node2 = Node(digest("id2"), self.addr2[0], self.addr2[1],
digest("key2"), True)
self.node3 = Node(digest("id3"), self.addr3[0], self.addr3[1],
digest("key3"), True)
def test_find(self):
self._connecting_to_connected()
self.wire_protocol[self.addr1] = self.con
self.wire_protocol[self.addr2] = self.con
self.wire_protocol[self.addr3] = self.con
self.protocol.router.addContact(self.node1)
self.protocol.router.addContact(self.node2)
self.protocol.router.addContact(self.node3)
node = Node(digest("s"))
nearest = self.protocol.router.findNeighbors(node)
spider = NodeSpiderCrawl(self.protocol, node, nearest, 20, 3)
spider.find()
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
self.assertEqual(len(self.proto_mock.send_datagram.call_args_list), 4)
def test_nodesFound(self):
self._connecting_to_connected()
self.wire_protocol[self.addr1] = self.con
self.wire_protocol[self.addr2] = self.con
self.wire_protocol[self.addr3] = self.con
self.protocol.router.addContact(self.node1)
self.protocol.router.addContact(self.node2)
self.protocol.router.addContact(self.node3)
node = Node(digest("s"))
nearest = self.protocol.router.findNeighbors(node)
spider = NodeSpiderCrawl(self.protocol, node, nearest, 20, 3)
response = (True, (self.node1.getProto().SerializeToString(),
self.node2.getProto().SerializeToString(),
self.node3.getProto().SerializeToString()))
responses = {self.node1.id: response}
spider._nodesFound(responses)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
self.assertEqual(len(self.proto_mock.send_datagram.call_args_list), 4)
response = (True, (self.node1.getProto().SerializeToString(),
self.node2.getProto().SerializeToString(),
self.node3.getProto().SerializeToString()))
responses = {self.node1.id: response}
nodes = spider._nodesFound(responses)
node_protos = []
for n in nodes:
node_protos.append(n.getProto())
self.assertTrue(self.node1.getProto() in node_protos)
self.assertTrue(self.node2.getProto() in node_protos)
self.assertTrue(self.node3.getProto() in node_protos)
response = (False, (self.node1.getProto().SerializeToString(),
self.node2.getProto().SerializeToString(),
self.node3.getProto().SerializeToString()))
responses = {self.node1.id: response}
nodes = spider._nodesFound(responses)
node_protos = []
for n in nodes:
node_protos.append(n.getProto())
self.assertTrue(self.node2.getProto() in node_protos)
self.assertTrue(self.node3.getProto() in node_protos)
def _connecting_to_connected(self):
remote_synack_packet = packet.Packet.from_data(42,
self.con.own_addr,
self.con.dest_addr,
ack=0,
syn=True)
self.con.receive_packet(remote_synack_packet)
self.clock.advance(0)
connection.REACTOR.runUntilCurrent()
self.next_remote_seqnum = 43
m_calls = self.proto_mock.send_datagram.call_args_list
sent_syn_packet = packet.Packet.from_bytes(m_calls[0][0][0])
seqnum = sent_syn_packet.sequence_number
self.handler_mock.reset_mock()
self.proto_mock.reset_mock()
self.next_seqnum = seqnum + 1
g = GUID()
keys = {'guid': g}
pickle.dump(keys, open(DATA_FOLDER + "keys.pickle", "wb"))
protocol = OpenBazaarProtocol((ip_address, port))
# kademlia
node = Node(g.guid, signed_pubkey=g.signed_pubkey)
if os.path.isfile(DATA_FOLDER + 'cache.pickle'):
kserver = Server.loadState(DATA_FOLDER + 'cache.pickle', ip_address, port, protocol)
else :
kserver = Server(node)
kserver.protocol.connect_multiplexer(protocol)
kserver.bootstrap(kserver.querySeed("162.213.253.147:8080", "909b4f614ec4fc8c63aab83b91bc620d7a238600bf256472e968fdafce200128"))
kserver.saveStateRegularly(DATA_FOLDER + 'cache.pickle', 10)
protocol.register_processor(kserver.protocol)
# market
mserver = network.Server(kserver)
mserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(mserver.protocol)
reactor.listenUDP(18467, protocol)
# json-rpc server
factory = jsonrpc.RPCFactory(RPCCalls(kserver, mserver))
reactor.listenTCP(18465, factory, interface="127.0.0.1")
reactor.run()
class KademliaProtocolTest(unittest.TestCase):
def setUp(self):
self.public_ip = '123.45.67.89'
self.port = 12345
self.own_addr = (self.public_ip, self.port)
self.addr1 = ('132.54.76.98', 54321)
self.addr2 = ('231.76.45.89', 15243)
self.clock = task.Clock()
connection.REACTOR.callLater = self.clock.callLater
self.proto_mock = mock.Mock(spec_set=rudp.ConnectionMultiplexer)
self.handler_mock = mock.Mock(spec_set=connection.Handler)
self.con = connection.Connection(self.proto_mock, self.handler_mock,
self.own_addr, self.addr1)
valid_key = "1a5c8e67edb8d279d1ae32fa2da97e236b95e95c837dc8c3c7c2ff7a7cc29855"
self.signing_key = nacl.signing.SigningKey(
valid_key, encoder=nacl.encoding.HexEncoder)
verify_key = self.signing_key.verify_key
signed_pubkey = self.signing_key.sign(str(verify_key))
h = nacl.hash.sha512(signed_pubkey)
self.storage = ForgetfulStorage()
self.node = Node(unhexlify(h[:40]), self.public_ip, self.port,
signed_pubkey, True)
self.protocol = KademliaProtocol(self.node, self.storage, 20)
self.wire_protocol = OpenBazaarProtocol(self.own_addr)
self.wire_protocol.register_processor(self.protocol)
self.protocol.connect_multiplexer(self.wire_protocol)
self.handler = self.wire_protocol.ConnHandler([self.protocol])
self.handler.connection = self.con
transport = mock.Mock(spec_set=udp.Port)
ret_val = address.IPv4Address('UDP', self.public_ip, self.port)
transport.attach_mock(mock.Mock(return_value=ret_val), 'getHost')
self.wire_protocol.makeConnection(transport)
def tearDown(self):
self.con.shutdown()
self.wire_protocol.shutdown()
def test_invalid_datagram(self):
self.assertFalse(self.handler.receive_message("hi"))
self.assertFalse(
self.handler.receive_message(
"hihihihihihihihihihihihihihihihihihihihih"))
def test_rpc_ping(self):
self._connecting_to_connected()
m = message.Message()
m.messageID = digest("msgid")
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("PING")
data = m.SerializeToString()
m.arguments.append(
self.protocol.sourceNode.getProto().SerializeToString())
expected_message = m.SerializeToString()
self.handler.receive_message(data)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
m_calls = self.proto_mock.send_datagram.call_args_list
sent_packet = packet.Packet.from_bytes(
self.proto_mock.send_datagram.call_args_list[0][0][0])
received_message = sent_packet.payload
self.assertEqual(received_message, expected_message)
self.assertEqual(len(m_calls), 2)
def test_rpc_store(self):
self._connecting_to_connected()
m = message.Message()
m.messageID = digest("msgid")
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("STORE")
m.arguments.extend([
digest("Keyword"), "Key",
self.protocol.sourceNode.getProto().SerializeToString()
])
data = m.SerializeToString()
del m.arguments[-3:]
m.arguments.append("True")
expected_message = m.SerializeToString()
self.handler.receive_message(data)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
m_calls = self.proto_mock.send_datagram.call_args_list
sent_packet = packet.Packet.from_bytes(
self.proto_mock.send_datagram.call_args_list[0][0][0])
received_message = sent_packet.payload
self.assertEqual(received_message, expected_message)
self.assertEqual(len(m_calls), 2)
self.assertTrue(
self.storage.getSpecific(digest("Keyword"), "Key") ==
self.protocol.sourceNode.getProto().SerializeToString())
def test_rpc_delete(self):
self._connecting_to_connected()
# Set a keyword to store
m = message.Message()
m.messageID = digest("msgid")
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("STORE")
m.arguments.extend([
digest("Keyword"), "Key",
self.protocol.sourceNode.getProto().SerializeToString()
])
data = m.SerializeToString()
del m.arguments[-3:]
m.arguments.append("True")
expected_message1 = m.SerializeToString()
self.handler.receive_message(data)
self.assertTrue(
self.storage.getSpecific(digest("Keyword"), "Key") ==
self.protocol.sourceNode.getProto().SerializeToString())
# Test bad signature
m = message.Message()
m.messageID = digest("msgid")
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("DELETE")
m.arguments.extend([digest("Keyword"), "Key", "Bad Signature"])
data = m.SerializeToString()
del m.arguments[-3:]
m.arguments.append("False")
expected_message2 = m.SerializeToString()
self.handler.receive_message(data)
self.assertTrue(
self.storage.getSpecific(digest("Keyword"), "Key") ==
self.protocol.sourceNode.getProto().SerializeToString())
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
sent_packets = tuple(
packet.Packet.from_bytes(call[0][0])
for call in self.proto_mock.send_datagram.call_args_list)
self.assertEqual(sent_packets[0].payload, expected_message1)
self.assertEqual(sent_packets[1].payload, expected_message2)
self.proto_mock.send_datagram.call_args_list = []
# Test good signature
m = message.Message()
m.messageID = digest("msgid")
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("DELETE")
m.arguments.extend(
[digest("Keyword"), "Key",
self.signing_key.sign("Key")[:64]])
data = m.SerializeToString()
del m.arguments[-3:]
m.arguments.append("True")
expected_message3 = m.SerializeToString()
self.handler.receive_message(data)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
sent_packet = packet.Packet.from_bytes(
self.proto_mock.send_datagram.call_args_list[0][0][0])
self.assertEqual(sent_packet.payload, expected_message3)
self.assertTrue(
self.storage.getSpecific(digest("Keyword"), "Key") is None)
def test_rpc_stun(self):
self._connecting_to_connected()
m = message.Message()
m.messageID = digest("msgid")
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("STUN")
data = m.SerializeToString()
m.arguments.extend([self.public_ip, str(self.port)])
expected_message = m.SerializeToString()
self.handler.receive_message(data)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
m_calls = self.proto_mock.send_datagram.call_args_list
sent_packet = packet.Packet.from_bytes(
self.proto_mock.send_datagram.call_args_list[0][0][0])
received_message = sent_packet.payload
a = message.Message()
a.ParseFromString(received_message)
self.assertEqual(received_message, expected_message)
self.assertEqual(len(m_calls), 2)
def test_rpc_find_node(self):
self._connecting_to_connected()
node1 = Node(digest("id1"), "127.0.0.1", 12345, digest("key1"))
node2 = Node(digest("id2"), "127.0.0.1", 22222, digest("key2"))
node3 = Node(digest("id3"), "127.0.0.1", 77777, digest("key3"))
self.protocol.router.addContact(node1)
self.protocol.router.addContact(node2)
self.protocol.router.addContact(node3)
m = message.Message()
m.messageID = digest("msgid")
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("FIND_NODE")
m.arguments.append(digest("nodetofind"))
data = m.SerializeToString()
del m.arguments[-1]
m.arguments.extend([
node2.getProto().SerializeToString(),
node1.getProto().SerializeToString(),
node3.getProto().SerializeToString()
])
expected_message = m.SerializeToString()
self.handler.receive_message(data)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
m_calls = self.proto_mock.send_datagram.call_args_list
sent_packet = packet.Packet.from_bytes(
self.proto_mock.send_datagram.call_args_list[0][0][0])
received_message = sent_packet.payload
a = message.Message()
a.ParseFromString(received_message)
self.assertEqual(received_message, expected_message)
self.assertEqual(len(m_calls), 2)
def test_rpc_find_value(self):
self._connecting_to_connected()
# Set a value to find
m = message.Message()
m.messageID = digest("msgid")
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("STORE")
m.arguments.extend([
digest("Keyword"), "Key",
self.protocol.sourceNode.getProto().SerializeToString()
])
data = m.SerializeToString()
self.handler.receive_message(data)
self.assertTrue(
self.storage.getSpecific(digest("Keyword"), "Key") ==
self.protocol.sourceNode.getProto().SerializeToString())
# Send the find_value rpc
m = message.Message()
m.messageID = digest("msgid")
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("FIND_VALUE")
m.arguments.append(digest("Keyword"))
data = m.SerializeToString()
self.handler.receive_message(data)
del m.arguments[-1]
value = objects.Value()
value.valueKey = "Key"
value.serializedData = self.protocol.sourceNode.getProto(
).SerializeToString()
m.arguments.append("value")
m.arguments.append(value.SerializeToString())
expected_message = m.SerializeToString()
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
m_calls = self.proto_mock.send_datagram.call_args_list
sent_packets = tuple(
packet.Packet.from_bytes(call[0][0])
for call in self.proto_mock.send_datagram.call_args_list)
received_message = sent_packets[1].payload
self.assertEqual(received_message, expected_message)
self.assertEqual(len(m_calls), 3)
def test_rpc_find_without_value(self):
self._connecting_to_connected()
node1 = Node(digest("id1"), "127.0.0.1", 12345, digest("key1"))
node2 = Node(digest("id2"), "127.0.0.1", 22222, digest("key2"))
node3 = Node(digest("id3"), "127.0.0.1", 77777, digest("key3"))
self.protocol.router.addContact(node1)
self.protocol.router.addContact(node2)
self.protocol.router.addContact(node3)
m = message.Message()
m.messageID = digest("msgid")
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("FIND_VALUE")
m.arguments.append(digest("Keyword"))
data = m.SerializeToString()
self.handler.receive_message(data)
del m.arguments[-1]
m.arguments.extend([
node3.getProto().SerializeToString(),
node1.getProto().SerializeToString(),
node2.getProto().SerializeToString()
])
expected_message = m.SerializeToString()
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
m_calls = self.proto_mock.send_datagram.call_args_list
sent_packet = packet.Packet.from_bytes(
self.proto_mock.send_datagram.call_args_list[0][0][0])
received_message = sent_packet.payload
m = message.Message()
m.ParseFromString(received_message)
self.assertEqual(received_message, expected_message)
self.assertEqual(len(m_calls), 2)
def test_callPing(self):
self._connecting_to_connected()
n = Node(digest("S"), self.addr1[0], self.addr1[1])
self.wire_protocol[self.addr1] = self.con
self.protocol.callPing(n)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
sent_packet = packet.Packet.from_bytes(
self.proto_mock.send_datagram.call_args_list[0][0][0])
sent_message = sent_packet.payload
m = message.Message()
m.ParseFromString(sent_message)
self.assertTrue(len(m.messageID) == 20)
self.assertEqual(self.protocol.sourceNode.getProto().guid,
m.sender.guid)
self.assertEqual(self.protocol.sourceNode.getProto().signedPublicKey,
m.sender.signedPublicKey)
self.assertTrue(m.command == message.PING)
self.assertEqual(self.proto_mock.send_datagram.call_args_list[0][0][1],
self.addr1)
def test_callStore(self):
self._connecting_to_connected()
n = Node(digest("S"), self.addr1[0], self.addr1[1])
self.wire_protocol[self.addr1] = self.con
self.protocol.callStore(
n, digest("Keyword"), digest("Key"),
self.protocol.sourceNode.getProto().SerializeToString())
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
sent_packet = packet.Packet.from_bytes(
self.proto_mock.send_datagram.call_args_list[0][0][0])
sent_message = sent_packet.payload
m = message.Message()
m.ParseFromString(sent_message)
self.assertTrue(len(m.messageID) == 20)
self.assertEqual(self.protocol.sourceNode.getProto().guid,
m.sender.guid)
self.assertEqual(self.protocol.sourceNode.getProto().signedPublicKey,
m.sender.signedPublicKey)
self.assertTrue(m.command == message.STORE)
self.assertEqual(self.proto_mock.send_datagram.call_args_list[0][0][1],
self.addr1)
self.assertEqual(m.arguments[0], digest("Keyword"))
self.assertEqual(m.arguments[1], digest("Key"))
self.assertEqual(
m.arguments[2],
self.protocol.sourceNode.getProto().SerializeToString())
def test_callFindValue(self):
self._connecting_to_connected()
n = Node(digest("S"), self.addr1[0], self.addr1[1])
self.wire_protocol[self.addr1] = self.con
keyword = Node(digest("Keyword"))
self.protocol.callFindValue(n, keyword)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
sent_packet = packet.Packet.from_bytes(
self.proto_mock.send_datagram.call_args_list[0][0][0])
sent_message = sent_packet.payload
m = message.Message()
m.ParseFromString(sent_message)
self.assertTrue(len(m.messageID) == 20)
self.assertEqual(self.protocol.sourceNode.getProto().guid,
m.sender.guid)
self.assertEqual(self.protocol.sourceNode.getProto().signedPublicKey,
m.sender.signedPublicKey)
self.assertTrue(m.command == message.FIND_VALUE)
self.assertEqual(self.proto_mock.send_datagram.call_args_list[0][0][1],
self.addr1)
self.assertEqual(m.arguments[0], keyword.id)
def test_callFindNode(self):
self._connecting_to_connected()
n = Node(digest("S"), self.addr1[0], self.addr1[1])
self.wire_protocol[self.addr1] = self.con
keyword = Node(digest("nodetofind"))
self.protocol.callFindNode(n, keyword)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
sent_packet = packet.Packet.from_bytes(
self.proto_mock.send_datagram.call_args_list[0][0][0])
sent_message = sent_packet.payload
m = message.Message()
m.ParseFromString(sent_message)
self.assertTrue(len(m.messageID) == 20)
self.assertEqual(self.protocol.sourceNode.getProto().guid,
m.sender.guid)
self.assertEqual(self.protocol.sourceNode.getProto().signedPublicKey,
m.sender.signedPublicKey)
self.assertTrue(m.command == message.FIND_NODE)
self.assertEqual(self.proto_mock.send_datagram.call_args_list[0][0][1],
self.addr1)
self.assertEqual(m.arguments[0], keyword.id)
def test_callDelete(self):
self._connecting_to_connected()
n = Node(digest("S"), self.addr1[0], self.addr1[1])
self.wire_protocol[self.addr1] = self.con
self.protocol.callDelete(n, digest("Keyword"), digest("Key"),
digest("Signature"))
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
sent_packet = packet.Packet.from_bytes(
self.proto_mock.send_datagram.call_args_list[0][0][0])
sent_message = sent_packet.payload
m = message.Message()
m.ParseFromString(sent_message)
self.assertEqual(self.proto_mock.send_datagram.call_args_list[0][0][1],
self.addr1)
self.assertTrue(len(m.messageID) == 20)
self.assertEqual(self.protocol.sourceNode.getProto().guid,
m.sender.guid)
self.assertEqual(self.protocol.sourceNode.getProto().signedPublicKey,
m.sender.signedPublicKey)
self.assertTrue(m.command == message.DELETE)
self.assertEqual(m.arguments[0], digest("Keyword"))
self.assertEqual(m.arguments[1], digest("Key"))
self.assertEqual(m.arguments[2], digest("Signature"))
def test_acceptResponse(self):
self._connecting_to_connected()
def handle_response(resp):
self.assertTrue(resp[0])
self.assertEqual(resp[1][0], self.protocol.sourceNode.id)
n = Node(digest("S"), self.addr1[0], self.addr1[1])
self.wire_protocol[self.addr1] = self.con
d = self.protocol.callPing(n)
self.clock.advance(1)
connection.REACTOR.runUntilCurrent()
sent_packet = packet.Packet.from_bytes(
self.proto_mock.send_datagram.call_args_list[0][0][0])
sent_message = sent_packet.payload
m = message.Message()
m.ParseFromString(sent_message)
timeout = reactor.callLater(5, self.protocol._timeout, m.messageID)
self.protocol._outstanding[m.messageID] = (d, timeout)
m.arguments.append(self.protocol.sourceNode.id)
self.handler.receive_message(m.SerializeToString())
return d.addCallback(handle_response)
def test_unknownRPC(self):
self.assertFalse(
self.handler.receive_message(str(random.getrandbits(1400))))
def test_timeout(self):
self._connecting_to_connected()
self.wire_protocol[self.addr1] = self.con
def test_remove_outstanding():
self.assertTrue(len(self.protocol._outstanding) == 0)
def test_deffered(d):
self.assertFalse(d[0])
test_remove_outstanding()
n = Node(digest("S"), self.addr1[0], self.addr1[1])
d = self.protocol.callPing(n)
self.clock.advance(6)
connection.REACTOR.runUntilCurrent()
self.clock.advance(6)
return d.addCallback(test_deffered)
def test_transferKeyValues(self):
self._connecting_to_connected()
self.wire_protocol[self.addr1] = self.con
self.protocol.addToRouter(mknode())
self.protocol.storage[digest("keyword")] = (
digest("key"),
self.protocol.sourceNode.getProto().SerializeToString())
self.protocol.transferKeyValues(
Node(digest("id"), self.addr1[0], self.addr1[1]))
self.clock.advance(1)
connection.REACTOR.runUntilCurrent()
sent_packet = packet.Packet.from_bytes(
self.proto_mock.send_datagram.call_args_list[0][0][0])
sent_message = sent_packet.payload
x = message.Message()
x.ParseFromString(sent_message)
m = message.Message()
m.sender.MergeFrom(self.protocol.sourceNode.getProto())
m.command = message.Command.Value("STORE")
m.arguments.append(digest("keyword"))
m.arguments.append(digest("key"))
m.arguments.append(
self.protocol.sourceNode.getProto().SerializeToString())
self.assertEqual(x.sender, m.sender)
self.assertEqual(x.command, m.command)
self.assertEqual(x.arguments[0], m.arguments[0])
self.assertEqual(x.arguments[1], m.arguments[1])
self.assertEqual(x.arguments[2], m.arguments[2])
def test_refreshIDs(self):
node1 = Node(digest("id1"),
"127.0.0.1",
12345,
signed_pubkey=digest("key1"))
node2 = Node(digest("id2"),
"127.0.0.1",
22222,
signed_pubkey=digest("key2"))
node3 = Node(digest("id3"),
"127.0.0.1",
77777,
signed_pubkey=digest("key3"))
self.protocol.router.addContact(node1)
self.protocol.router.addContact(node2)
self.protocol.router.addContact(node3)
for b in self.protocol.router.buckets:
b.lastUpdated = (time.time() - 5000)
ids = self.protocol.getRefreshIDs()
self.assertTrue(len(ids) == 1)
def _connecting_to_connected(self):
remote_synack_packet = packet.Packet.from_data(42,
self.con.own_addr,
self.con.dest_addr,
ack=0,
syn=True)
self.con.receive_packet(remote_synack_packet)
self.clock.advance(0)
connection.REACTOR.runUntilCurrent()
self.next_remote_seqnum = 43
m_calls = self.proto_mock.send_datagram.call_args_list
sent_syn_packet = packet.Packet.from_bytes(m_calls[0][0][0])
seqnum = sent_syn_packet.sequence_number
self.handler_mock.reset_mock()
self.proto_mock.reset_mock()
self.next_seqnum = seqnum + 1
def test_badRPCDelete(self):
n = mknode()
val = self.protocol.rpc_delete(n, 'testkeyword', 'key', 'testsig')
self.assertEqual(val, ["False"])
val = self.protocol.rpc_delete(n, '', '', '')
class ValueSpiderCrawlTest(unittest.TestCase):
def setUp(self):
self.public_ip = '123.45.67.89'
self.port = 12345
self.own_addr = (self.public_ip, self.port)
self.addr1 = ('132.54.76.98', 54321)
self.addr2 = ('231.76.45.89', 15243)
self.addr3 = ("193.193.111.00", 99999)
self.clock = task.Clock()
connection.REACTOR.callLater = self.clock.callLater
self.proto_mock = mock.Mock(spec_set=rudp.ConnectionMultiplexer)
self.handler_mock = mock.Mock(spec_set=connection.Handler)
self.con = connection.Connection(self.proto_mock, self.handler_mock,
self.own_addr, self.addr1)
valid_key = "1a5c8e67edb8d279d1ae32fa2da97e236b95e95c837dc8c3c7c2ff7a7cc29855"
self.signing_key = nacl.signing.SigningKey(
valid_key, encoder=nacl.encoding.HexEncoder)
verify_key = self.signing_key.verify_key
signed_pubkey = self.signing_key.sign(str(verify_key))
h = nacl.hash.sha512(signed_pubkey)
self.storage = ForgetfulStorage()
self.node = Node(unhexlify(h[:40]), self.public_ip, self.port,
signed_pubkey, True)
self.protocol = KademliaProtocol(self.node, self.storage, 20)
self.wire_protocol = OpenBazaarProtocol(self.own_addr)
self.wire_protocol.register_processor(self.protocol)
self.protocol.connect_multiplexer(self.wire_protocol)
self.handler = self.wire_protocol.ConnHandler([self.protocol])
transport = mock.Mock(spec_set=udp.Port)
ret_val = address.IPv4Address('UDP', self.public_ip, self.port)
transport.attach_mock(mock.Mock(return_value=ret_val), 'getHost')
self.wire_protocol.makeConnection(transport)
self.node1 = Node(digest("id1"), self.addr1[0], self.addr1[1],
digest("key1"), True)
self.node2 = Node(digest("id2"), self.addr2[0], self.addr2[1],
digest("key2"), True)
self.node3 = Node(digest("id3"), self.addr3[0], self.addr3[1],
digest("key3"), True)
def tearDown(self):
self.con.shutdown()
self.wire_protocol.shutdown()
def test_find(self):
self._connecting_to_connected()
self.wire_protocol[self.addr1] = self.con
self.wire_protocol[self.addr2] = self.con
self.wire_protocol[self.addr3] = self.con
self.protocol.router.addContact(self.node1)
self.protocol.router.addContact(self.node2)
self.protocol.router.addContact(self.node3)
node = Node(digest("s"))
nearest = self.protocol.router.findNeighbors(node)
spider = ValueSpiderCrawl(self.protocol, node, nearest,
dht.constants.KSIZE, dht.constants.ALPHA)
spider.find()
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
self.assertEqual(len(self.proto_mock.send_datagram.call_args_list), 4)
def test_nodesFound(self):
self._connecting_to_connected()
self.wire_protocol[self.addr1] = self.con
self.wire_protocol[self.addr2] = self.con
self.wire_protocol[self.addr3] = self.con
self.protocol.router.addContact(self.node1)
self.protocol.router.addContact(self.node2)
self.protocol.router.addContact(self.node3)
# test resonse with uncontacted nodes
node = Node(digest("s"))
nearest = self.protocol.router.findNeighbors(node)
spider = ValueSpiderCrawl(self.protocol, node, nearest,
dht.constants.KSIZE, dht.constants.ALPHA)
response = (True, (self.node1.getProto().SerializeToString(),
self.node2.getProto().SerializeToString(),
self.node3.getProto().SerializeToString()))
responses = {self.node1.id: response}
spider._nodesFound(responses)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
self.assertEqual(len(self.proto_mock.send_datagram.call_args_list), 4)
# test all been contacted
spider = ValueSpiderCrawl(self.protocol, node, nearest,
dht.constants.KSIZE, dht.constants.ALPHA)
for peer in spider.nearest.getUncontacted():
spider.nearest.markContacted(peer)
response = (True, (self.node1.getProto().SerializeToString(),
self.node2.getProto().SerializeToString(),
self.node3.getProto().SerializeToString()))
responses = {self.node2.id: response}
resp = spider._nodesFound(responses)
self.assertTrue(resp is None)
# test didn't happen
spider = ValueSpiderCrawl(self.protocol, node, nearest,
dht.constants.KSIZE, dht.constants.ALPHA)
response = (False, (self.node1.getProto().SerializeToString(),
self.node2.getProto().SerializeToString(),
self.node3.getProto().SerializeToString()))
responses = {self.node1.id: response}
spider._nodesFound(responses)
self.assertTrue(len(spider.nearest) == 2)
# test got value
val = Value()
val.valueKey = digest("contractID")
val.serializedData = self.protocol.sourceNode.getProto(
).SerializeToString()
response = (True, ("value", val.SerializeToString()))
responses = {self.node3.id: response}
spider.nearestWithoutValue = NodeHeap(node, 1)
value = spider._nodesFound(responses)
self.assertEqual(value[0], val.SerializeToString())
def test_handleFoundValues(self):
self._connecting_to_connected()
self.wire_protocol[self.addr1] = self.con
self.protocol.router.addContact(self.node1)
self.protocol.router.addContact(self.node2)
self.protocol.router.addContact(self.node3)
node = Node(digest("s"))
nearest = self.protocol.router.findNeighbors(node)
spider = ValueSpiderCrawl(self.protocol, node, nearest,
dht.constants.KSIZE, dht.constants.ALPHA)
val = Value()
val.valueKey = digest("contractID")
val.serializedData = self.node1.getProto().SerializeToString()
val1 = val.SerializeToString()
value = spider._handleFoundValues([(val1, )])
self.assertEqual(value[0], val.SerializeToString())
# test handle multiple values
val.serializedData = self.node2.getProto().SerializeToString()
val2 = val.SerializeToString()
found_values = [(val1, ), (val1, ), (val2, )]
self.assertEqual(spider._handleFoundValues(found_values), (val1, ))
# test store value at nearest without value
spider.nearestWithoutValue.push(self.node1)
spider._handleFoundValues(found_values)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
self.assertTrue(len(self.proto_mock.send_datagram.call_args_list) > 1)
self.proto_mock.send_datagram.call_args_list = []
def _connecting_to_connected(self):
remote_synack_packet = packet.Packet.from_data(42,
self.con.own_addr,
self.con.dest_addr,
ack=0,
syn=True)
self.con.receive_packet(remote_synack_packet)
self.clock.advance(0)
connection.REACTOR.runUntilCurrent()
self.next_remote_seqnum = 43
m_calls = self.proto_mock.send_datagram.call_args_list
sent_syn_packet = packet.Packet.from_bytes(m_calls[0][0][0])
seqnum = sent_syn_packet.sequence_number
self.handler_mock.reset_mock()
self.proto_mock.reset_mock()
self.next_seqnum = seqnum + 1
def run(*args):
TESTNET = args[0]
# database
db = Database(TESTNET)
# key generation
keys = KeyChain(db)
# logging
# TODO: prune this log file and prevent it from getting too large?
logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log")
log.addObserver(log.FileLogObserver(logFile).emit)
log.startLogging(sys.stdout)
# stun
# TODO: accept port from command line
port = 18467 if not TESTNET else 28467
print "Finding NAT Type.."
# TODO: maintain a list of backup STUN servers and try them if ours fails
response = stun.get_ip_info(stun_host="seed.openbazaar.org",
source_port=port)
print "%s on %s:%s" % (response[0], response[1], response[2])
ip_address = response[1]
port = response[2]
# TODO: try UPnP if restricted NAT
# TODO: maintain open connection to seed node if STUN/UPnP fail
# TODO: use TURN if symmetric NAT
def on_bootstrap_complete(resp):
mlistener = MessageListenerImpl(ws_factory, db)
mserver.get_messages(mlistener)
mserver.protocol.add_listener(mlistener)
nlistener = NotificationListenerImpl(ws_factory, db)
mserver.protocol.add_listener(nlistener)
# TODO: after bootstrap run through any pending contracts and see if the bitcoin address
# has been funded, if not listen on the address and start the 10 minute delete timer.
protocol = OpenBazaarProtocol((ip_address, port), testnet=TESTNET)
# kademlia
node = Node(keys.guid,
ip_address,
port,
signed_pubkey=keys.guid_signed_pubkey)
try:
kserver = Server.loadState(DATA_FOLDER + 'cache.pickle',
ip_address,
port,
protocol,
db,
on_bootstrap_complete,
storage=PersistentStorage(db.DATABASE))
except Exception:
kserver = Server(node,
db,
KSIZE,
ALPHA,
storage=PersistentStorage(db.DATABASE))
kserver.protocol.connect_multiplexer(protocol)
kserver.bootstrap(
kserver.querySeed("seed.openbazaar.org:8080",
"ddd862778e3ed71af06db0e3619a4c6269ec7468c745132dbb73982b319fc572"))\
.addCallback(on_bootstrap_complete)
# TODO: load seeds from config file
kserver.saveStateRegularly(DATA_FOLDER + 'cache.pickle', 10)
protocol.register_processor(kserver.protocol)
# market
mserver = network.Server(kserver, keys.signing_key, db)
mserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(mserver.protocol)
reactor.listenUDP(port, protocol)
# websockets api
ws_factory = WSFactory("ws://127.0.0.1:18466", mserver, kserver)
ws_factory.protocol = WSProtocol
ws_factory.setProtocolOptions(allowHixie76=True)
listenWS(ws_factory)
webdir = File(".")
web = Site(webdir)
reactor.listenTCP(9000, web, interface="127.0.0.1")
# rest api
api = OpenBazaarAPI(mserver, kserver, protocol)
site = Site(api, timeout=None)
reactor.listenTCP(18469, site, interface="127.0.0.1")
# TODO: add optional SSL on rest and websocket servers
# blockchain
# TODO: listen on the libbitcoin heartbeat port instead fetching height
def height_fetched(ec, height):
# TODO: re-broadcast any unconfirmed txs in the db using height to find confirmation status
print "Libbitcoin server online"
try:
timeout.cancel()
except Exception:
pass
def timeout(client):
print "Libbitcoin server offline"
client = None
if TESTNET:
libbitcoin_client = LibbitcoinClient(
"tcp://libbitcoin2.openbazaar.org:9091")
else:
libbitcoin_client = LibbitcoinClient(
"tcp://libbitcoin1.openbazaar.org:9091")
# TODO: load libbitcoin server url from config file
libbitcoin_client.fetch_last_height(height_fetched)
timeout = reactor.callLater(5, timeout, libbitcoin_client)
protocol.set_servers(ws_factory, libbitcoin_client)
reactor.run()
def run(*args):
TESTNET = args[0]
# logging
logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log")
log.addObserver(log.FileLogObserver(logFile).emit)
log.startLogging(sys.stdout)
# Create the database
db = Database(testnet=TESTNET)
# Load the keys
keychain = KeyChain(db)
if os.path.isfile(DATA_FOLDER + 'keys.pickle'):
keys = pickle.load(open(DATA_FOLDER + "keys.pickle", "r"))
signing_key_hex = keys["signing_privkey"]
signing_key = nacl.signing.SigningKey(signing_key_hex,
encoder=nacl.encoding.HexEncoder)
else:
signing_key = nacl.signing.SigningKey.generate()
keys = {
'signing_privkey':
signing_key.encode(encoder=nacl.encoding.HexEncoder),
'signing_pubkey':
signing_key.verify_key.encode(encoder=nacl.encoding.HexEncoder)
}
pickle.dump(keys, open(DATA_FOLDER + "keys.pickle", "wb"))
# Stun
port = 18467 if not TESTNET else 28467
print "Finding NAT Type.."
response = stun.get_ip_info(stun_host="stun.l.google.com",
source_port=port,
stun_port=19302)
print "%s on %s:%s" % (response[0], response[1], response[2])
ip_address = response[1]
port = response[2]
# Start the kademlia server
this_node = Node(keychain.guid, ip_address, port,
keychain.guid_signed_pubkey)
protocol = OpenBazaarProtocol((ip_address, port), testnet=TESTNET)
try:
kserver = Server.loadState('cache.pickle', ip_address, port, protocol,
db)
except Exception:
kserver = Server(this_node, db)
kserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(kserver.protocol)
kserver.saveStateRegularly('cache.pickle', 10)
# start the market server
mserver = network.Server(kserver, keychain.signing_key, db)
mserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(mserver.protocol)
reactor.listenUDP(port, protocol)
class WebResource(resource.Resource):
def __init__(self, kserver_r):
resource.Resource.__init__(self)
self.kserver = kserver_r
self.nodes = {}
for bucket in self.kserver.protocol.router.buckets:
for node in bucket.getNodes():
self.nodes[node.id] = node
self.nodes[this_node.id] = this_node
loopingCall = task.LoopingCall(self.crawl)
loopingCall.start(60, True)
def crawl(self):
def gather_results(result):
for proto in result:
n = objects.Node()
try:
n.ParseFromString(proto)
node = Node(n.guid, n.ip, n.port, n.signedPublicKey,
n.vendor)
if node.id not in self.nodes:
self.nodes[node.id] = node
except Exception:
pass
def start_crawl(results):
for node, result in results.items():
if not result[0]:
del self.nodes[node.id]
node = Node(digest(random.getrandbits(255)))
nearest = self.kserver.protocol.router.findNeighbors(node)
spider = NodeSpiderCrawl(self.kserver.protocol, node, nearest,
100, 4)
spider.find().addCallback(gather_results)
ds = {}
for bucket in self.kserver.protocol.router.buckets:
for node in bucket.getNodes():
if node.id not in self.nodes:
self.nodes[node.id] = node
for node in self.nodes.values():
if node.id != this_node.id:
ds[node] = self.kserver.protocol.callPing(node)
deferredDict(ds).addCallback(start_crawl)
def getChild(self, child, request):
return self
def render_GET(self, request):
nodes = self.nodes.values()
shuffle(nodes)
log.msg("Received a request for nodes, responding...")
if "format" in request.args:
if request.args["format"][0] == "json":
json_list = []
if "type" in request.args and request.args["type"][
0] == "vendors":
print "getting list of vendors"
for node in nodes:
if node.vendor is True:
print "found vendor"
node_dic = {}
node_dic["ip"] = node.ip
node_dic["port"] = node.port
json_list.append(node_dic)
sig = signing_key.sign(str(json_list))
resp = {
"peers": json_list,
"signature": hexlify(sig[:64])
}
request.write(json.dumps(resp, indent=4))
else:
for node in nodes[:50]:
node_dic = {}
node_dic["ip"] = node.ip
node_dic["port"] = node.port
json_list.append(node_dic)
sig = signing_key.sign(str(json_list))
resp = {
"peers": json_list,
"signature": hexlify(sig[:64])
}
request.write(json.dumps(resp, indent=4))
elif request.args["format"][0] == "protobuf":
proto = peers.PeerSeeds()
for node in nodes[:50]:
peer = peers.PeerData()
peer.ip_address = node.ip
peer.port = node.port
peer.vendor = node.vendor
proto.peer_data.append(peer.SerializeToString())
sig = signing_key.sign("".join(proto.peer_data))[:64]
proto.signature = sig
uncompressed_data = proto.SerializeToString()
request.write(uncompressed_data.encode("zlib"))
else:
proto = peers.PeerSeeds()
if "type" in request.args and request.args["type"][
0] == "vendors":
for node in nodes:
if node.vendor is True:
peer = peers.PeerData()
peer.ip_address = node.ip
peer.port = node.port
peer.vendor = node.vendor
proto.peer_data.append(peer.SerializeToString())
sig = signing_key.sign("".join(proto.peer_data))[:64]
proto.signature = sig
uncompressed_data = proto.SerializeToString()
request.write(uncompressed_data.encode("zlib"))
else:
for node in nodes[:50]:
peer = peers.PeerData()
peer.ip_address = node.ip
peer.port = node.port
peer.vendor = node.vendor
proto.peer_data.append(peer.SerializeToString())
sig = signing_key.sign("".join(proto.peer_data))[:64]
proto.signature = sig
uncompressed_data = proto.SerializeToString()
request.write(uncompressed_data.encode("zlib"))
request.finish()
return server.NOT_DONE_YET
server_protocol = server.Site(WebResource(kserver))
reactor.listenTCP(8080, server_protocol)
reactor.run()
class ValueSpiderCrawlTest(unittest.TestCase):
def setUp(self):
self.public_ip = '123.45.67.89'
self.port = 12345
self.own_addr = (self.public_ip, self.port)
self.addr1 = ('132.54.76.98', 54321)
self.addr2 = ('231.76.45.89', 15243)
self.addr3 = ("193.193.111.00", 99999)
self.clock = task.Clock()
connection.REACTOR.callLater = self.clock.callLater
self.proto_mock = mock.Mock(spec_set=rudp.ConnectionMultiplexer)
self.handler_mock = mock.Mock(spec_set=connection.Handler)
self.con = connection.Connection(
self.proto_mock,
self.handler_mock,
self.own_addr,
self.addr1
)
valid_key = "1a5c8e67edb8d279d1ae32fa2da97e236b95e95c837dc8c3c7c2ff7a7cc29855"
self.signing_key = nacl.signing.SigningKey(valid_key, encoder=nacl.encoding.HexEncoder)
verify_key = self.signing_key.verify_key
signed_pubkey = self.signing_key.sign(str(verify_key))
h = nacl.hash.sha512(signed_pubkey)
self.storage = ForgetfulStorage()
self.node = Node(unhexlify(h[:40]), self.public_ip, self.port, signed_pubkey, True)
self.db = Database(filepath=":memory:")
self.protocol = KademliaProtocol(self.node, self.storage, 20, self.db)
self.wire_protocol = OpenBazaarProtocol(self.own_addr)
self.wire_protocol.register_processor(self.protocol)
self.protocol.connect_multiplexer(self.wire_protocol)
self.handler = self.wire_protocol.ConnHandler([self.protocol], self.wire_protocol)
transport = mock.Mock(spec_set=udp.Port)
ret_val = address.IPv4Address('UDP', self.public_ip, self.port)
transport.attach_mock(mock.Mock(return_value=ret_val), 'getHost')
self.wire_protocol.makeConnection(transport)
self.node1 = Node(digest("id1"), self.addr1[0], self.addr1[1], digest("key1"), True)
self.node2 = Node(digest("id2"), self.addr2[0], self.addr2[1], digest("key2"), True)
self.node3 = Node(digest("id3"), self.addr3[0], self.addr3[1], digest("key3"), True)
def tearDown(self):
self.con.shutdown()
self.wire_protocol.shutdown()
def test_find(self):
self._connecting_to_connected()
self.wire_protocol[self.addr1] = self.con
self.wire_protocol[self.addr2] = self.con
self.wire_protocol[self.addr3] = self.con
self.protocol.router.addContact(self.node1)
self.protocol.router.addContact(self.node2)
self.protocol.router.addContact(self.node3)
node = Node(digest("s"))
nearest = self.protocol.router.findNeighbors(node)
spider = ValueSpiderCrawl(self.protocol, node, nearest, KSIZE, ALPHA)
spider.find()
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
self.assertEqual(len(self.proto_mock.send_datagram.call_args_list), 4)
def test_nodesFound(self):
self._connecting_to_connected()
self.wire_protocol[self.addr1] = self.con
self.wire_protocol[self.addr2] = self.con
self.wire_protocol[self.addr3] = self.con
self.protocol.router.addContact(self.node1)
self.protocol.router.addContact(self.node2)
self.protocol.router.addContact(self.node3)
# test resonse with uncontacted nodes
node = Node(digest("s"))
nearest = self.protocol.router.findNeighbors(node)
spider = ValueSpiderCrawl(self.protocol, node, nearest, KSIZE, ALPHA)
response = (True, (self.node1.getProto().SerializeToString(), self.node2.getProto().SerializeToString(),
self.node3.getProto().SerializeToString()))
responses = {self.node1.id: response}
spider._nodesFound(responses)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
self.assertEqual(len(self.proto_mock.send_datagram.call_args_list), 4)
# test all been contacted
spider = ValueSpiderCrawl(self.protocol, node, nearest, KSIZE, ALPHA)
for peer in spider.nearest.getUncontacted():
spider.nearest.markContacted(peer)
response = (True, (self.node1.getProto().SerializeToString(), self.node2.getProto().SerializeToString(),
self.node3.getProto().SerializeToString()))
responses = {self.node2.id: response}
resp = spider._nodesFound(responses)
self.assertTrue(resp is None)
# test didn't happen
spider = ValueSpiderCrawl(self.protocol, node, nearest, KSIZE, ALPHA)
response = (False, (self.node1.getProto().SerializeToString(), self.node2.getProto().SerializeToString(),
self.node3.getProto().SerializeToString()))
responses = {self.node1.id: response}
spider._nodesFound(responses)
self.assertTrue(len(spider.nearest) == 2)
# test got value
val = Value()
val.valueKey = digest("contractID")
val.serializedData = self.protocol.sourceNode.getProto().SerializeToString()
response = (True, ("value", val.SerializeToString()))
responses = {self.node3.id: response}
spider.nearestWithoutValue = NodeHeap(node, 1)
value = spider._nodesFound(responses)
self.assertEqual(value[0], val.SerializeToString())
def test_handleFoundValues(self):
self._connecting_to_connected()
self.wire_protocol[self.addr1] = self.con
self.protocol.router.addContact(self.node1)
self.protocol.router.addContact(self.node2)
self.protocol.router.addContact(self.node3)
node = Node(digest("s"))
nearest = self.protocol.router.findNeighbors(node)
spider = ValueSpiderCrawl(self.protocol, node, nearest, KSIZE, ALPHA)
val = Value()
val.valueKey = digest("contractID")
val.serializedData = self.node1.getProto().SerializeToString()
val1 = val.SerializeToString()
value = spider._handleFoundValues([(val1,)])
self.assertEqual(value[0], val.SerializeToString())
# test handle multiple values
val.serializedData = self.node2.getProto().SerializeToString()
val2 = val.SerializeToString()
found_values = [(val1,), (val1,), (val2,)]
self.assertEqual(spider._handleFoundValues(found_values), (val1,))
# test store value at nearest without value
spider.nearestWithoutValue.push(self.node1)
spider._handleFoundValues(found_values)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
self.assertTrue(len(self.proto_mock.send_datagram.call_args_list) > 1)
self.proto_mock.send_datagram.call_args_list = []
def _connecting_to_connected(self):
remote_synack_packet = packet.Packet.from_data(
42,
self.con.own_addr,
self.con.dest_addr,
ack=0,
syn=True
)
self.con.receive_packet(remote_synack_packet)
self.clock.advance(0)
connection.REACTOR.runUntilCurrent()
self.next_remote_seqnum = 43
m_calls = self.proto_mock.send_datagram.call_args_list
sent_syn_packet = packet.Packet.from_bytes(m_calls[0][0][0])
seqnum = sent_syn_packet.sequence_number
self.handler_mock.reset_mock()
self.proto_mock.reset_mock()
self.next_seqnum = seqnum + 1
source_port=0,
stun_port=19302)
ip_address = response[1]
port = 18467
# Start the kademlia server
this_node = Node(keychain.guid, ip_address, port, keychain.guid_signed_pubkey)
protocol = OpenBazaarProtocol((ip_address, port))
if os.path.isfile('cache.pickle'):
kserver = Server.loadState('cache.pickle', ip_address, port, protocol)
else:
kserver = Server(this_node)
kserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(kserver.protocol)
kserver.saveStateRegularly('cache.pickle', 10)
# start the market server
mserver = network.Server(kserver, keychain.signing_key)
mserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(mserver.protocol)
udpserver = internet.UDPServer(18467, protocol)
udpserver.setServiceParent(application)
class WebResource(resource.Resource):
def __init__(self, kserver_r):
resource.Resource.__init__(self)
self.kserver = kserver_r
class NodeSpiderCrawlTest(unittest.TestCase):
def setUp(self):
self.public_ip = '123.45.67.89'
self.port = 12345
self.own_addr = (self.public_ip, self.port)
self.addr1 = ('132.54.76.98', 54321)
self.addr2 = ('231.76.45.89', 15243)
self.addr3 = ("193.193.111.00", 99999)
self.clock = task.Clock()
connection.REACTOR.callLater = self.clock.callLater
self.proto_mock = mock.Mock(spec_set=rudp.ConnectionMultiplexer)
self.handler_mock = mock.Mock(spec_set=connection.Handler)
self.con = connection.Connection(
self.proto_mock,
self.handler_mock,
self.own_addr,
self.addr1
)
valid_key = "1a5c8e67edb8d279d1ae32fa2da97e236b95e95c837dc8c3c7c2ff7a7cc29855"
self.signing_key = nacl.signing.SigningKey(valid_key, encoder=nacl.encoding.HexEncoder)
verify_key = self.signing_key.verify_key
signed_pubkey = self.signing_key.sign(str(verify_key))
h = nacl.hash.sha512(signed_pubkey)
self.storage = ForgetfulStorage()
self.node = Node(unhexlify(h[:40]), self.public_ip, self.port, signed_pubkey, True)
self.db = Database(filepath=":memory:")
self.protocol = KademliaProtocol(self.node, self.storage, 20, self.db)
self.wire_protocol = OpenBazaarProtocol(self.own_addr, "Full Cone")
self.wire_protocol.register_processor(self.protocol)
self.protocol.connect_multiplexer(self.wire_protocol)
self.handler = self.wire_protocol.ConnHandler([self.protocol], self.wire_protocol)
transport = mock.Mock(spec_set=udp.Port)
ret_val = address.IPv4Address('UDP', self.public_ip, self.port)
transport.attach_mock(mock.Mock(return_value=ret_val), 'getHost')
self.wire_protocol.makeConnection(transport)
self.node1 = Node(digest("id1"), self.addr1[0], self.addr1[1], digest("key1"), True)
self.node2 = Node(digest("id2"), self.addr2[0], self.addr2[1], digest("key2"), True)
self.node3 = Node(digest("id3"), self.addr3[0], self.addr3[1], digest("key3"), True)
def test_find(self):
self._connecting_to_connected()
self.wire_protocol[self.addr1] = self.con
self.wire_protocol[self.addr2] = self.con
self.wire_protocol[self.addr3] = self.con
self.protocol.router.addContact(self.node1)
self.protocol.router.addContact(self.node2)
self.protocol.router.addContact(self.node3)
node = Node(digest("s"))
nearest = self.protocol.router.findNeighbors(node)
spider = NodeSpiderCrawl(self.protocol, node, nearest, 20, 3)
spider.find()
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
self.assertEqual(len(self.proto_mock.send_datagram.call_args_list), 4)
def test_nodesFound(self):
self._connecting_to_connected()
self.wire_protocol[self.addr1] = self.con
self.wire_protocol[self.addr2] = self.con
self.wire_protocol[self.addr3] = self.con
self.protocol.router.addContact(self.node1)
self.protocol.router.addContact(self.node2)
self.protocol.router.addContact(self.node3)
node = Node(digest("s"))
nearest = self.protocol.router.findNeighbors(node)
spider = NodeSpiderCrawl(self.protocol, node, nearest, 20, 3)
response = (True, (self.node1.getProto().SerializeToString(), self.node2.getProto().SerializeToString(),
self.node3.getProto().SerializeToString()))
responses = {self.node1.id: response}
spider._nodesFound(responses)
self.clock.advance(100 * constants.PACKET_TIMEOUT)
connection.REACTOR.runUntilCurrent()
self.assertEqual(len(self.proto_mock.send_datagram.call_args_list), 4)
response = (True, (self.node1.getProto().SerializeToString(), self.node2.getProto().SerializeToString(),
self.node3.getProto().SerializeToString()))
responses = {self.node1.id: response}
nodes = spider._nodesFound(responses)
node_protos = []
for n in nodes:
node_protos.append(n.getProto())
self.assertTrue(self.node1.getProto() in node_protos)
self.assertTrue(self.node2.getProto() in node_protos)
self.assertTrue(self.node3.getProto() in node_protos)
response = (False, (self.node1.getProto().SerializeToString(), self.node2.getProto().SerializeToString(),
self.node3.getProto().SerializeToString()))
responses = {self.node1.id: response}
nodes = spider._nodesFound(responses)
node_protos = []
for n in nodes:
node_protos.append(n.getProto())
self.assertTrue(self.node2.getProto() in node_protos)
self.assertTrue(self.node3.getProto() in node_protos)
def _connecting_to_connected(self):
remote_synack_packet = packet.Packet.from_data(
42,
self.con.own_addr,
self.con.dest_addr,
ack=0,
syn=True
)
self.con.receive_packet(remote_synack_packet)
self.clock.advance(0)
connection.REACTOR.runUntilCurrent()
self.next_remote_seqnum = 43
m_calls = self.proto_mock.send_datagram.call_args_list
sent_syn_packet = packet.Packet.from_bytes(m_calls[0][0][0])
seqnum = sent_syn_packet.sequence_number
self.handler_mock.reset_mock()
self.proto_mock.reset_mock()
self.next_seqnum = seqnum + 1
def run(*args):
TESTNET = args[0]
# database
db = Database(TESTNET)
# key generation
keys = KeyChain(db)
# logging
# TODO: prune this log file and prevent it from getting too large?
logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log")
log.addObserver(FileLogObserver(logFile, level=args[1]).emit)
log.addObserver(FileLogObserver(level=args[1]).emit)
logger = Logger(system="OpenBazaard")
# NAT traversal
port = args[2]
PortMapper().add_port_mapping(port, port, 'UDP')
logger.info("Finding NAT Type...")
try:
response = stun.get_ip_info(source_port=port)
except Exception:
response = stun.get_ip_info()
logger.info("%s on %s:%s" % (response[0], response[1], response[2]))
ip_address = response[1]
port = response[2]
# TODO: use TURN if symmetric NAT
def on_bootstrap_complete(resp):
logger.info("bootstrap complete, downloading outstanding messages...")
mlistener = MessageListenerImpl(ws_factory, db)
mserver.get_messages(mlistener)
mserver.protocol.add_listener(mlistener)
nlistener = NotificationListenerImpl(ws_factory, db)
mserver.protocol.add_listener(nlistener)
# TODO: ping seed node to establish connection if not full cone NAT
# TODO: after bootstrap run through any pending contracts and see if the bitcoin address
# has been funded, if not listen on the address and start the 10 minute delete timer.
protocol = OpenBazaarProtocol((ip_address, port), testnet=TESTNET)
# kademlia
node = Node(keys.guid,
ip_address,
port,
signed_pubkey=keys.guid_signed_pubkey,
vendor=Profile(db).get().vendor)
storage = ForgetfulStorage() if TESTNET else PersistentStorage(db.DATABASE)
try:
kserver = Server.loadState(DATA_FOLDER + 'cache.pickle',
ip_address,
port,
protocol,
db,
on_bootstrap_complete,
storage=storage)
except Exception:
kserver = Server(node, db, KSIZE, ALPHA, storage=storage)
kserver.protocol.connect_multiplexer(protocol)
kserver.bootstrap(
kserver.querySeed("seed.openbazaar.org:8080",
"5b44be5c18ced1bc9400fe5e79c8ab90204f06bebacc04dd9c70a95eaca6e117"))\
.addCallback(on_bootstrap_complete)
# TODO: load seeds from config file
kserver.saveStateRegularly(DATA_FOLDER + 'cache.pickle', 10)
protocol.register_processor(kserver.protocol)
# market
mserver = network.Server(kserver, keys.signing_key, db)
mserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(mserver.protocol)
reactor.listenUDP(port, protocol)
# websockets api
ws_factory = WSFactory("ws://127.0.0.1:18466", mserver, kserver)
ws_factory.protocol = WSProtocol
ws_factory.setProtocolOptions(allowHixie76=True)
listenWS(ws_factory)
webdir = File(".")
web = Site(webdir)
reactor.listenTCP(9000, web, interface=args[4])
# rest api
api = OpenBazaarAPI(mserver, kserver, protocol)
site = Site(api, timeout=None)
reactor.listenTCP(18469, site, interface=args[3])
# TODO: add optional SSL on rest and websocket servers
# blockchain
# TODO: listen on the libbitcoin heartbeat port instead fetching height
def height_fetched(ec, height):
# TODO: re-broadcast any unconfirmed txs in the db using height to find confirmation status
logger.info("Libbitcoin server online")
try:
timeout.cancel()
except Exception:
pass
def timeout(client):
logger.critical("Libbitcoin server offline")
client = None
if TESTNET:
libbitcoin_client = LibbitcoinClient(
"tcp://libbitcoin2.openbazaar.org:9091")
else:
libbitcoin_client = LibbitcoinClient(
"tcp://libbitcoin1.openbazaar.org:9091")
# TODO: load libbitcoin server url from config file
libbitcoin_client.fetch_last_height(height_fetched)
timeout = reactor.callLater(7, timeout, libbitcoin_client)
protocol.set_servers(ws_factory, libbitcoin_client)
reactor.run()
def run(*args):
TESTNET = args[0]
# database
db = Database(TESTNET)
# key generation
keys = KeyChain(db)
# logging
# TODO: prune this log file and prevent it from getting too large?
logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log")
log.addObserver(FileLogObserver(logFile, level=args[1]).emit)
log.addObserver(FileLogObserver(level=args[1]).emit)
logger = Logger(system="OpenBazaard")
# NAT traversal
port = args[2]
PortMapper().add_port_mapping(port, port, 'UDP')
logger.info("Finding NAT Type...")
while True:
try:
response = stun.get_ip_info(source_port=port)
break
except Exception:
pass
logger.info("%s on %s:%s" % (response[0], response[1], response[2]))
ip_address = response[1]
port = response[2]
# TODO: use TURN if symmetric NAT
def on_bootstrap_complete(resp):
logger.info("bootstrap complete, downloading outstanding messages...")
mlistener = MessageListenerImpl(ws_factory, db)
mserver.get_messages(mlistener)
mserver.protocol.add_listener(mlistener)
nlistener = NotificationListenerImpl(ws_factory, db)
mserver.protocol.add_listener(nlistener)
# TODO: ping seed node to establish connection if not full cone NAT
# TODO: after bootstrap run through any pending contracts and see if the bitcoin address
# has been funded, if not listen on the address and start the 10 minute delete timer.
protocol = OpenBazaarProtocol((ip_address, port), response[0], testnet=TESTNET)
# kademlia
node = Node(keys.guid, ip_address, port, signed_pubkey=keys.guid_signed_pubkey, vendor=Profile(db).get().vendor)
storage = ForgetfulStorage() if TESTNET else PersistentStorage(db.DATABASE)
try:
kserver = Server.loadState(DATA_FOLDER + 'cache.pickle', ip_address, port, protocol, db,
on_bootstrap_complete, storage=storage)
except Exception:
kserver = Server(node, db, KSIZE, ALPHA, storage=storage)
kserver.protocol.connect_multiplexer(protocol)
kserver.bootstrap(
kserver.querySeed("seed.openbazaar.org:8080",
"5b44be5c18ced1bc9400fe5e79c8ab90204f06bebacc04dd9c70a95eaca6e117"))\
.addCallback(on_bootstrap_complete)
# TODO: load seeds from config file
kserver.saveStateRegularly(DATA_FOLDER + 'cache.pickle', 10)
protocol.register_processor(kserver.protocol)
# market
mserver = network.Server(kserver, keys.signing_key, db)
mserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(mserver.protocol)
reactor.listenUDP(port, protocol)
# websockets api
ws_factory = WSFactory("ws://127.0.0.1:18466", mserver, kserver)
ws_factory.protocol = WSProtocol
ws_factory.setProtocolOptions(allowHixie76=True)
listenWS(ws_factory)
webdir = File(".")
web = Site(webdir)
reactor.listenTCP(9000, web, interface=args[4])
# rest api
api = OpenBazaarAPI(mserver, kserver, protocol)
site = Site(api, timeout=None)
reactor.listenTCP(18469, site, interface=args[3])
# TODO: add optional SSL on rest and websocket servers
# blockchain
# TODO: listen on the libbitcoin heartbeat port instead fetching height
def height_fetched(ec, height):
# TODO: re-broadcast any unconfirmed txs in the db using height to find confirmation status
logger.info("Libbitcoin server online")
try:
timeout.cancel()
except Exception:
pass
def timeout(client):
logger.critical("Libbitcoin server offline")
client = None
if TESTNET:
libbitcoin_client = LibbitcoinClient(LIBBITCOIN_SERVER_TESTNET)
else:
libbitcoin_client = LibbitcoinClient(LIBBITCOIN_SERVER)
# TODO: load libbitcoin server url from config file
libbitcoin_client.fetch_last_height(height_fetched)
timeout = reactor.callLater(7, timeout, libbitcoin_client)
protocol.set_servers(ws_factory, libbitcoin_client)
reactor.run()