예제 #1
0
def setup_test(window=1, packet_size=1000, packets=10000):
    """
    Create two nodes who will be sending packets to each other.

    :param window: the window size for packets (1 is synchronous)
    :param packet_size: the size of each packet
    :param packets: the number of packets to send in the experiment
    :return: the deferred that fires once the experiment is complete
    """
    configuration = get_default_configuration()
    configuration['overlays'] = []
    configuration['keys'] = []

    master_peer = Peer(ECCrypto().generate_key(u"low"))

    peer_ipv8 = IPv8(configuration)
    peer_ipv8.keys = {'my_peer': Peer(ECCrypto().generate_key(u"low"))}
    peer_ipv8.overlays = [
        LoadOverlay(master_peer, peer_ipv8.keys['my_peer'], peer_ipv8.endpoint,
                    peer_ipv8.network, window, packet_size, packets)
    ]

    counterparty_ipv8 = IPv8(configuration)
    counterparty_ipv8.keys = {'my_peer': Peer(ECCrypto().generate_key(u"low"))}
    counterparty_ipv8.overlays = [
        LoadOverlay(master_peer, counterparty_ipv8.keys['my_peer'],
                    counterparty_ipv8.endpoint, counterparty_ipv8.network, 0,
                    packet_size, packets)
    ]

    peer_ipv8.overlays[0].send(counterparty_ipv8.endpoint.get_address())

    return DeferredList(
        [peer_ipv8.overlays[0].done, counterparty_ipv8.overlays[0].done])
예제 #2
0
    def connect_peer(self, mid):
        matched_node = MockObject()
        matched_node.mid = mid
        matched_node.public_key = ECCrypto().generate_key("low").pub()

        nearby_node = MockObject()
        nearby_node.mid = unhexlify('b' * 20)
        nearby_node.public_key = ECCrypto().generate_key("low").pub()

        return succeed([matched_node, nearby_node])
예제 #3
0
class MyCommunity(Community):
    master_peer = Peer(ECCrypto().generate_key(u"medium"))

    def started(self):
        async def check_peers():
            global INSTANCES, LOW_EDGE, LOW_EDGE_PEER, START_TIME
            if self.get_peers():
                if LOW_EDGE and self.my_peer != LOW_EDGE_PEER:
                    print("%.4f,%.4f" % (LOW_EDGE, time.time() - START_TIME))

                    async def shutdown():
                        for instance in INSTANCES:
                            await instance.stop(False)
                        get_event_loop().stop()

                    ensure_future(shutdown())
                else:
                    LOW_EDGE = time.time() - START_TIME
                    LOW_EDGE_PEER = self.my_peer

        self.register_task("check_peers", check_peers, interval=0.1, delay=0)

    def create_introduction_response(self,
                                     lan_socket_address,
                                     socket_address,
                                     identifier,
                                     introduction=None):
        return super(MyCommunity, self).create_introduction_response(
            lan_socket_address, socket_address, identifier, introduction, b'1')

    def create_introduction_request(self, socket_address):
        return super(MyCommunity,
                     self).create_introduction_request(socket_address, b'2')
예제 #4
0
    def test_peer_inequality_key(self):
        """
        Check if peers with a different key and same address are not equal.
        """
        other = Peer(ECCrypto().generate_key(u"very-low"), self.peer.address)

        self.assertNotEqual(self.peer, other)
예제 #5
0
class MyCommunity(Community):
    master_peer = Peer(ECCrypto().generate_key(u"medium"))

    def started(self):
        def check_peers():
            global INSTANCES, LOW_EDGE, LOW_EDGE_PEER, START_TIME
            if self.get_peers():
                if LOW_EDGE and self.my_peer != LOW_EDGE_PEER:
                    for instance in INSTANCES:
                        instance.stop(False)
                    reactor.callFromThread(reactor.stop)
                    print("%.4f,%.4f" % (LOW_EDGE, time.time() - START_TIME))
                else:
                    LOW_EDGE = time.time() - START_TIME
                    LOW_EDGE_PEER = self.my_peer

        self.register_task("check_peers",
                           LoopingCall(check_peers)).start(0.1, True)

    def create_introduction_response(self,
                                     lan_socket_address,
                                     socket_address,
                                     identifier,
                                     introduction=None):
        return super(MyCommunity, self).create_introduction_response(
            lan_socket_address, socket_address, identifier, introduction, b'1')

    def create_introduction_request(self, socket_address):
        return super(MyCommunity,
                     self).create_introduction_request(socket_address, b'2')
