IPv8 claim creation demo: 1024-EC key overkill edition

main.py

from base64 import b64encode
from urllib import quote

from twisted.internet import reactor
from twisted.internet.defer import inlineCallbacks, returnValue
from twisted.internet.task import deferLater

from roles import initialize_peer, make_request, sleep, stop_peers


print "Initializing peers"
idowner, idowner_restapi = initialize_peer("idowner")
attester, attester_restapi  = initialize_peer("attester")
verifier, verifier_restapi  = initialize_peer("verifier")


@inlineCallbacks
def wait_for_peers(idowner_restapi):
    # Wait a second, if we fail to find peers: repeat, otherwise: return the result
    peers = yield make_request(idowner_restapi, 'GET', {
        'type': 'peers'
    })
    if peers != "[]":
        returnValue(peers)
    else:
        print "No peers have connected yet, waiting for 4 seconds!"
        peers = yield deferLater(reactor, 4.0, wait_for_peers, idowner_restapi)
        returnValue(peers)


@inlineCallbacks
def wait_for_attestation_request(attester_restapi):
    # Wait a second, if we fail to find pending requests: repeat, otherwise: return the result
    requests = yield make_request(attester_restapi, 'GET', {
        'type': 'outstanding'
    })
    if requests != "[]":
        returnValue(requests)
    else:
        print "No attestation requests have been received yet, waiting for 4 seconds!"
        requests = yield deferLater(reactor, 4.0, wait_for_attestation_request, attester_restapi)
        returnValue(requests)


@inlineCallbacks
def make_attribute():
    global attester, attester_restapi, idowner, idowner_restapi
    try:
        idowner_id = quote(b64encode(idowner.keys["anonymous id"].mid))
        attest_id = quote(b64encode(attester.keys["anonymous id"].mid))

        value = yield wait_for_peers(idowner_restapi)
        print "Known peers for id owner:", value
        print "Requesting attestation for QR from", b64encode(attester.keys["anonymous id"].mid),\
            "(generates one-time 1024-bit EC key)"
        yield make_request(idowner_restapi, 'POST', {
            'type': 'request',
            'mid': attest_id,
            'attribute_name': 'QR'
        })
        value = yield wait_for_attestation_request(attester_restapi)
        print "Pending attestation request for attester:", value
        print "Attesting QR for", b64encode(idowner.keys["anonymous id"].mid)
        yield make_request(attester_restapi, 'POST', {
            'type': 'attest',
            'mid': idowner_id,
            'attribute_name': 'QR',
            'attribute_value': quote(b64encode('binarydata'))
        })
        yield sleep(20)
        value = yield make_request(idowner_restapi, 'GET', {
            'type': 'attributes',
            'mid': attest_id
        })
        print "ID Owner attributes:", value
        yield stop_peers(attester, idowner)
    except:
        import traceback
        traceback.print_exc()


deferLater(reactor, 0.5, make_attribute)
reactor.run()

roles.py

import os
import sys
from twisted.internet.defer import inlineCallbacks
from twisted.internet.task import deferLater

sys.path.append('pyipv8')

from twisted.internet import reactor
from twisted.web import server
from twisted.web.client import Agent, readBody
from twisted.web.http_headers import Headers

from pyipv8.REST.rest_manager import RESTManager, RESTRequest
from pyipv8.REST.root_endpoint import RootEndpoint
from pyipv8.ipv8_service import IPv8
from pyipv8.ipv8.configuration import get_default_configuration


agent = Agent(reactor)


class TestRESTAPI(RESTManager):

    port = 8085

    def start(self):
        self.root_endpoint = RootEndpoint(self.session)
        site = server.Site(resource=self.root_endpoint)
        site.requestFactory = RESTRequest
        TestRESTAPI.port += 1
        self.site = reactor.listenTCP(TestRESTAPI.port, site, interface="127.0.0.1")


@inlineCallbacks
def sleep(time):
    try:
        yield deferLater(reactor, time, lambda: None)
    except:
        import traceback
        print traceback.print_exc()


def create_working_dir(path):
    if os.path.isdir(path):
        import shutil
        shutil.rmtree(path)
    os.mkdir(path)


def initialize_peer(path):
    configuration = get_default_configuration()
    configuration['logger'] = {'level': "ERROR"}
    overlays = ['AttestationCommunity', 'IdentityCommunity']
    configuration['overlays'] = [o for o in configuration['overlays'] if o['class'] in overlays]
    for o in configuration['overlays']:
        o['walkers'] = [{
                    'strategy': "RandomWalk",
                    'peers': 4,
                    'init': {
                        'timeout': 60.0
                    }
                }]
    create_working_dir(path)
    os.chdir(path)
    ipv8 = IPv8(configuration)
    os.chdir(os.path.dirname(__file__))
    rest_manager = TestRESTAPI(ipv8)
    rest_manager.start()
    return ipv8, "http://localhost:%d/attestation" % rest_manager.port


@inlineCallbacks
def stop_peers(*peers):
    for p in peers:
        p.endpoint.close()
        yield p.stop(stop_reactor=(p==peers[-1]))


def make_request(url, type, arguments={}):
    global agent
    request_url = url + '?' + '&'.join("%s=%s" % (k,v) for k,v in arguments.iteritems())
    print "\t[HTTP-%s] %s" % (type, request_url)
    d = agent.request(
            type,
            request_url,
            Headers({'User-Agent': ['Twisted Web Client Example'],
                     'Content-Type': ['text/x-greeting']}),
            None)
    return d.addCallback(lambda response: readBody(response))