def decode_claim(owner_vrf_pk, nonce, claim_label, vrf_value, encrypted_claim): """Decode claim. :param petlib.EcPt owner_vrf_pk: Owner's VRF public key :param bytes nonce: Nonce :param bytes claim_label: Claim label :param bytes vrf_value: Exported VRF value (hash) :param bytes encrypted_claim: Claim content """ claim_label = ensure_binary(claim_label) pp = PublicParams.get_default() cipher = pp.enc_cipher salted_label = _salt_label(nonce, claim_label) (encrypted_body, tag) = decode(encrypted_claim) lookup_key = _compute_claim_key(vrf_value, mode='lookup') enc_key = _compute_claim_key(vrf_value, mode='enc') raw_body = cipher.quick_gcm_dec(enc_key, b"\x00" * pp.enc_key_size, encrypted_body, tag) (proof, claim_content) = decode(raw_body) vrf = VrfContainer(value=vrf_value, proof=proof) if not verify_vrf(owner_vrf_pk, vrf, salted_label): raise Exception("Wrong VRF value") return claim_content
def __init__(self, crypto_dir): """ __init__ imports the long term required values from files """ self.n = 4 self.crypto_dir = crypto_dir if not os.path.exists(crypto_dir): os.makedirs(crypto_dir) try: with open(self.crypto_dir + '/params', 'rb') as f: self.params = decode(f.read()) except IOError: self.params = cred_setup() with open(self.crypto_dir + '/params', 'wb+') as f: f.write(encode(self.params)) try: with open(self.crypto_dir + '/isec', 'rb') as f: self.isec = decode(f.read()) with open(self.crypto_dir + '/ipub', 'rb') as f: self.ipub = decode(f.read()) except IOError: self.ipub, self.isec = cred_CredKeyge(self.params, self.n) with open(self.crypto_dir + '/isec', 'wb+') as f: f.write(encode(self.isec)) with open(self.crypto_dir + '/ipub', 'wb+') as f: f.write(encode(self.ipub))
def _handle_client(self, client_reader, client_writer): while True: try: data = yield from client_reader.readuntil(separator=b'done') cmd = data[0:4] strippedData = data[4:-4] except asyncio.streams.IncompleteReadError: data = None if not data: # an empty string means the client disconnected break if cmd == b'mypb': self.idp_pub, self.params = decode(strippedData) print("Parameters and idp's public key received") elif cmd == b'vsig': sig, signature = decode(strippedData) params = self.params idp_pub = self.idp_pub #assert the validity of the credential m = BL_verify_cred(params, idp_pub, 2, sig, signature) if m != False: print('Signature Correct') else: print('Signature Incorrect') elif cmd == b'page': newStuff = decode(strippedData) c, responses, gam_g, gam_hs, Age, ID = newStuff zet1 = sig[2] #assert user's age is correct if ZK_verify_age(c, responses, gam_g, gam_hs, Age, ID, params, zet1) == True: print("Age & User verified") client_writer.write(b'okaydone') else: print("Proof failed") client_writer.write(b'faildone') # This enables us to have flow control in our connection. yield from client_writer.drain()
def __init__(self, crypto_dir, info_url=None, params=None, ipub=None): """ Loads long term values from files. If the server's public values are missing an Exception is raised. If any of the client's public values are missing, they are created. """ self.crypto_dir = crypto_dir if not os.path.exists(crypto_dir): os.makedirs(crypto_dir) self.delete_expired_credentials() if params is not None and ipub is not None: self.params = params self.ipub = ipub else: import requests if info_url is not None: try: r = requests.post(info_url) if r.status_code == 200: self.params, self.ipub = decode(r.content) else: raise Exception("Could not access {}".format(info_url)) except: raise Exception("Could not access {}".format(info_url)) try: with open(self.crypto_dir + '/keypair', 'rb') as f: self.keypair = decode(f.read()) except IOError: self.keypair = cred_UserKeyge(self.params) with open(self.crypto_dir + '/keypair', 'wb+') as f: f.write(encode(self.keypair)) try: with open(self.crypto_dir + '/private_attr', 'rb') as f: self.private_attr = decode(f.read()) except IOError: (_, _, _, o) = self.params self.private_attr = [o.random()] with open(self.crypto_dir + '/private_attr', 'wb+') as f: f.write(encode(self.private_attr)) try: with open(self.crypto_dir + '/user_token', 'rb') as f: self.user_token = decode(f.read()) except IOError: self.user_token = cred_secret_issue_user(self.params, self.keypair, self.private_attr) self.save_user_token(self.user_token)
def get_credential(): """ The page for the user to obtain credentials. The encrypted private attribute is given to the server along with the public attributes """ all_keys = [ 'name', 'given_name', 'family_name', 'email', 'gender', 'zoneinfo', 'birthdate' ] form = CredentialForm(request.form) form.keys.choices = zip(all_keys, all_keys) if request.method == 'POST' and form.validate(): email = form.email.data password = form.password.data keys = form.keys.data if keys == []: form.keys.errors.append( 'A credential needs to contain at least 1 key') return render_template('credential.html', form=form) try: user_token = cs.get_user_token() r = requests.post(credential_url, data=encode( (email, password, keys, user_token))) cred_token = decode(r.content) except Exception: flash('Could not get credential') return redirect(url_for('home')) cs.issue_verify(cred_token, user_token) flash('Got a credential for you') return redirect(url_for('home')) return render_template('credential.html', form=form)
def credential(*args, **kwargs): """ A endpoint for users to request credentials """ try: (email, password, keys, user_token) = decode(request.data) (_, enc_secret, _) = user_token except Exception: return "Invalid Data in Request" # Checking the user's email and password if keys == []: return 'Cannot issue credential with no attributes' user = User.query.filter_by(email=email.lower()).first() if user is not None and user.check_password(password): # Checking the users ciphertext if user.check_enc_secret(enc_secret): # Setting values, keys and timeout for the issued credential values = user.get_values_by_keys(keys) timeout_date = date.today() + \ timedelta(days=app.config['CREDENTIAL_LIFETIME']) timeout = timeout_date.isoformat() cred_issued = cs.issue_credential(user_token, keys, values, timeout) return encode((cred_issued, keys, values, timeout)) else: return "Unknown user token" else: return "Invalid email or password"
def decode_binary(self, e, record_size): e = decode(e) result = "" for x in e[:-1]: petlib_decode = decode(x) binary = "{0:b}".format(petlib_decode) pad = "0" * (min(self.size, record_size) - len(binary)) result += pad + binary petlib_decode = decode(e[-1]) binary = "{0:b}".format(petlib_decode) pad = "0" * (record_size - (len(result)+len(binary))) result += pad + binary l = [] for x in result: l.append(int(x)) return l
def poll_index(self, pir, requested_index): self.client_poller = ClientPoller() threads = [] messages = {} for surbid, data in self.surbDict.items(): threads.append( self.client_poller.poll_with((surbid, data['source']), self, messages)) for t in threads: t.start() for t in threads: t.join() decrypted_msgs = [] if not pir: decrypted_msgs = {} try: for surbid, _ in self.surbDict.items(): msg = self.surbDict[surbid] log_debug(msg) decrypted_msg = decode( self.decrypt(messages[surbid][1], msg['key'][1])) if pir: decrypted_msgs.append(decrypted_msg) else: decrypted_msgs[messages[surbid][0]] = decrypted_msg if pir: return self.xor(decrypted_msgs) else: return decrypted_msgs[requested_index].strip() except Exception as e: PrintException() log_debug('[ERROR] Exception\n{}\n'.format(e))
def recv_timeout_petlib_pack(the_socket, timeout=0.15): the_socket.setblocking(0) total_data=[]; data=''; begin=time.time() isEmpty =0 while 1: if total_data and time.time()-begin > timeout: break elif isEmpty > 20: break try: data = the_socket.recv(4096) if data: total_data.append(data) begin = time.time() else: isEmpty += 1 time.sleep(0.05) except: pass string = b''.join(total_data) if string == b'': return '' return decode(string)
def dataReceived(self, data): #Function called when some data is received from the made connection print "SP: Data received", self.transport.getPeer() #, data #Decode and Parse meta data name, op, vs, turn, option, nbpack, nbtot, content = pack.decode( data) # operation, request id, content print "rec:", name, op, vs, turn, nbpack, nbtot #Stop connection if function not triggered by the server itself if nbpack >= nbtot - 1: print "cutting connection", [ self.factory.mix.name, "END", vs, turn, "", nbpack, nbtot, [] ] self.transport.write( pack.encode([ self.factory.mix.name, "END", vs, turn, "", nbpack, nbtot, [] ])) self.transport.loseConnection() else: print "asking for next packet", [ self.factory.mix.name, "ACK", vs, turn, "", nbpack, nbtot, [] ] self.transport.write( pack.encode([ self.factory.mix.name, "ACK", vs, turn, "", nbpack, nbtot, [] ])) if "ACK" not in op and "END" not in op: reactor.callInThread(self.dataParser, data)
def handle_PIR(self, decrypted_msg, client_pk): time_queued = time.perf_counter() - self.t_accepted log_info(">>>>> TIME QUEUED: {}".format(time_queued)) t1 = time.perf_counter() print("TRYING TO FETCH") answer = self.dbnode.fetch_answer(decrypted_msg) print("ANSWER:", answer) reply = encode(answer) encrypted_reply = encode(self.dbnode.encrypt(reply, client_pk)) nymtuple = decrypted_msg['nymtuple'] first_node = decode(nymtuple[0]) header, delta = package_surb(getGlobalSphinxParams(), nymtuple, encrypted_reply) self.dbnode.get_mixnode_list() json_data, dest = RequestCreator().post_msg_to_mix( { 'ip': first_node[1], 'port': self.mixport }, { 'header': header, 'delta': delta }) t2 = time.perf_counter() elapsed_time = (t2 - t1) log_info("TIME ELAPSED: {}".format(elapsed_time)) self.network_sender.send_data(json_data, dest)
def test_info_post(self): rv = self.app.post('/unlimitID/info') raised = False try: params, ipub = decode(rv.data) except: raised = True assert raised is False
def add_user_and_get_credential(self): self.add_user('test', '*****@*****.**') user_token = self.user_cs.get_encrypted_attribute() rv = self.app.post('unlimitID/credential', data=encode(('*****@*****.**', 'pass', full_scope, user_token))) cred_token = decode(rv.data) self.user_cs.issue_verify(cred_token, user_token)
def receive_forward(params, mac_key, delta): """ Decodes the body of a forward message, and checks its MAC tag.""" if delta[:params.k] != params.mu(mac_key, delta[params.k:]): raise SphinxException("Modified Body") delta = unpad_body(delta[params.k:]) return decode(delta)
def decode_claim(owner_vrf_pk, nonce, claim_label, vrf_value, encrypted_claim): claim_label = ensure_binary(claim_label) pp = PublicParams.get_default() cipher = pp.enc_cipher salted_label = _salt_label(nonce, claim_label) (encrypted_body, tag) = decode(encrypted_claim) lookup_key = _compute_claim_key(vrf_value, mode='lookup') enc_key = _compute_claim_key(vrf_value, mode='enc') raw_body = cipher.quick_gcm_dec(enc_key, b"\x00" * pp.enc_key_size, encrypted_body, tag) (proof, claim_content) = decode(raw_body) vrf = VrfContainer(value=vrf_value, proof=proof) if not verify_vrf(owner_vrf_pk, vrf, salted_label): raise Exception("Wrong VRF Value") return claim_content
def verify_vrf(pub, vrf, message): pp = PublicParams.get_default() G = pp.ec_group g = G.generator() h = G.hash_to_point(b"1||" + message) v = EcPt.from_binary(vrf.value, G) s, t = decode(vrf.proof) R = t * g + s * pub Hr = t * h + s * v s2 = Bn.from_binary(sha256(encode([g, h, pub, v, R, Hr])).digest()) return s2 == s
def delete_expired_credentials(self): for filename in os.listdir(self.crypto_dir): if filename.startswith("cred_"): with open(self.crypto_dir + '/' + filename, 'rb') as f: cred = decode(f.read()) _, _, _, timeout = cred if datetime.strptime(timeout, '%Y-%m-%d').date() < date.today(): os.unlink(self.crypto_dir + '/' + filename) cred_id = filename.split('_')[1] os.unlink(self.crypto_dir + '/mac_' + cred_id) return
def test_credential_post(self): self.add_user('test', '*****@*****.**') user_token = self.user_cs.get_encrypted_attribute() rv = self.app.post('unlimitID/credential', data=encode(('*****@*****.**', 'pass', full_scope, user_token))) raised = False try: cred_token = decode(rv.data) self.user_cs.issue_verify(cred_token, user_token) except: raised = True assert raised is False
def test_pack_unpack_g2(group_pair): """ Testing packing and unpacking G2 element """ group_pair = BilinearGroupPair() g2 = group_pair.G2 order = g2.order() pt1 = order.random() * g2.generator() data = pack.encode(pt1) pt2 = pack.decode(data) assert pt1 == pt2
def run(self): json_data, destination = self.request_creator.poll_mixnode( self.id, self.mixnode) response = self.network_sender.send_data_wait(json_data, destination) if response: response = decode(response) id = response['id'] response = response['response'] for entry in response: msg = entry['delta'] recoveredMessage = self.client.recoverMessage( msg, entry['myid']) self.message_pool[id] = (recoveredMessage[0], recoveredMessage[1])
def decode_capability(owner_dh_pk, nonce, claim_label, encrypted_capability): pp = PublicParams.get_default() cipher = pp.enc_cipher params = LocalParams.get_default() shared_secret = params.dh.sk * owner_dh_pk enc_key = _compute_capability_key(nonce, shared_secret, claim_label, mode='enc') enc_body, tag = decode(encrypted_capability) vrf_value = cipher.quick_gcm_dec(enc_key, b"\x00" * pp.enc_key_size, enc_body, tag) claim_lookup_key = _compute_claim_key(vrf_value, mode='lookup') return vrf_value, claim_lookup_key
def list_credential_tokens(self): creds = [] for filename in os.listdir(self.crypto_dir): if filename.startswith("cred_"): cred_id = filename.split('_')[1] with open(self.crypto_dir + '/' + filename, 'rb') as f: cred = decode(f.read()) _, k, v, t = cred attr = [ '{}={}'.format(key, value) for key, value in zip(k, v) ] creds.append( (cred_id, 'Attributes: {}\n Timeout: {}'.format( ', '.join(attr), t))) return creds
def finish(): vote_data = decode(session["vote_data"]) vote_data.sort(key=lambda x: x[6]['voter_id']) votes = [v[0] for v in vote_data] vote_commits = [v[1] for v in vote_data] randoms = [v[2] for v in vote_data] receipts = [v[6] for v in vote_data] # genvote.verifyChallenge(receipts[0]['challenges'], receipts[0]['vote_commitment']) tally = Counter(votes) print(tally) proofs = genvote.doFiatShamir(votes, vote_commits, randoms, tally) big_dict = { 'G': str(genvote.GROUP_ID), 'sleeve': genvote.sleeve, 'g': genvote.EcPtToStr(genvote.g), 'h': genvote.EcPtToStr(genvote.h), 'precinct-id': '0', 'receipts': receipts, 'tally': tally, 'proofs': proofs } json_str = json.dumps(big_dict) for candidate in tally: print("%s: %d" % (session["rev_d"][candidate], tally[candidate])) with open("./verification.json", 'w') as f: f.write(json_str) verification_file_url = os.popen( "curl --upload-file ./verification.json https://transfer.sh/verification.json" ).read() xmail = GMail('Verified Voting <*****@*****.**>', 'qyfsewfeepumeaex') msg = Message( 'New Verification File', to= 'Verified Voting <*****@*****.**>, Soham Sankaran <*****@*****.**>', text=verification_file_url) xmail.send(msg) return render_template("finished.html", verification_file_url=verification_file_url)
def test_pack_full(): G = BpGroup() # Key Generation private = G.order().random() pub = private * G.gen2() # The public key # Signature message = b"Hello World" sig = private * G.hashG1(message) # Verification gt = G.pair(sig, G.gen2()) struct = [G, pub, sig, gt] data = encode( struct ) assert struct == decode(data)
def poll_recordSize(self, DummyIndex): self.client_poller = ClientPoller() messages = {} threads = [] for surbid, data in self.surbDict.items(): threads.append( self.client_poller.poll_with((surbid, data['source']), self, messages)) for t in threads: t.start() for t in threads: t.join() # First one is the record size surbid = list(self.surbDict.keys())[0] self.surbDict = {} record_size = decode( self.decrypt(messages[surbid][1], self.private_key[1])) return record_size
def receive_forward(params, header, mac_key, routing, delta): """ Decodes the body of a forward message, and checks its MAC tag.""" _, _, _, dest_key = header _, dest = routing dest_inner_key = params.derive_key(dest_key, b"dest_inner______") body_inner_key = params.derive_key(dest_key, b"body_inner______") # TODO: Encure that changing the body destroys the dest_key. dest = params.xor_rho(dest_inner_key, dest) delta = params.pii(body_inner_key, delta) if delta[:params.k] != params.mu(mac_key, delta[params.k:]): raise SphinxException("Modified Body") delta = unpad_body(delta[params.k:]) return dest, decode(delta)
def getDBRecordSize(self, portEnum, network_sender): session_name = os.urandom(16) self.public_key, self.private_key = self.encryptor.keyGenerate( session_name) db_dest, key = self.create_db_destination(0, portEnum.db.value) message = encode( self.create_db_message( None, { 'pir_xor': None, 'request_type': RequestType.get_db_size.value, 'pk': self.public_key })) json_msg = self.encryptForDB(message, key, session_name) response = network_sender.send_data_wait(json_msg, { 'ip': db_dest[0], 'port': db_dest[2] }) response = int(decode(response)) return response
def dataReceived(self, data): # Function called when data received from DB # Forward data received to the Server print "CP: Receive:", self.transport.getPeer( ), self.factory.header #data, self.factory.counter += 1 name, op, vs, turn, option, turn, tot, content = pack.decode(data) if "PUT" in op: if turn == 0: self.factory.nbpack = int(tot) opsend = "END" if self.factory.counter != self.factory.nbpack: opsend = "ACK" self.cdata = [ self.factory.name, opsend, self.factory.vs, self.factory.turn, [self.factory.range1, self.factory.range2], self.factory.counter, self.factory.nbpack, "" ] else: if self.factory.counter != self.factory.nbpack: if "PUT" in self.factory.header: self.factory.header[4][0] += self.factory.nbrec self.cdata = self.factory.header + [ self.factory.counter, self.factory.nbpack ] + [ self.factory.data[self.factory.counter * self.factory. nbrec:min(len(self.factory.data), (self.factory.counter + 1) * self.factory.nbrec)] ] if "END" not in op: print "CP: R sending data" #, self.cdata self.transport.write(pack.encode(self.cdata)) else: self.transport.loseConnection() if "ACK" not in op and "END" not in op: self.factory.s_proto.dataParser(data)
def verify_vrf(pub, vrf, message): """Verify a VRF. Checks whether a VRF value and a proof correspond to the message. :param petlib.EcPt pub: VRF public key :param VrfContainer vrf: VRF value and proof :param bytes message: Message """ pp = PublicParams.get_default() G = pp.ec_group g = G.generator() h = G.hash_to_point(b"1||" + message) v = EcPt.from_binary(vrf.value, G) s, t = decode(vrf.proof) R = t * g + s * pub Hr = t * h + s * v s2 = Bn.from_binary(sha256(encode([g, h, pub, v, R, Hr])).digest()) return s2 == s
def decode_capability(owner_dh_pk, nonce, claim_label, encrypted_capability): """Decode capability. :param petlib.EcPt owner_dh_pk: Owder's VRF public key :param bytes nonce: Nonce :param bytes claim_label: Corresponding claim label :param bytes encrypted_capability: Encrypted capability """ pp = PublicParams.get_default() cipher = pp.enc_cipher params = LocalParams.get_default() shared_secret = params.dh.sk * owner_dh_pk enc_key = _compute_capability_key(nonce, shared_secret, claim_label, mode='enc') enc_body, tag = decode(encrypted_capability) vrf_value = cipher.quick_gcm_dec(enc_key, b"\x00" * pp.enc_key_size, enc_body, tag) claim_lookup_key = _compute_claim_key(vrf_value, mode='lookup') return vrf_value, claim_lookup_key
def _handle_client(self, client_reader, client_writer): global count global paramsReceived IOtime = 0 while True: try:#data = (yield from client_reader.readline()).decode("utf-8") startWait = time.time() data = yield from client_reader.readuntil(separator=b'fireintheboof') endWait = time.time() #print('IO wait: ', data[0:4], endWait - startWait) IOtime += endWait-startWait cmd = data[0:4] strippedData = data[4:-13] except asyncio.streams.IncompleteReadError: data = None if not data: # an empty string means the client disconnected break #cmd, *args = str(data).rstrip().split(' ') if cmd == b'buys': retval = "id" client_writer.write("{!r}\n".format(retval).encode("utf-8")) start = time.time() count +=1 id = count print(id, 'Starting...') elif cmd == b'para': params = decode(strippedData) paramsReceived = True elif cmd == b'ipub': idp_pub = decode(strippedData) elif cmd == b'vsig': sig = decode(strippedData) elif cmd == b'vsg2': signature = decode(strippedData) startSigProof = time.time() m = BL_verify_cred(params, idp_pub, 2, sig, signature) endSigProof = time.time() finalSigProof = endSigProof - startSigProof if m != False: print('Signature Correct') else: print('Signature Incorrect') elif cmd == b'page': newStuff = decode(strippedData) c, responses, gam_g, gam_hs, Age, xran = newStuff rrnd, rR, rx = responses #print(gam_hs, Age) (G, q, g, h, z, hs) = params startProof = time.time() H = G.hash_to_point(b'service_name') ID = xran * H zet1 = sig[2] zet1p = zet1 - Age * gam_hs[2] Waprime = rrnd * gam_g + rR * gam_hs[0] + rx * gam_hs[1] + c * zet1p Wxprime = rx * H + c * ID stuffToHash = (gam_g, Waprime, Wxprime, zet1p, gam_hs[0], gam_hs[1], gam_hs[2], H) cstr = b",".join([hexlify(x.export()) for x in stuffToHash]) chash = sha256(cstr).digest() c_prime = Bn.from_binary(chash) if c == c_prime: end = time.time() finalTime = end-start timeList.append(finalTime) print(id, "Age & User match, time: ", finalTime, 'Time for proof: ', end - startProof, 'Sig proof: ', finalSigProof, 'IO time: ', IOtime) else: print("whops") elif cmd == 'Commitment': """params = setup() G = params[0] C = EcPt.from_binary(literal_eval(args[0]), G)""" elif cmd == 'Proof': """c = Bn.from_hex(literal_eval(args[0])) responses1 = pickle.loads(literal_eval(args[1])) params = setup() responses = [] for res in responses1: responses.append(Bn.from_hex(res)) proof = c, responses print(verifyCommitments(params, C, proof))""" # This enables us to have flow control in our connection. yield from client_writer.drain()
def _handle_client(self, client_reader, client_writer): global paramsReceived while True: try: # data = (yield from client_reader.readline()).decode("utf-8") startWait = time.time() data = yield from client_reader.readuntil(separator=b'fireintheboof') endWait = time.time() print('IO wait: ', data[0:4], endWait - startWait) cmd = data[0:4] strippedData = data[4:-13] except asyncio.streams.IncompleteReadError: data = None if not data: # an empty string means the client disconnected break # cmd, *args = str(data).rstrip().split(' ') if cmd == 'id': """secrets = [3, 645, 3430, 420] seriSecrets = pickle.dumps(secrets) params = setup() C, r = commit(params, secrets) G = params[0] exportedC = C.export() retval = 'IDCONFIRMED' #client_writer.write("{!r}\n".format(retval).encode("utf-8")) #Interesting asyncio thingy here, if I send the data to the client first, the proof is never correct #THe client completes and sends the proof to the service provider before the SP receives the C from here.""" print(literal_eval(args[0])) print(type(literal_eval(args[0]))) reader_sp, writer_sp = yield from asyncio.streams.open_connection("localhost", 12345, loop = loop) params = BL_setup() LT_idp_state, idp_pub = BL_idp_keys(params) #conv_user_commit = bytes(args[0], "utf8") #user_commit = encdec.decode(conv_user_commit) user_commit = encdec.decode(literal_eval(args[0])) msg_to_user = BL_idp_prep(LT_idp_state, user_commit) elif cmd == b'para': #reader_sp, writer_sp = yield from asyncio.streams.open_connection("localhost", 12345, loop=loop) start = time.time() paramsReceived = True print('Starting...') params = decode(strippedData) G, q, g, h, z, hs = params LT_idp_state, idp_pub = BL_idp_keys(params) #send public key to user and service provider #writer_sp.write(b'ipub' + encode(idp_pub) + b'fireintheboof') client_writer.write(b'mypb' + encode(idp_pub) + b'fireinthepub') elif cmd == b'ucmt': user_commit, C, c, responses, L2, Age = decode(strippedData) rR, rx = responses H = G.hash_to_point(b'service_name') ID = L2 * H Cprime = C - Age * hs[2] Wprime = rR * hs[0] + rx * hs[1] + c * Cprime Wxprime = rx * H + c * ID stuffToHash = (Wprime, Wxprime, C, g, h, z, hs[0], hs[1], hs[2], hs[3], H) cstr = b",".join([hexlify(x.export()) for x in stuffToHash]) chash = sha256(cstr).digest() cprime = Bn.from_binary(chash) if c == cprime: print("success") else: print("no") #generate message to user msg_to_user = BL_idp_prep(LT_idp_state, user_commit) client_writer.write(encode(msg_to_user) + b'fireintheboof') elif cmd == b'prep': msg_to_user2 = BL_idp_validation(LT_idp_state) client_writer.write(encode(msg_to_user2) + b'fireintheboof') elif cmd == b'msgi': msg_to_idp = decode(strippedData) # generate 3rd message to user msg_to_user3 = BL_idp_validation_2(LT_idp_state, msg_to_idp) client_writer.write(encode(msg_to_user3) + b'fireintheboof') end = time.time() finalTime = end - start print('Total time taken: ', finalTime) else: #print("Bad command {!r}".format(data), file=sys.stderr) pass # This enables us to have flow control in our connection. yield from client_writer.drain()
def test_openID_blind(): ## Setup from credential issuer. params = cred_setup() (G, g, h, o) = params data = encode(params) params = decode(data) ## Derive a fresh, long term secret for user LT_user_ID = o.random() timeout = 100 ## Attriutes we want to encode public_attr = [ timeout ] private_attr = [ LT_user_ID ] n = len(public_attr) + len(private_attr) ipub, isec = cred_CredKeyge(params, n) ## User generates keys and encrypts some secret attributes # the secret attributes are [10, 20] keypair = cred_UserKeyge(params) keypair = decode(encode(keypair)) user_token = cred_secret_issue_user(params, keypair, private_attr) pub, EGenc, sig_u = decode(encode(user_token)) ## The issuer checks the secret attributes and encrypts a amac # It also includes some public attributes, namely [30, 40]. assert cred_secret_issue_user_check(params, pub, EGenc, sig_u) cred_issued = cred_secret_issue(params, pub, EGenc, ipub, isec, public_attr) u, EncE, sig_s = decode(encode(cred_issued)) ## The user decrypts the amac mac = cred_secret_issue_user_decrypt(params, keypair, u, EncE, ipub, public_attr, EGenc, sig_s) mac = decode(encode(mac)) ## User Shows back full credential to issuer (creds, sig_o, zis) = cred_show(params, ipub, mac, sig_s, public_attr + private_attr, export_zi=True) ## The credential contains a number of commitments to the attributes (u, Cmis, Cup) = creds assert len(Cmis) == 2 assert Cmis[0] == timeout * u + zis[0] * h assert Cmis[1] == LT_user_ID * u + zis[1] * h # Derive a service specific User ID Gid = G.hash_to_point(b"ServiceNameRP") Uid = LT_user_ID * Gid # Define the statements to be proved zk = define_proof(G) # Define the proof environemnt env = ZKEnv(zk) env.u, env.h = u, h env.Cm0p, env.Cm1 = Cmis[0] - (timeout * u), Cmis[1] env.Uid, env.Gid = Uid, Gid env.LT_ID = LT_user_ID env.z0, env.z1 = zis[0], zis[1] sig_openID = zk.build_proof(env.get()) creds, sig_o, sig_openID = decode(encode( (creds, sig_o, sig_openID) )) ## Issuer / IdP checks the credential is valid assert cred_show_check(params, ipub, isec, creds, sig_o) # Execute the verification on the proof 'sig' env2 = ZKEnv(zk) env2.u, env2.h = u, h env2.Cm0p, env2.Cm1 = Cmis[0] - (timeout * u), Cmis[1] env2.Uid, env2.Gid = Uid, Gid assert zk.verify_proof(env2.get(), sig_openID)
def datagramReceived(self, data, (host, port)): # Deal with information requests if data[:4] == "INFO": self.do_INFO(data, (host, port)) # Deal with routing requests if data[:4] == "ROUT": self.do_ROUT(data, (host, port)) def do_INFO(self, data, (host, port)): print "do INFORMATION" hexkey = hexlify(self.ypub.export()) resp = "RINF %s %s %s" % (self.ip.host, self.port, hexkey) # Respond self.transport.write(resp, (host, port)) def do_ROUT(self, data, (host, port)): print "do ROUTING" msg = decode(data[4:]) (xfrom, xto), next_msg = mix_operate(msg, (None, self.ypub, self.y), self.setup) if __name__ == "__main__": port = 9999 reactor.listenUDP(port, Echo(port)) reactor.run()
def client(): reader, writer = yield from asyncio.streams.open_connection( '127.0.0.1', 12345, loop=loop)#Service Provider reader2, writer2 = yield from asyncio.streams.open_connection( '127.0.0.1', 7878, loop=loop)#Identity Provider def send(msg, writer): print("> " + str(msg)) writer.write((msg + '\n').encode("utf-8")) print(msg) print(type(msg.encode("utf8"))) def sendBin(data, writer): #print("bin>" + str(data)) writer.write(data + b'fireintheboof') #writer.write_eof() def recv(reader): msgback = (yield from reader.readline()).decode("utf-8").rstrip() #print("< " + msgback) return msgback # send a line #send("buy", writer) sendBin(b'buys', writer) msg = yield from recv(reader) #if repr('id') == msg: if True: startWait = time.time() print("ok i go get ID") #generating, encoding, and sending parameters to both sp and idp params = BL_setup() G, q, g, h, z, hs = params endWait = time.time() sendBin(b'para' + encode(params), writer) sendBin(b'para' + encode(params), writer2) print('Time to generate params: ', endWait-startWait) seri_enc_idp_pub = yield from reader2.readuntil(separator=b'fireinthepub') if seri_enc_idp_pub[0:4] == b'mypb': #idp_pub = tuple(list_enc_idp_pub) idp_pub = decode(seri_enc_idp_pub[4:-12]) sendBin(b'ipub' + encode(idp_pub) + b'fireintheboof', writer) #h = Hmac(b'sha256', b'ServiceProviderID') L2 = q.random() Age = 21 #new #N = params[0].hash_to_point('service_name') #pseudonym = x * N #encode and send user_commit to idp LT_user_state, user_commit = BL_user_setup(params, [L2, Age]) startTimeProof = time.time() C = LT_user_state.C R = LT_user_state.R q = LT_user_state.params[1] H = params[0].hash_to_point(b'service_name') ID = L2 * H wR_id = q.random() wx_id = q.random() Wit = wR_id * hs[0] + wx_id * hs[1] WID_id = wx_id * H print(hs) stuffToHash = (Wit, WID_id, C, g, h, z, hs[0], hs[1], hs[2], hs[3], H) cstr = b",".join([hexlify(x.export()) for x in stuffToHash]) chash = sha256(cstr).digest() c = Bn.from_binary(chash) rR_id = wR_id - c * R rx_id = wx_id - c * L2 endTimeProof = time.time() print('Proof took: ', endTimeProof - startTimeProof) responses = (rR_id, rx_id) values = (user_commit, C, c, responses, L2, Age) sendBin(b'ucmt' + encode(values), writer2) msg2 = yield from reader2.readuntil(separator=b'fireintheboof') msg_to_user = decode(msg2[:-13]) BL_user_prep(LT_user_state, msg_to_user) #request idp's pubkey #sendBin(b'pubk', writer2) #inform idp Im prepped and ready to go sendBin(b'prep', writer2) msg3 = yield from reader2.readuntil(separator=b'fireintheboof') msg_to_user2 = decode(msg3[:-13]) #generate msg to idp msg_to_idp = BL_user_validation(LT_user_state, idp_pub, msg_to_user2) #encode, serialise, and send msg to idp sendBin(b'msgi' + encode(msg_to_idp), writer2) #receive last message from idp, generate signature msg4 = yield from reader2.readuntil(separator=b'fireintheboof') msg_to_user3 = decode(msg4[:-13]) sig = BL_user_validation_2(LT_user_state, msg_to_user3) sendBin(b'vsig' + encode(sig) + b'fireintheboof', writer) print('idppub: ', idp_pub) signature_gamhs = BL_user_prove_cred(LT_user_state) signature = signature_gamhs[0] gam_hs = signature_gamhs[1] gam_g = signature_gamhs[2] sendBin(b'vsg2' + encode(signature) + b'fireintheboof', writer) zet1p = LT_user_state.zet1 - Age * gam_hs[2] newStuff = (gam_hs, Age) #prove age #get variabels rnd = LT_user_state.rnd R = LT_user_state.R q = LT_user_state.params[1] wrnd = q.random() wR = q.random() wx = q.random() Wzet1p = wrnd * gam_g + wR * gam_hs[0] + wx * gam_hs[1] #remember to get gam_g WID = wx * params[0].hash_to_point(b'service_name') stuffToHash = (gam_g, Wzet1p, WID, zet1p, gam_hs[0], gam_hs[1], gam_hs[2], H) cstr = b",".join([hexlify(x.export()) for x in stuffToHash]) chash = sha256(cstr).digest() c = Bn.from_binary(chash) rrnd = wrnd - c*rnd rR = wR - c*R rx = wx - c*L2 responses = (rrnd, rR, rx) newStuff = (c, responses, gam_g, gam_hs, Age, L2) """Wprime = rrnd * gam_g + rR * gam_hs[0] + rx * gam_hs[1] + c * zet1p print(Wzet1p) print(Wprime)""" sendBin(b'page' + encode(newStuff) + b'fireintheboof', writer) #Close the connections to get rid of IncompleteReadError cmd = "asd" #cmd, *args = msg2.rstrip().split(' ') if repr('IDCONFIRMED') == cmd: #for encryption """key = keyGen() print(repr(key)) ciphertext = encrypt_AES(key, "HAUHEUheuahehaeuhUAEHUHEAUh") serialisedCiphertext = pickle.dumps(ciphertext) send(('key ' + repr(key)) + " " + repr(serialisedCiphertext), writer)""" """params = setup() G = params[0] C = EcPt.from_binary(literal_eval(args[0]), G) r = Bn.from_binary(literal_eval(args[1])) secrets = pickle.loads(literal_eval(args[2])) proof = proveCommitment(params, C, r, secrets) c, responses = proof #Here is where I send the proof to the service provider seriRes = pickle.dumps(responses) send('Proof ' + repr(c) + " " + repr(seriRes), writer) print("the end")""" end = time.time() print("Time: ", end-start) writer.close() writer2.close()