예제 #6
0
    def __init__(self, crypto_curve, overlay_class, *args, **kwargs):
        self.endpoint = AutoMockEndpoint()
        self.endpoint.open()
        self.network = Network()
        self.my_peer = Peer(ECCrypto().generate_key(crypto_curve), self.endpoint.wan_address)
        self.overlay = overlay_class(self.my_peer, self.endpoint, self.network, *args, **kwargs)
        self.discovery = MockWalk(self.overlay)

        self.overlay.my_estimated_wan = self.endpoint.wan_address
        self.overlay.my_estimated_lan = self.endpoint.lan_address
예제 #7
0
    def bootstrap_new_identity(self, amount):
        """
        One-way payment channel.
        Create a new temporary identity, and transfer funds to the new identity.
        A different party can then take the result and do a transfer from the temporary identity to itself
        """

        # Create new identity for the temporary identity
        crypto = ECCrypto()
        tmp_peer = Peer(crypto.generate_key(u"curve25519"))

        # Create the transaction specification
        transaction = {'up': 0, 'down': amount, 'type': b'tribler_bandwidth'}

        # Create the two half blocks that form the transaction
        local_half_block = TriblerBandwidthBlock.create(
            b'tribler_bandwidth',
            transaction,
            self.trustchain.persistence,
            self.trustchain.my_peer.public_key.key_to_bin(),
            link_pk=tmp_peer.public_key.key_to_bin())
        local_half_block.sign(self.trustchain.my_peer.key)
        tmp_half_block = TriblerBandwidthBlock.create(
            b'tribler_bandwidth',
            transaction,
            self.trustchain.persistence,
            tmp_peer.public_key.key_to_bin(),
            link=local_half_block,
            link_pk=self.trustchain.my_peer.public_key.key_to_bin())
        tmp_half_block.sign(tmp_peer.key)

        self.trustchain.persistence.add_block(local_half_block)
        self.trustchain.persistence.add_block(tmp_half_block)

        # Create the bootstrapped identity format
        block = {
            'block_hash': b64encode(tmp_half_block.hash),
            'sequence_number': tmp_half_block.sequence_number
        }

        result = {
            'private_key': b64encode(tmp_peer.key.key_to_bin()),
            'transaction': {
                'up': amount,
                'down': 0
            },
            'block': block
        }
        return result
예제 #8
0
    async def load_tunnel_community_in_session(self,
                                               session,
                                               exitnode=False,
                                               start_lt=False):
        """
        Load the tunnel community in a given session. We are using our own tunnel community here instead of the one
        used in Tribler.
        """
        await self.sanitize_network(session)

        keypair = ECCrypto().generate_key(u"curve25519")
        tunnel_peer = Peer(keypair)
        session.config.set_tunnel_community_exitnode_enabled(exitnode)
        overlay = self.test_class(tunnel_peer,
                                  session.ipv8.endpoint,
                                  session.ipv8.network,
                                  tribler_session=session,
                                  settings={"max_circuits": 1})
        if exitnode:
            overlay.settings.peer_flags.add(PEER_FLAG_EXIT_ANY)
        overlay._use_main_thread = False
        overlay.dht_provider = MockDHTProvider(
            Peer(overlay.my_peer.key, overlay.my_estimated_wan))
        overlay.settings.remove_tunnel_delay = 0
        session.ipv8.overlays.append(overlay)

        await overlay.wait_for_socks_servers()

        if start_lt:
            # If libtorrent tries to connect to the socks5 servers before they are loaded,
            # it will never recover (on Mac/Linux with Libtorrent >=1.2.0). Therefore, we start
            # libtorrent afterwards.
            tunnel_community_ports = session.config.get_tunnel_community_socks5_listen_ports(
            )
            session.config.set_anon_proxy_settings(
                2, ("127.0.0.1", tunnel_community_ports))
            session.dlmgr = DownloadManager(session)
            session.dlmgr.initialize()
            session.dlmgr.is_shutdown_ready = lambda: True

        return overlay
