class MyCommunity(TunnelCommunity): master_peer = Peer( "307e301006072a8648ce3d020106052b81040024036a00040112bc352a3f40dd5b6b34f28c82636b3614855179338a1c2f9ac87af17f5af3084955c4f58d9a48d35f6216aac27d68e04cb6c200025046155983a3ae1378320d93e3d865c6ab63b3f11a6c74fc510fa67b2b5f448de756b4114f765c80069e9faa51476604d9d4" .decode('HEX')) def __init__(self, my_peer, endpoint, network): super(MyCommunity, self).__init__(my_peer, endpoint, network) self.settings = TunnelSettings() self.settings.become_exitnode = True print self.settings.become_exitnode def started(self): def print_peers(): print "I am:", self.my_peer, "\nI know:", [ str(p) for p in self.get_peers() ] print self.settings.become_exitnode print "relay_session_keys", self.relay_session_keys for p in self.get_peers(): print("any node", [c.peer.address for c in self.circuits.values()], "exit node", [c.address for c in self.exit_candidates.values()]) # We register a Twisted task with this overlay. # This makes sure that the task ends when this overlay is unloaded. # We call the 'print_peers' function every 5.0 seconds, starting now. self.register_task("print_peers", LoopingCall(print_peers)).start( 5.0, True).addErrback(log.err)
def create_community(ipv8, country, state, city, street, number): property_details = { "country": country, "state": state, "city": city, "street": street, "number": number } community_key = ECCrypto().generate_key(u"medium") community_key_hash = hashlib.sha224( json.dumps(property_details)).hexdigest() community_peer = Peer(community_key) community = BOBChainCommunity(community_peer, ipv8.endpoint, ipv8.network, **property_details) ipv8.overlays.append(community) for walker in [{ 'strategy': "EdgeWalk", 'peers': 20, 'init': { 'edge_length': 4, 'neighborhood_size': 6, 'edge_timeout': 3.0 } }]: strategy_class = _WALKERS.get( walker['strategy'], community.get_available_strategies().get(walker['strategy'])) args = walker['init'] target_peers = walker['peers'] ipv8.strategies.append((strategy_class(community, **args), target_peers)) for config in [('started', )]: reactor.callWhenRunning(getattr(community, config[0]), *config[1:])
class DAppCrowdTrustchainCommunity(TrustChainCommunity): master_peer = Peer( unhexlify( '3081a7301006072a8648ce3d020106052b81040027038192000404267964a5be4a43ee1e59397c6765' '8db0dadc276a89163a3b1f7dec3fdb4cecd94dd80968c9983bfffcd2cd58e8ec7ada6dded7ff3b389b' '85f691ee0e7981326b4b4deb80ad536801d781795a335f501b80c00b479f076f0384fa7fa3bd940f76' '82840dae77d46f938f49743acb5d2ab723046982608d60f2398853f9898d97e4e3b35fa19eb92f0ba2' 'c1570a31ae72')) DB_CLASS = DAppCrowdTrustChainDatabase def __init__(self, *args, **kwargs): super(DAppCrowdTrustchainCommunity, self).__init__(*args, **kwargs) self.persistence.my_peer = self.my_peer def get_github_profile(self, username): """ Get the GitHub profile for a given username. """ return requests.get("https://api.github.com/users/%s" % username).json() def import_github_profile(self, username): """ Import your GitHub profile. """ profile_info = self.get_github_profile(username) #mid = self.my_peer.mid.encode('hex') #if not profile_info['bio'] or mid not in profile_info['bio']: # return fail(RuntimeError("your member ID (%s) should be in the GitHub bio!" % mid)) # Challenge successful, create TrustChain block tx = { 'platform': 'github', 'info': { 'username': username, 'followers': profile_info['followers'] } } return self.create_source_block(block_type='devid_connection', transaction=tx) def add_skill(self, name): """ Add a skill to your developer portfolio. """ tx = {'name': name} return self.create_source_block(block_type='devid_skill', transaction=tx) def endorse_skill(self, public_key, block_num): """ Endorse a specific skill of another user, identified by a public key and block number """ source_block = self.persistence.get(public_key, block_num) return self.create_link(source_block)
def get_peer_from_public_key(self, public_key): if type(public_key) == bytes: b = public_key key = default_eccrypto.key_from_public_bin(public_key) else: b = public_key.key_to_bin() key = public_key for peer in self.get_peers(): if peer.public_key.key_to_bin() == b: return peer return Peer(key)
class MyCommunity(Community): master_peer = Peer(ECCrypto().generate_key(u"medium")) def started(self): async def print_peers(): print("I am:", self.my_peer, "\nI know:", [str(p) for p in self.get_peers()]) # We register a asyncio task with this overlay. # This makes sure that the task ends when this overlay is unloaded. # We call the 'print_peers' function every 5.0 seconds, starting now. self.register_task("print_peers", print_peers, interval=5.0, delay=0)
class TrustClient(TrustChainCommunity): master_peer = Peer( "307e301006072a8648ce3d020106052b81040024036a000401142bae9f90e77434a6ddda16c9bc913a3440366b9eedc9e57a660789e10aa3f470c1f7ae769083a3494be79ad78165caed85da009a7e897bd51e531e9fd90465c038993d2bbe6646b592872cb432c818ce9fa6e3ae0382a76d39ef982fb85801279def1409a86a" .decode('HEX')) DB_NAME = 'trustchain_client' def __init__(self, my_peer, endpoint, network): super(TrustClient, self).__init__(my_peer, endpoint, network) # self.add_listener(TestBlockListener(), ['test']) self.count = 0 self.his_key = '' self.my_key = self.my_peer.public_key.key_to_bin() self._balance = 0 def started(self): def print_peers(): print "I am:", self.my_peer, "\nI know:", [ str(p) for p in self.get_peers() ] for p in self.get_peers(): self.his_node = p self.his_pubkey = p.public_key.key_to_bin() self.send_sign() self.check_db(self.count) self.count += 1 self.register_task("print_peers", LoopingCall(print_peers)).start(5.0, True) \ .addErrback(log.err) def check_db(self, count): print "persistence", count, self.persistence.get(self.his_key, count) # print "persistence", self.persistence._getall(u"", ()) def send_sign(self): transaction = self.create_transaction() print transaction self.sign_block(self.his_node, public_key=self.his_pubkey, block_type='test', transaction=transaction) def create_transaction(self): debit = 0 credit = 1 self._balance += debit - credit bill = { 'identity': 'client->', 'debit': debit, 'credit': credit, 'balance': self._balance } return bill
class MyCommunity(Community): # master_peer = Peer(ECCrypto().generate_key(u"medium")) master_peer = Peer( "307e301006072a8648ce3d020106052b81040024036a00040112bc352a3f40dd5b6b34f28c82636b3614855179338a1c2f9ac87af17f5af3084955c4f58d9a48d35f6216aac27d68e04cb6c200025046155983a3ae1378320d93e3d865c6ab63b3f11a6c74fc510fa67b2b5f448de756b4114f765c80069e9faa51476604d9d4" .decode('HEX')) def started(self): def print_peers(): print "I am:", self.my_peer, "\nI know:", [str(p) for p in self.get_peers()] # We register a Twisted task with this overlay. # This makes sure that the task ends when this overlay is unloaded. # We call the 'print_peers' function every 5.0 seconds, starting now. self.register_task("print_peers", LoopingCall(print_peers)).start(5.0, True)
class TrustServer(TrustChainCommunity): master_peer = Peer( "307e301006072a8648ce3d020106052b81040024036a000401142bae9f90e77434a6ddda16c9bc913a3440366b9eedc9e57a660789e10aa3f470c1f7ae769083a3494be79ad78165caed85da009a7e897bd51e531e9fd90465c038993d2bbe6646b592872cb432c818ce9fa6e3ae0382a76d39ef982fb85801279def1409a86a" .decode('HEX')) DB_NAME = 'trustchain_server' def __init__(self, my_peer, endpoint, network): super(TrustServer, self).__init__(my_peer, endpoint, network) # self.add_listener(TestBlockListener(), ['test']) # self.my_key = self.my_peer.public_key.key_to_bin() self.his_pubkey = '' self.count = 0 self._balance = 0 def started(self): def start_communication(): for p in self.get_peers(): print "New host {} join the network".format(p) self.my_key = self.my_peer.public_key.key_to_bin() self.his_node = p self.his_pubkey = p.public_key.key_to_bin() self.send_sign() self.check_db(self.count) self.register_task("start_communication", LoopingCall(start_communication)).start(5.0, True) \ .addErrback(log.err) def send_sign(self): transaction = self.create_transaction() print transaction self.sign_block(self.his_node, public_key=self.his_pubkey, block_type='test', transaction=transaction) def create_transaction(self): debit = 1 credit = 0 self._balance += debit - credit bill = { 'identity': 'server->', "debit": debit, "credit": credit, "balance": self._balance } return bill def check_db(self, count): print "from persistence", count, self.persistence.get( self.my_key, count)
class MyCommunity(TunnelCommunity): master_peer = Peer( "307e301006072a8648ce3d020106052b81040024036a00040112bc352a3f40dd5b6b34f28c82636b3614855179338a1c2f9ac87af17f5af3084955c4f58d9a48d35f6216aac27d68e04cb6c200025046155983a3ae1378320d93e3d865c6ab63b3f11a6c74fc510fa67b2b5f448de756b4114f765c80069e9faa51476604d9d4" .decode('HEX')) def __init__(self, my_peer, endpoint, network): super(MyCommunity, self).__init__(my_peer, endpoint, network) self.settings = TunnelSettings() self.settings.become_exitnode = False self.nodes = {} # self.build_tunnels(1) @inlineCallbacks def build_conn(self): yield self.introduce_nodes() self.nodes[0].overlay.build_tunnels(1) @inlineCallbacks def introduce_nodes(self): for node in self.nodes: for other in self.nodes: if other != node: print(other.endpoint.get_address()) node.overlay.walk_to(other.endpoint.wan_address) # I know: ['Peer<145.94.160.220:8092, xDPZmlsmAw/fGvdp+fTH0e9Ra78=>', 'Peer<145.94.160.220:8090, 4uQM2VNhSL0gbBHiVcEzxQJLI50=>'] # yield self.deliver_messages() def started(self): def print_peers(): print "I am:", self.my_peer, "\nI know:", [ str(p) for p in self.get_peers() ] print "relay_session_keys", self.relay_session_keys for p in self.get_peers(): print("any node", [c.peer.address for c in self.circuits.values()], "exit node", [c.address for c in self.exit_candidates.values()]) if p not in self.nodes: self.nodes[p] = None # We register a Twisted task with this overlay. # This makes sure that the task ends when this overlay is unloaded. # We call the 'print_peers' function every 5.0 seconds, starting now. self.register_task("print_peers", LoopingCall(print_peers)).start(5.0, True)
def create_community(self, country, state, city, street, number): property_details = {"country": country, "state": state, "city": city, "street": street, "number": number} community_key = ECCrypto().generate_key(u"medium") community_peer = Peer(community_key) print "Community peer %s ...." % community_peer community = BOBChainCommunity(community_peer, self.ipv8.endpoint, self.ipv8.network, **property_details) self.ipv8.overlays.append(community) for walker in [{ 'strategy': "EdgeWalk", 'peers': 20, 'init': { 'edge_length': 4, 'neighborhood_size': 6, 'edge_timeout': 3.0 } }]: strategy_class = _WALKERS.get(walker['strategy'], community.get_available_strategies().get(walker['strategy'])) args = walker['init'] target_peers = walker['peers'] self.ipv8.strategies.append((strategy_class(community, **args), target_peers)) for config in [('started',)]: reactor.callWhenRunning(getattr(community, config[0]), *config[1:]) communities[country][state][city][street][number] = community community_key_hash = hashlib.sha224(json.dumps(property_details)).hexdigest() with open("keys\\" + str(community_key_hash) + ".pem", 'w') as f: f.write(community_key.key_to_bin()) with open('property_to_key_mappings.json', 'w') as file: l = [] for country, states in communities.items(): for state, cities in states.items(): for city, streets in cities.items(): for street, numbers in streets.items(): for number in numbers: l.append([{ "country": country, "state": state, "city": city, "street": street, "number": number, }, community_key_hash]) json.dump(l, file)
class MyCommunity(Community): master_peer = Peer( "307e301006072a8648ce3d020106052b81040024036a00040112bc352a3f40dd5b6b34f28c82636b3614855179338a1c2f9ac87af17f5af3084955c4f58d9a48d35f6216aac27d68e04cb6c200025046155983a3ae1378320d93e3d865c6ab63b3f11a6c74fc510fa67b2b5f448de756b4114f765c80069e9faa51476604d9d4" .decode('HEX')) # master_peer = Peer( # "307e301006072a8648ce3d020106052b81040024036a000400d6911c823cfddc8842131e0306795ba9e652f8f0ecfe627b70d5469b30de14d3289b2899ffb655bc8e01631c9a7fbfecd5db42017718bdcd0e5acf218494e4085277e048ecb34e30218d0f3131c45627b345789753109b570d987c679ecb99a9a85c072de67bc6" # .decode('HEX')) def started(self): def print_peers(): print "I am:", self.endpoint.get_address(), repr(self.my_peer.mid), "\nI know:", [str(p) for p in self.get_peers()] # print self.network.services_per_peer # print "address", self.network._all_addresses # print "blacklist", self.network.blacklist, self.network.blacklist_mids # We register a Twisted task with this overlay. # This makes sure that the task ends when this overlay is unloaded. # We call the 'print_peers' function every 5.0 seconds, starting now. self.register_task("print_peers", LoopingCall(print_peers)).start(5.0, True).addErrback(log.err)
class MyCommunity(Community): master_peer = Peer( "307e301006072a8648ce3d020106052b81040024036a000400d6911c823cfddc8842131e0306795ba9e652f8f0ecfe627b70d5469b30de14d3289b2899ffb655bc8e01631c9a7fbfecd5db42017718bdcd0e5acf218494e4085277e048ecb34e30218d0f3131c45627b345789753109b570d987c679ecb99a9a85c072de67bc6" .decode('HEX')) def started(self): def print_peers(): print "I am:", self.endpoint.get_address(), repr( self.my_peer.mid), "\nI know:", [ str(p) for p in self.get_peers() ] print "address", self.network._all_addresses print "blacklist", self.network.blacklist, self.network.blacklist_mids # We register a Twisted task with this overlay. # This makes sure that the task ends when this overlay is unloaded. # We call the 'print_peers' function every 5.0 seconds, starting now. self.register_task("print_peers", LoopingCall(print_peers)).start( 5.0, True).addErrback(log.err)
class MyCommunity(Community): master_peer = Peer( "307e301006072a8648ce3d020106052b81040024036a00040112bc352a3f40dd5b6b34f28c82636b3614855179338a1c2f9ac87af17f5af3084955c4f58d9a48d35f6216aac27d68e04cb6c200025046155983a3ae1378320d93e3d865c6ab63b3f11a6c74fc510fa67b2b5f448de756b4114f765c80069e9faa51476604d9d4" .decode('HEX')) def started(self): def print_peers(): print "walk to .." self.walk_to(('127.0.0.1', 8090)) print "I am:", self.endpoint.get_address(), repr( self.my_peer.mid), "\nI know:", [ str(p) for p in self.get_peers() ] # print "address", self.network._all_addresses # We register a Twisted task with this overlay. # This makes sure that the task ends when this overlay is unloaded. # We call the 'print_peers' function every 5.0 seconds, starting now. self.register_task("print_peers", LoopingCall(print_peers)).start( 5.0, True).addErrback(log.err)
from socks5_ipv8.Message import Message from pyipv8.ipv8_service import IPv8, _COMMUNITIES from pyipv8.ipv8.configuration import get_default_configuration from pyipv8.ipv8.messaging.anonymization.community import TunnelCommunity, TunnelSettings, CIRCUIT_STATE_READY # master_peer_init = Peer( # "307e301006072a8648ce3d020106052b81040024036a00040112bc352a3f40dd5b6b34f28c82636b3614855179338a1c2f9ac87af17f5af3084955c4f58d9a48d35f6216aac27d68e04cb6c200025046155983a3ae1378320d93e3d865c6ab63b3f11a6c74fc510fa67b2b5f448de756b4114f765c80069e9faa51476604d9d4" # .decode('HEX')) # # master_peer_init = Peer( # "307e301006072a8648ce3d020106052b81040024036a0004017dc7230411163214d17a4a1c3b2ec63c4ce5e56509041bcebb8f8e55c1befea14101e2499d8dbd0d9d1412fade2e8079fa171000fea5c0ad4ace791b6cb1708e46ccb6709afe90a18f303ad6f50afb9fcb64bf929419b00ba87ed81ca6b2e7100b75f53937ffe4" # .decode('HEX')) master_peer_init = Peer( "307e301006072a8648ce3d020106052b81040024036a000401487c28074a4594a1089cb2efa6788678c1053cc42d07284a70dd06d8210ef8d433c98728a24f8ccca1634e62c0d986b2af97620167d013d284574b7095ae3029fd5b679d59f1283815d575c66c95f996ccef2173fd652893b13a23c8209c8eb39a0a10985b8f4d" .decode('Hex')) # master_peer_init = Peer( # "307e301006072a8648ce3d020106052b81040024036a000400e0ba96c684c264342852cf25a75868524589dfbf81454074ea6ea379d1c3a6f9b85e3007d970916e18aeca17d6e99ce52c4a24013bf8ee92ee291d92cdc34ce0f59f1b98027e979f0f6157a8f5579356791fa7a88bd6a697d8ba3bce81d6547e46e4f76e135922" # .decode('Hex') # ) logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(levelname)-8s %(message)s', datefmt='%Y-%m-%d %H:%M:%S', filemode='a+') # IPv8 node # ----------------------------------------------------------------------------------------------------------------------
import logging import time import random # from socks5_udp.database import ProxyDatabase # from socks5_udp.payload import IdentityRequestPayload, IdentityResponsePayload, TargetAddressPayload, Message, \ # ACKPayload key1 = ECCrypto().generate_key(u"medium") # master_peer_init = Peer(key1) logging.info(key1.pub().key_to_bin().encode('HEX')) # master_peer_init = Peer(key1.pub().key_to_bin().encode('HEX').decode('HEX')) print key1.pub().key_to_bin().encode('HEX') master_peer_init = Peer( "307e301006072a8648ce3d020106052b81040024036a00040112bc352a3f40dd5b6b34f28c82636b3614855179338a1c2f9ac87af17f5af3084955c4f58d9a48d35f6216aac27d68e04cb6c200025046155983a3ae1378320d93e3d865c6ab63b3f11a6c74fc510fa67b2b5f448de756b4114f765c80069e9faa51476604d9d4" .decode('HEX')) class Server(Community): master_peer = master_peer_init DB_NAME = 'trustchain_server' def __init__(self, my_peer, endpoint, network): super(Server, self).__init__(my_peer, endpoint, network) self.host_dict = {} self.client_dict = {} self.state = 'ADDRESS_FROM_SOCKS5' self.remote_protocol = None self.remote_factory = None self.buffer = None
from twisted.internet import protocol from twisted.internet.task import LoopingCall from twisted.internet.protocol import Factory, ClientFactory from pyipv8.ipv8.peer import Peer from socks5_ipv8.Message import Message from pyipv8.ipv8_service import IPv8, _COMMUNITIES from pyipv8.ipv8.configuration import get_default_configuration from pyipv8.ipv8.messaging.anonymization.community import TunnelCommunity, TunnelSettings, CIRCUIT_STATE_READY # master_peer_init = Peer( # "307e301006072a8648ce3d020106052b81040024036a00040112bc352a3f40dd5b6b34f28c82636b3614855179338a1c2f9ac87af17f5af3084955c4f58d9a48d35f6216aac27d68e04cb6c200025046155983a3ae1378320d93e3d865c6ab63b3f11a6c74fc510fa67b2b5f448de756b4114f765c80069e9faa51476604d9d4" # .decode('HEX')) master_peer_init = Peer( "307e301006072a8648ce3d020106052b81040024036a0004017dc7230411163214d17a4a1c3b2ec63c4ce5e56509041bcebb8f8e55c1befea14101e2499d8dbd0d9d1412fade2e8079fa171000fea5c0ad4ace791b6cb1708e46ccb6709afe90a18f303ad6f50afb9fcb64bf929419b00ba87ed81ca6b2e7100b75f53937ffe4" .decode('HEX')) logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(levelname)-8s %(message)s', datefmt='%Y-%m-%d %H:%M:%S', filemode='a+') # IPv8 node # ---------------------------------------------------------------------------------------------------------------------- # For peer discovery ... class MultiProxy(TunnelCommunity): master_peer = master_peer_init def __init__(self, my_peer, endpoint, network):
class DAppCrowdCommunity(Community, BlockListener): master_peer = Peer( unhexlify( '3081a7301006072a8648ce3d020106052b81040027038192000406297d96eafe1f25408ecc44062310' '67d4d644bf837e051d64fee582788544b360d30f21004eeb7f3425331423c7d5c9cc56ad7358558a43' '6fd46ac53dc9f25575f4b28a512c8ca002aaab6d820800634f009a8d509e600a9c7f9a171e9d0c3a66' 'd2a823a5f6d6d2bfb5d96c1725163b03242a1e6b7d51ae110d5666d696640f4e3633bd9da346397dcd' '0dd47bd6fe29')) def __init__(self, *args, **kwargs): working_directory = kwargs.pop('working_directory', '') self.trustchain = kwargs.pop('trustchain') self.ipfs_api = kwargs.pop('ipfs_api') super(DAppCrowdCommunity, self).__init__(*args, **kwargs) self.persistence = DAppCrowdDatabase(working_directory, 'dappcrowd', self.ipfs_api, self.trustchain.persistence) self.persistence.my_peer = self.my_peer self.trustchain.add_listener( self, ['dappcoder_project', 'dappcoder_submission', 'dappcoder_review']) def should_sign(self, block): if block.type == 'dappcrowd_review_request': return False # We counter-sign this one manually return True def received_block(self, block): if block.type == 'dappcoder_project' and not self.persistence.has_project( block.public_key, block.transaction['id']): self.persistence.add_project(block) if block.type == 'dappcoder_submission' and not self.persistence.has_submission( block.public_key, block.transaction['id']): self.persistence.add_submission(block) if block.type == 'dappcoder_review' and not self.persistence.has_review( block.public_key, block.transaction['id']): self.persistence.add_review(block) def create_project(self, name, specifications, deadline, reward, currency, min_reviews): """ Create a new project. """ # Add specifications to IPFS pointer = self.ipfs_api.add_json({"specifications": specifications}) tx = { 'id': self.persistence.get_next_project_id( self.trustchain.my_peer.public_key.key_to_bin()), 'name': name, 'specifications': pointer, 'deadline': deadline, 'reward': reward, 'currency': currency, 'min_reviews': min_reviews, 'notary_signature': 'a' * 64, } return self.trustchain.create_source_block( block_type='dappcoder_project', transaction=tx) def create_submission(self, project_public_key, project_id, submission): """ Create a submission for a given project. """ if not self.persistence.has_project(project_public_key, project_id): raise RuntimeError("This project does not exist.") # TODO check deadline expiration! # Add submission to IPFS pointer = self.ipfs_api.add_json({"submission": submission}) tx = { 'project_pk': project_public_key, 'project_id': project_id, 'id': self.persistence.get_next_submission_id( self.trustchain.my_peer.public_key.key_to_bin()), 'submission': pointer } return self.trustchain.create_source_block( block_type='dappcoder_submission', transaction=tx) def create_review(self, submission_public_key, submission_id, review): """ Create a review for a given submission. """ # Add review to IPFS pointer = self.ipfs_api.add_json({"review": review}) tx = { 'submission_pk': submission_public_key, 'submission_id': submission_id, 'id': self.persistence.get_next_review_id( self.trustchain.my_peer.public_key.key_to_bin()), 'review': pointer } return self.trustchain.create_source_block( block_type='dappcoder_review', transaction=tx) def request_review(self, submission_id, requester_pub_key): """ Request a review for a submission from another peer. """ tx = {'submission_id': submission_id} peer = self.network.get_verified_by_public_key_bin(requester_pub_key) self.trustchain.sign_block(peer, requester_pub_key, block_type='dappcrowd_review_request', transaction=tx) def respond_to_review_request(self, block_hash, accept): """ Accept/reject a review request for a given block hash """ block = self.trustchain.persistence.get_block_with_hash(block_hash) peer = self.network.get_verified_by_public_key_bin(block.public_key) self.trustchain.sign_block(peer, linked=block, additional_info={'accept': accept}) def unload(self): super(DAppCrowdCommunity, self).unload() # Close the persistence layer self.persistence.close()
# master_peer_init = Peer( # "307e301006072a8648ce3d020106052b81040024036a00040112bc352a3f40dd5b6b34f28c82636b3614855179338a1c2f9ac87af17f5af3084955c4f58d9a48d35f6216aac27d68e04cb6c200025046155983a3ae1378320d93e3d865c6ab63b3f11a6c74fc510fa67b2b5f448de756b4114f765c80069e9faa51476604d9d4" # .decode('HEX')) # # master_peer_init = Peer( # "307e301006072a8648ce3d020106052b81040024036a0004017dc7230411163214d17a4a1c3b2ec63c4ce5e56509041bcebb8f8e55c1befea14101e2499d8dbd0d9d1412fade2e8079fa171000fea5c0ad4ace791b6cb1708e46ccb6709afe90a18f303ad6f50afb9fcb64bf929419b00ba87ed81ca6b2e7100b75f53937ffe4" # .decode('HEX')) # master_peer_init = Peer( # "307e301006072a8648ce3d020106052b81040024036a000401487c28074a4594a1089cb2efa6788678c1053cc42d07284a70dd06d8210ef8d433c98728a24f8ccca1634e62c0d986b2af97620167d013d284574b7095ae3029fd5b679d59f1283815d575c66c95f996ccef2173fd652893b13a23c8209c8eb39a0a10985b8f4d" # .decode('Hex') # ) master_peer_init = Peer( "307e301006072a8648ce3d020106052b81040024036a000400e0ba96c684c264342852cf25a75868524589dfbf81454074ea6ea379d1c3a6f9b85e3007d970916e18aeca17d6e99ce52c4a24013bf8ee92ee291d92cdc34ce0f59f1b98027e979f0f6157a8f5579356791fa7a88bd6a697d8ba3bce81d6547e46e4f76e135922" .decode('Hex') ) logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(levelname)-8s %(message)s', datefmt='%Y-%m-%d %H:%M:%S', filemode='a+') # IPv8 node # ---------------------------------------------------------------------------------------------------------------------- # For peer discovery ... class MultiProxy(TunnelCommunity): master_peer = master_peer_init def __init__(self, my_peer, endpoint, network): super(MultiProxy, self).__init__(my_peer, endpoint, network)
self.message = message def to_pack_list(self): return [('raw', self.message)] @classmethod def from_unpack_list(cls, message): return cls(message) key1 = ECCrypto().generate_key(u"medium") # master_peer_init = Peer(key1) logging.info(key1.pub().key_to_bin().encode('HEX')) # master_peer_init = Peer(key1.pub().key_to_bin().encode('HEX').decode('HEX')) master_peer_init = Peer( "307e301006072a8648ce3d020106052b81040024036a00040046d529db97b697d56b33d7935cd9213df309a7c3eb96a15c494ee72697f1d192c649d0666e903977de4a412649a28c970af0940155bfe7d7e0abd13e0bf7673b65f087a976deac412464c4959da06cc36945eee5017ec2007cca71841c6cddce8a84e525e64c88" .decode('HEX')) class MyServer(Community): master_peer = master_peer_init def __init__(self, my_peer, endpoint, network): super(MyServer, self).__init__(my_peer, endpoint, network) self.decode_map[chr(1)] = self.on_message self.addr_set = set() self.conn_socks = {} def started(self): def start_communication(): for p in self.get_peers():