예제 #9
0
async def start_communities():
    # Override the Community master peers so we don't interfere with the live network
    # Also hook in our custom logic for introduction responses
    for community_cls in _COMMUNITIES.values():
        community_cls.master_peer = Peer(ECCrypto().generate_key(u"medium"))
        community_cls.introduction_response_callback = custom_intro_response_cb

    # Create two peers with separate working directories
    previous_workdir = getcwd()
    for i in [1, 2]:
        configuration = get_default_configuration()
        configuration['port'] = 12000 + randint(0, 10000)
        configuration['logger']['level'] = "CRITICAL"
        for overlay in configuration['overlays']:
            overlay['walkers'] = [walker for walker in overlay['walkers'] if walker['strategy'] in _WALKERS]
        workdir = path.abspath(path.join(path.dirname(__file__), str(i)))
        if not path.exists(workdir):
            mkdir(workdir)
        chdir(workdir)
        await IPv8(configuration).start()
        chdir(previous_workdir)
예제 #10
0
    async def setUp(self):
        """
        Setup various variables and load the tunnel community in the main downloader session.
        """
        await TestAsServer.setUp(self)
        self.seed_tdef = None
        self.sessions = []
        self.session2 = None
        self.bypass_dht = False
        self.seed_config = None
        self.tunnel_community_seeder = None

        self.eccrypto = ECCrypto()
        ec = self.eccrypto.generate_key(u"curve25519")
        self.test_class = TriblerTunnelCommunity
        self.test_class.master_peer = Peer(ec)

        self.tunnel_community = await self.load_tunnel_community_in_session(
            self.session, exitnode=True, start_lt=True)
        self.session.tunnel_community = self.tunnel_community  # Magic!
        self.tunnel_communities = []
예제 #11
0
class TestPeer(unittest.TestCase):

    test_key = ECCrypto().generate_key(u"very-low")

    def setUp(self):
        super(TestPeer, self).setUp()
        self.peer = Peer(TestPeer.test_key, ("1.2.3.4", 5))

    def test_default_timestamp(self):
        """
        Check if the default Lamport timestamp of a Peer is 0.
        """
        self.assertEqual(self.peer.get_lamport_timestamp(), 0)

    def test_increment_timestamp(self):
        """
        Check if the Lamport timestamp of a Peer can be incremented.
        """
        self.peer.update_clock(1)

        self.assertEqual(self.peer.get_lamport_timestamp(), 1)

    def test_increase_timestamp(self):
        """
        Check if the Lamport timestamp of a Peer can be increased arbitrarily.
        """
        self.peer.update_clock(42)

        self.assertEqual(self.peer.get_lamport_timestamp(), 42)

    def test_decrease_timestamp(self):
        """
        Check if the Lamport timestamp of a Peer cannot be decreased.
        """
        self.peer.update_clock(-1)

        self.assertEqual(self.peer.get_lamport_timestamp(), 0)

    def test_peer_equality(self):
        """
        Check if peers with the same key and address are equal.
        """
        other = Peer(self.peer.key, self.peer.address)

        self.assertEqual(self.peer, other)

    def test_peer_inequality_key(self):
        """
        Check if peers with a different key and same address are not equal.
        """
        other = Peer(ECCrypto().generate_key(u"very-low"), self.peer.address)

        self.assertNotEqual(self.peer, other)

    def test_peer_inequality_address(self):
        """
        Check if peers with the same key and a different address are not equal.
        """
        other = Peer(self.peer.key)

        self.assertNotEqual(self.peer, other)

    def test_to_string(self):
        """
        Check if the __str__ method functions properly.
        """
        self.assertEqual(
            str(self.peer),
            "Peer<1.2.3.4:5, %s>" % self.peer.mid.encode('base64')[:-1])
예제 #12
0
 def setUp(self):
     self.ec = ECCrypto()
     self.key = self.ec.generate_key(u"very-low")
     self.key_nacl = self.ec.generate_key(u"curve25519")
예제 #13
0
 def __init__(self):
     endpoint = AutoMockEndpoint()
     endpoint.open()
     network = Network()
     peer = Peer(ECCrypto().generate_key(u"very-low"), endpoint.wan_address)
     super(MockCommunity, self).__init__(peer, endpoint, network)
예제 #14
0
# If it takes longer than 30 seconds to find anything, abort the experiment and set the intro time to -1.0
def on_timeout():
    for definition in get_default_configuration()['overlays']:
        if definition['class'] not in RESULTS:
            RESULTS[definition['class']] = -1.0
            print(definition['class'],
                  "found no peers at all!",
                  file=sys.stderr)
    reactor.callFromThread(reactor.stop)


# Override the Community master peers so we don't interfere with the live network
# Also hook in our custom logic for introduction responses
for community_cls in _COMMUNITIES.values():
    community_cls.master_peer = Peer(ECCrypto().generate_key(u"medium"))
    community_cls.introduction_response_callback = custom_intro_response_cb

# Create two peers with separate working directories
previous_workdir = getcwd()
for i in [1, 2]:
    configuration = get_default_configuration()
    configuration['port'] = 12000 + randint(0, 10000)
    configuration['logger']['level'] = "CRITICAL"
    for overlay in configuration['overlays']:
        overlay['walkers'] = [
            walker for walker in overlay['walkers']
            if walker['strategy'] in _WALKERS
        ]
    workdir = path.abspath(path.join(path.dirname(__file__), "%d" % i))
    if not path.exists(workdir):
예제 #15
0
class TestECCrypto(unittest.TestCase):

    m2crypto_key = ECCrypto().generate_key(u"very-low")
    libnacl_key = ECCrypto().generate_key(u"curve25519")

    def setUp(self):
        self.ecc = ECCrypto()

    def test_available(self):
        """
        Check if the required curves are available.
        """
        available = self.ecc.security_levels

        self.assertIn(u"very-low", available)
        self.assertIn(u"low", available)
        self.assertIn(u"medium", available)
        self.assertIn(u"high", available)
        self.assertIn(u"curve25519", available)

    def test_generate_m2crypto(self):
        """
        Check if M2Crypto backend keys can be generated correctly.
        """
        self.assertIsInstance(TestECCrypto.m2crypto_key, Key)
        self.assertIsInstance(TestECCrypto.m2crypto_key, PrivateKey)
        self.assertIsInstance(TestECCrypto.m2crypto_key, PublicKey)
        self.assertIsInstance(TestECCrypto.m2crypto_key, M2CryptoSK)
        self.assertIsInstance(TestECCrypto.m2crypto_key, M2CryptoPK)

    def test_generate_nacl(self):
        """
        Check if libnacl backend keys can be generated correctly.
        """
        self.assertIsInstance(TestECCrypto.libnacl_key, Key)
        self.assertIsInstance(TestECCrypto.libnacl_key, PrivateKey)
        self.assertIsInstance(TestECCrypto.libnacl_key, PublicKey)
        self.assertIsInstance(TestECCrypto.libnacl_key, LibNaCLSK)
        self.assertIsInstance(TestECCrypto.libnacl_key, LibNaCLPK)

    def test_generate_bogus(self):
        """
        Check if a bogus curve produces a RuntimeError
        """
        self.assertRaises(RuntimeError, self.ecc.generate_key, u"idontexist")

    def test_key_to_bin_m2crypto(self):
        """
        Check if ECCrypto correctly detects an M2Crypto key for bin.
        """
        key_bin = self.ecc.key_to_bin(TestECCrypto.m2crypto_key)

        self.assertEqual(key_bin, TestECCrypto.m2crypto_key.key_to_bin())

    def test_key_to_bin_nacl(self):
        """
        Check if ECCrypto correctly detects an libnacl key for bin.
        """
        key_bin = self.ecc.key_to_bin(TestECCrypto.libnacl_key)

        self.assertEqual(key_bin, TestECCrypto.libnacl_key.key_to_bin())

    def test_key_to_hash_m2crypto(self):
        """
        Check if ECCrypto correctly detects an M2Crypto key for hash.
        """
        key_hash = self.ecc.key_to_hash(TestECCrypto.m2crypto_key)

        self.assertEqual(key_hash, TestECCrypto.m2crypto_key.key_to_hash())

    def test_key_to_hash_nacl(self):
        """
        Check if ECCrypto correctly detects an libnacl key for hash.
        """
        key_hash = self.ecc.key_to_hash(TestECCrypto.libnacl_key)

        self.assertEqual(key_hash, TestECCrypto.libnacl_key.key_to_hash())

    def test_is_valid_private_bin_m2crypto(self):
        """
        Check if ECCrypto can detect a valid M2Crypto private key.
        """
        self.assertTrue(
            self.ecc.is_valid_private_bin(
                TestECCrypto.m2crypto_key.key_to_bin()))

    def test_is_valid_private_bin_m2crypto_public(self):
        """
        Check if ECCrypto doesn't detect a valid public M2Crypto key as a private key.
        """
        self.assertFalse(
            self.ecc.is_valid_private_bin(
                TestECCrypto.m2crypto_key.pub().key_to_bin()))

    def test_is_valid_private_bin_nacl(self):
        """
        Check if ECCrypto can detect a valid libnacl private key.
        """
        self.assertTrue(
            self.ecc.is_valid_private_bin(
                TestECCrypto.libnacl_key.key_to_bin()))

    def test_is_valid_private_bin_nacl_public(self):
        """
        Check if ECCrypto doesn't detect a valid public libnacl key as a private key.
        """
        self.assertFalse(
            self.ecc.is_valid_private_bin(
                TestECCrypto.libnacl_key.pub().key_to_bin()))

    def test_is_valid_public_bin_m2crypto(self):
        """
        Check if ECCrypto doesn't detect a valid M2Crypto private key as a public key.
        """
        self.assertFalse(
            self.ecc.is_valid_public_bin(
                TestECCrypto.m2crypto_key.key_to_bin()))

    def test_is_valid_public_bin_m2crypto_public(self):
        """
        Check if ECCrypto detects a valid public M2Crypto key as a public key.
        """
        self.assertTrue(
            self.ecc.is_valid_public_bin(
                TestECCrypto.m2crypto_key.pub().key_to_bin()))

    def test_is_valid_public_bin_nacl(self):
        """
        Check if ECCrypto doesn't detect a valid libnacl private key as a public key.
        """
        self.assertFalse(
            self.ecc.is_valid_public_bin(
                TestECCrypto.libnacl_key.key_to_bin()))

    def test_is_valid_public_bin_nacl_public(self):
        """
        Check if ECCrypto detects a valid public libnacl key as a public key.
        """
        self.assertTrue(
            self.ecc.is_valid_public_bin(
                TestECCrypto.libnacl_key.pub().key_to_bin()))
예제 #16
0
        def __init__(self,
                     configuration,
                     endpoint_override=None,
                     enable_statistics=False):
            if endpoint_override:
                self.endpoint = endpoint_override
            else:
                self.endpoint = UDPEndpoint(port=configuration['port'],
                                            ip=configuration['address'])
                self.endpoint.open()
                if enable_statistics:
                    self.endpoint = StatisticsEndpoint(self, self.endpoint)

            self.network = Network()

            # Load/generate keys
            self.keys = {}
            for key_block in configuration['keys']:
                if key_block['file'] and isfile(key_block['file']):
                    with open(key_block['file'], 'r') as f:
                        content = f.read()
                        try:
                            # IPv8 Standardized bin format
                            self.keys[key_block['alias']] = Peer(
                                ECCrypto().key_from_private_bin(content))
                        except ValueError:
                            try:
                                # Try old Tribler M2Crypto PEM format
                                content = content[31:-30].replace(
                                    '\n', '').decode("BASE64")
                                peer = Peer(M2CryptoSK(keystring=content))
                                peer.mid  # This will error out if the keystring is not M2Crypto
                                self.keys[key_block['alias']] = peer
                            except:
                                # Try old LibNacl format
                                content = "LibNaCLSK:" + content
                                self.keys[key_block['alias']] = Peer(
                                    ECCrypto().key_from_private_bin(content))
                else:
                    self.keys[key_block['alias']] = Peer(
                        ECCrypto().generate_key(key_block['generation']))
                    if key_block['file']:
                        with open(key_block['file'], 'w') as f:
                            f.write(
                                self.keys[key_block['alias']].key.key_to_bin())

            # Setup logging
            logging.basicConfig(**configuration['logger'])

            self.overlay_lock = RLock()
            self.strategies = []
            self.overlays = []

            for overlay in configuration['overlays']:
                overlay_class = _COMMUNITIES[overlay['class']]
                my_peer = self.keys[overlay['key']]
                overlay_instance = overlay_class(my_peer, self.endpoint,
                                                 self.network,
                                                 **overlay['initialize'])
                self.overlays.append(overlay_instance)
                for walker in overlay['walkers']:
                    strategy_class = _WALKERS[walker['strategy']]
                    args = walker['init']
                    target_peers = walker['peers']
                    self.strategies.append(
                        (strategy_class(overlay_instance,
                                        **args), target_peers))
                for config in overlay['on_start']:
                    reactor.callWhenRunning(
                        getattr(overlay_instance, config[0]), *config[1:])

            self.state_machine_lc = LoopingCall(self.on_tick)
            self.state_machine_lc.start(configuration['walker_interval'],
                                        False)
예제 #17
0
class MyCommunity(Community):
    master_peer = Peer(ECCrypto().generate_key(u"medium"))

    def __init__(self, *args, **kwargs):
        super(MyCommunity, self).__init__(*args, **kwargs)
        self.request_cache = RequestCache()

    def unload(self):
        self.request_cache.shutdown()
        super(MyCommunity, self).unload()

    def finish_ping(self, cache, include=True):
        global RESULTS
        print(cache.hostname, cache.address, time.time() - cache.starttime)
        if include:
            if (cache.hostname, cache.address) in RESULTS:
                RESULTS[(cache.hostname,
                         cache.address)].append(time.time() - cache.starttime)
            else:
                RESULTS[(cache.hostname,
                         cache.address)] = [time.time() - cache.starttime]
        elif (cache.hostname, cache.address) not in RESULTS:
            RESULTS[(cache.hostname, cache.address)] = []

        self.next_ping()

    def next_ping(self):
        global CHECK_QUEUE
        if CHECK_QUEUE:
            hostname, address = CHECK_QUEUE.pop()
            packet = self.create_introduction_request(address)
            self.request_cache.add(
                PingCache(self, hostname, address, time.time()))
            self.endpoint.send(address, packet)
        else:
            reactor.callFromThread(reactor.stop)

    def introduction_response_callback(self, peer, dist, payload):
        if self.request_cache.has(u"introping", payload.identifier):
            cache = self.request_cache.pop(u"introping", payload.identifier)
            self.finish_ping(cache)

    def started(self):
        global CHECK_QUEUE

        dnsmap = {}
        for (address, port) in _DNS_ADDRESSES:
            try:
                ip = gethostbyname(address)
                dnsmap[(ip, port)] = address
            except:
                pass

        UNKNOWN_NAME = '*'

        for (ip, port) in _DEFAULT_ADDRESSES:
            hostname = dnsmap.get((ip, port), None)
            if not hostname:
                hostname = UNKNOWN_NAME
                UNKNOWN_NAME = UNKNOWN_NAME + '*'
            CHECK_QUEUE.append((hostname, (ip, port)))

        CHECK_QUEUE = CHECK_QUEUE * CONST_REQUESTS

        self.next_ping()
예제 #18
0
 def __init__(self, endpoint):
     my_peer = Peer(ECCrypto().generate_key(u"very-low"))
     super(EndpointServer, self).__init__(my_peer, endpoint, Network())
     self.churn_lc = self.register_task("churn", LoopingCall(self.do_churn)).start(5.0, now=False)
     self.churn_strategy = RandomChurn(self)
     self.crypto = ECCrypto()
예제 #19
0
from twisted.web import server

from ipv8.REST.rest_manager import RESTRequest
from ipv8.REST.root_endpoint import RootEndpoint
from ipv8.attestation.identity.community import IdentityCommunity
from ipv8.attestation.wallet.community import AttestationCommunity
from ipv8.configuration import get_default_configuration
from ipv8.keyvault.crypto import ECCrypto
from ipv8.peer import Peer
from ipv8.taskmanager import TaskManager
from ipv8.test.REST.rtest.peer_communication import GetStyleRequests, PostStyleRequests
from ipv8.test.REST.rtest.rest_peer_communication import HTTPGetRequester, HTTPPostRequester
from ipv8_service import IPv8

COMMUNITY_TO_MASTER_PEER_KEY = {
    'AttestationCommunity': ECCrypto().generate_key(u'high'),
    'DiscoveryCommunity': ECCrypto().generate_key(u'high'),
    'HiddenTunnelCommunity': ECCrypto().generate_key(u'high'),
    'IdentityCommunity': ECCrypto().generate_key(u'high'),
    'TrustChainCommunity': ECCrypto().generate_key(u'high'),
    'TunnelCommunity': ECCrypto().generate_key(u'high')
}


class TestPeer(object):
    """
    Class for the purpose of testing the REST API
    """

    def __init__(self,
                 path,
예제 #20
0
def _generate_peer():
    key = ECCrypto().generate_key(u'very-low')
    address = (".".join([str(random.randint(0, 255))
                         for _ in range(4)]), random.randint(0, 65535))
    return Peer(key, address)
예제 #21
0
from __future__ import absolute_import
from __future__ import print_function

from binascii import hexlify
import sys

from ipv8.keyvault.crypto import ECCrypto

# This script generates a curve25519 key and prints it in hex format
if '--public' in sys.argv:
    print(hexlify(ECCrypto().generate_key(u"curve25519").pub().key_to_bin()))
else:
    print(hexlify(ECCrypto().generate_key(u"curve25519").key_to_bin()))
예제 #22
0
 def setUp(self):
     self.ecc = ECCrypto()
예제 #23
0
 def setUp(self):
     self.ec = ECCrypto()
     self.data = "".join([chr(i) for i in range(256)])