def elli(key_size_bytes): # Generate the key pair for Alice a_private = urandom(key_size_bytes) a_public = scalarmult_base(a_private) # Generate the key pair for Bob b_private = urandom(key_size_bytes) b_public = scalarmult_base(b_private) a_shared = scalarmult(a_private, b_public) b_shared = scalarmult(b_private, a_public) assert a_shared == b_shared
def test_dh(): a_priv = unhexlify( '77076d0a7318a57d3c16c17251b26645df4c2f87ebc0992ab177fba51db92c2a') a_pub = unhexlify( '8520f0098930a754748b7ddcb43ef75a0dbf3a0d26381af4eba4a98eaa9b4e6a') b_priv = unhexlify( '5dab087e624a8a4b79e17f8b83800ee66f3bb1292618b6fd1c2f8b27ff88e0eb') b_pub = unhexlify( 'de9edb7d7b7dc1b4d35b61c2ece435373f8343c85b78674dadfc7e146f882b4f') k = '4a5d9d5ba4ce2de1728e3bf480350f25e07e21c947d19e3376f09b3c1e161742' assert hexlify(scalarmult_base(a_priv)) == hexlify(a_pub) assert hexlify(scalarmult_base(b_priv)) == hexlify(b_pub) assert hexlify(scalarmult(a_priv, b_pub)) == k assert hexlify(scalarmult(b_priv, a_pub)) == k
def run(self): HOST = '' s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s.bind((HOST,self.port)) s.listen(1) self.conn, self.addr = s.accept() # Curve25519 encryption scheme # Usign a size-32 key a = urandom(32) a_pub = scalarmult_base(a) # send public key print(binascii.hexlify(a_pub)) self.conn.send(a_pub) b_pub = self.conn.recv(32) secret = scalarmult(a, b_pub) print("Private Key A: " +binascii.hexlify(a)) print("Public Key A: " +binascii.hexlify(a_pub)) print("Public Key B: " +binascii.hexlify(b_pub)) print("Shared key: " + binascii.hexlify(secret)) # Select loop for listen while self.running == True:
def run(self): self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.settimeout(5.0) try: self.sock.connect((self.host, self.port)) except socket.timeout: print("Timeout, host inacessivel") connecter.config(state=NORMAL) raise SystemExit(0) print("Conectado ao peer:"+ self.host + " on port: " + str(self.port)) # Curve25519 encryption scheme # Usign a size-32 key a = urandom(32) a_pub = scalarmult_base(a) # send public key self.sock.send(a_pub) b_pub = self.sock.recv(32) secret = scalarmult(a, b_pub) print("Private Key A: " +binascii.hexlify(a)) print("Public Key A: " +binascii.hexlify(a_pub)) print("Public Key B: " +binascii.hexlify(b_pub)) print("Shared key: " + binascii.hexlify(secret)) # Select loop for listen while self.running == True:
def run(self): self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.settimeout(5.0) try: self.sock.connect((self.host, self.port)) except socket.timeout: print("Timeout, host inacessivel") connecter.config(state=NORMAL) raise SystemExit(0) print("Conectado ao peer:"+ self.host + " on port: " + str(self.port)) t0 = time.clock() # Curve25519 encryption scheme # Usign a size-32 key a = urandom(32) a_pub = scalarmult_base(a) # send public key self.sock.send(a_pub) context = str(my_ip) + str(peer_ip) + str(i) k_collection = k_db['key_collection'] entry = {"userid":str(my_ip), "context":context, "key": binascii.hexlify(a_pub)} k_collection.insert_one(entry)
def run(self): self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.settimeout(5.0) try: self.sock.connect((self.host, self.port)) except socket.timeout: print("Timeout, host inacessivel") connecter.config(state=NORMAL) raise SystemExit(0) print("Conectado ao peer:"+ self.host + " on port: " + str(self.port)) t0 = time.clock() # Curve25519 encryption scheme # Usign a size-32 key a = urandom(32) a_pub = scalarmult_base(a) # send public key self.sock.send(a_pub) context = str(my_ip) + str(peer_ip) + str(i) des.create('stream', contexto,True) des.publish(contexto, {"userid":str(my_ip), "context":context, "key": binascii.hexlify(a_pub)}) time.seep(tau - (time.clock() - t0)) secret = scalarmult(a, b_pub) count = 0 entries = api.liststreams() for entry in entries: count += 1 entry = entry['details'] if str(entry["context"]) == context and \ str(entry["userid"]) == str(peer_ip): b_pub = binascii.unhexlify(entry["key"]) found = True if (count > 2): for entry in k_collection.find({"context":context}): print(entry) print("poisoned block, disconnect") sys.exit() print("Private Key A: " +binascii.hexlify(a)) print("Public Key A: " +binascii.hexlify(a_pub)) print("Public Key B: " +binascii.hexlify(b_pub)) print("Shared key: " + binascii.hexlify(secret)) # Select loop for listen while self.running == True:
async def create_relationship(self, bulletin_secret, username, to): config = self.config mongo = self.config.mongo if not bulletin_secret: return 'error: "bulletin_secret" missing', 400 if not username: return 'error: "username" missing', 400 if not to: return 'error: "to" missing', 400 rid = TU.generate_rid(config, bulletin_secret) dup = mongo.db.blocks.find({'transactions.rid': rid}) if dup.count(): found_a = False found_b = False for txn in dup: if txn['public_key'] == config.public_key: found_a = True if txn['public_key'] != config.public_key: found_b = True if found_a and found_b: return json.dumps({ "success": False, "status": "Already added" }) miner_transactions = mongo.db.miner_transactions.find() mtxn_ids = [] for mtxn in miner_transactions: for mtxninput in mtxn['inputs']: mtxn_ids.append(mtxninput['id']) checked_out_txn_ids = mongo.db.checked_out_txn_ids.find() for mtxn in checked_out_txn_ids: mtxn_ids.append(mtxn['id']) a = os.urandom(32).decode('latin1') dh_public_key = scalarmult_base(a).encode('latin1').hex() dh_private_key = a.encode('latin1').hex() transaction = await Transaction.generate( bulletin_secret=bulletin_secret, username=username, fee=0.00, public_key=config.public_key, dh_public_key=dh_public_key, private_key=config.private_key, dh_private_key=dh_private_key, outputs=[{ 'to': to, 'value': 0 }]) return transaction
def run(self): HOST = '' s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s.bind((HOST,self.port)) s.listen(1) self.conn, self.addr = s.accept() t0 = time.clock() # Curve25519 encryption scheme # Usign a size-32 key a = urandom(32) a_pub = scalarmult_base(a) # send public key print(binascii.hexlify(a_pub)) self.conn.send(a_pub) b_pub = self.conn.recv(32) time.seep(tau - (time.clock() - t0)) secret = scalarmult(a, b_pub) count = 0 entries = api.liststreams() for entry in entries: count += 1 entry = entry['details'] if str(entry["context"]) == context and \ str(entry["userid"]) == str(peer_ip): b_pub = binascii.unhexlify(entry["key"]) found = True if (count > 2): for entry in k_collection.find({"context":context}): print(entry) print("poisoned block, disconnect") sys.exit() print("Private Key A: " +binascii.hexlify(a)) print("Public Key A: " +binascii.hexlify(a_pub)) print("Public Key B: " +binascii.hexlify(b_pub)) print("Shared key: " + binascii.hexlify(secret)) # Select loop for listen while self.running == True:
def add_user(self, data): user = User.from_dict(data) a = os.urandom(32).decode('latin1') dh_public_key = scalarmult_base(a).encode('latin1').hex() dh_private_key = a.encode('latin1').hex() relationship = user.their_dict relationship.update(self.service.my_dict) relationship['dh_private_key'] = dh_private_key encrypted_relationship = self.service.encrypt_relationship( json.dumps(relationship) ) extra_data = { 'relationship': encrypted_relationship, 'dh_public_key': dh_public_key } data.update(extra_data) return self.service.api_call( '/add-user', data )
def dispatch_request(self): config = app.config['yada_config'] mongo = app.config['yada_mongo'] if request.method == 'GET': bulletin_secret = request.args.get('bulletin_secret', '') username = request.args.get('username', '') to = request.args.get('to', '') else: bulletin_secret = request.json.get('bulletin_secret', '') username = request.json.get('username', '') to = request.json.get('to', '') if not bulletin_secret: return 'error: "bulletin_secret" missing', 400 if not username: return 'error: "username" missing', 400 if not to: return 'error: "to" missing', 400 rid = TU.generate_rid(config, bulletin_secret) dup = mongo.db.blocks.find({'transactions.rid': rid}) if dup.count(): for txn in dup: if txn['public_key'] == config.public_key: return json.dumps({ "success": False, "status": "Already added" }) miner_transactions = mongo.db.miner_transactions.find() mtxn_ids = [] for mtxn in miner_transactions: for mtxninput in mtxn['inputs']: mtxn_ids.append(mtxninput['id']) checked_out_txn_ids = mongo.db.checked_out_txn_ids.find() for mtxn in checked_out_txn_ids: mtxn_ids.append(mtxn['id']) a = os.urandom(32) dh_public_key = scalarmult_base(a).encode('hex') dh_private_key = a.encode('hex') transaction = TransactionFactory(config=config, mongo=mongo, block_height=BU.get_latest_block( config, mongo)['index'], bulletin_secret=bulletin_secret, username=username, fee=0.00, public_key=config.public_key, dh_public_key=dh_public_key, private_key=config.private_key, dh_private_key=dh_private_key, outputs=[{ 'to': to, 'value': 0 }]) TU.save(config, mongo, transaction.transaction) mongo.db.miner_transactions.insert(transaction.transaction.to_dict()) job = Process(target=TxnBroadcaster.txn_broadcast_job, args=(transaction.transaction, )) job.start() my_bulletin_secret = config.bulletin_secret bulletin_secrets = sorted( [str(my_bulletin_secret), str(bulletin_secret)], key=str.lower) rid = hashlib.sha256( str(bulletin_secrets[0]) + str(bulletin_secrets[1])).digest().encode('hex') mongo.site_db.friends.insert({ 'rid': rid, 'relationship': { 'bulletin_secret': bulletin_secret } }) return json.dumps({"success": True})
def dispatch_request(self): config = app.config['yada_config'] mongo = app.config['yada_mongo'] if request.method == 'GET': bulletin_secret = request.args.get('bulletin_secret', '') username = request.args.get('username', '') to = request.args.get('to', '') else: bulletin_secret = request.json.get('bulletin_secret', '') username = request.json.get('username', '') to = request.json.get('to', '') if not bulletin_secret: return 'error: "bulletin_secret" missing', 400 if not username: return 'error: "username" missing', 400 if not to: return 'error: "to" missing', 400 rid = TU.generate_rid(config, bulletin_secret) dup = mongo.db.blocks.find({'transactions.rid': rid}) if dup.count(): found_a = False found_b = False for txn in dup: if txn['public_key'] == config.public_key: found_a = True if txn['public_key'] != config.public_key: found_b = True if found_a and found_b: return json.dumps({"success": False, "status": "Already added"}) miner_transactions = mongo.db.miner_transactions.find() mtxn_ids = [] for mtxn in miner_transactions: for mtxninput in mtxn['inputs']: mtxn_ids.append(mtxninput['id']) checked_out_txn_ids = mongo.db.checked_out_txn_ids.find() for mtxn in checked_out_txn_ids: mtxn_ids.append(mtxn['id']) a = os.urandom(32).decode('latin1') dh_public_key = scalarmult_base(a).encode('latin1').hex() dh_private_key = a.encode('latin1').hex() transaction = TransactionFactory( block_height=BU().get_latest_block()['index'], bulletin_secret=bulletin_secret, username=username, fee=0.00, public_key=config.public_key, dh_public_key=dh_public_key, private_key=config.private_key, dh_private_key=dh_private_key, outputs=[ { 'to': to, 'value': 0 } ] ) mongo.db.miner_transactions.insert(transaction.transaction.to_dict()) job = Process(target=TxnBroadcaster.txn_broadcast_job, args=(transaction.transaction,)) job.start() return json.dumps({"success": True})
salt=salt, iterations=100000, backend=default_backend() ) derived_key = base64.urlsafe_b64encode(kdf.derive(shared_master_key)) f = Fernet(derived_key) # Dependent on the mode, either encrypt or decrypt if is_encryption_mode: return f.encrypt(message.encode()) else: return f.decrypt(message).decode() # Generate the key pair for the reader r_private = urandom(32) r_public = scalarmult_base(r_private) # Generate the key pair for the tag t_private = urandom(32) t_public = scalarmult_base(t_private) # Sign the Public Key of the tag with the Private Key of the reader certificate_salt = urandom(32) t_public_hash = hashlib.sha256(t_public).hexdigest() t_certificate = encrypt(r_private, t_public_hash, certificate_salt) print "Reader Public Key: ",binascii.hexlify(r_public) print "Reader Private Key:",binascii.hexlify(r_private) print print "Tag Public Key: ",binascii.hexlify(t_public)
def get_public(self): return scalarmult_base(self.secret)
async def post(self): config = self.config mongo = self.config.mongo kwargs = json.loads(self.request.body.decode('utf-8')) bulletin_secret = kwargs.get('bulletin_secret', '') username = kwargs.get('username', '') to = kwargs.get('to', '') if not bulletin_secret: return 'error: "bulletin_secret" missing', 400 if not username: return 'error: "username" missing', 400 if not to: return 'error: "to" missing', 400 rid = TU.generate_rid(config, bulletin_secret) dup = mongo.db.blocks.find({'transactions.rid': rid}) if dup.count(): found_a = False found_b = False for txn in dup: if txn['public_key'] == config.public_key: found_a = True if txn['public_key'] != config.public_key: found_b = True if found_a and found_b: return json.dumps({ "success": False, "status": "Already added" }) miner_transactions = mongo.db.miner_transactions.find() mtxn_ids = [] for mtxn in miner_transactions: for mtxninput in mtxn['inputs']: mtxn_ids.append(mtxninput['id']) checked_out_txn_ids = mongo.db.checked_out_txn_ids.find() for mtxn in checked_out_txn_ids: mtxn_ids.append(mtxn['id']) a = os.urandom(32).decode('latin1') dh_public_key = scalarmult_base(a).encode('latin1').hex() dh_private_key = a.encode('latin1').hex() transaction = TransactionFactory( block_height=BU().get_latest_block()['index'], bulletin_secret=bulletin_secret, username=username, fee=0.00, public_key=config.public_key, dh_public_key=dh_public_key, private_key=config.private_key, dh_private_key=dh_private_key, outputs=[{ 'to': to, 'value': 0 }]) mongo.db.miner_transactions.insert(transaction.transaction.to_dict()) """ # TODO: integrate new socket/peer framework for transmitting txns job = Process(target=TxnBroadcaster.txn_broadcast_job, args=(transaction.transaction,)) job.start() """ self.render_as_json({"success": True})
# implementation is a translation of the pseudocode # specified in RFC7748: https://tools.ietf.org/html/rfc7748 # # libraries required for implementation from os import urandom from eccsnacks.curve25519 import scalarmult, scalarmult_base import binascii # (l) is a random selected point for Reader RFID l = urandom(32) a = scalarmult_base(l) # (e) is a random seclected point for RFID tag e = urandom(32) b = scalarmult_base(e) # reference points defined by the scalar multiplication from the elliptic curve c = scalarmult(e, a) d = scalarmult(l, b) # Reader RFID and RFID tag private key values print "RFID private key: ",binascii.hexlify(e) print "Reader private key: ",binascii.hexlify(l) # printing value of A and B in function of (a) and (b) with the Binary ASCII print "A value: ",binascii.hexlify(a) print "B value: ",binascii.hexlify(b) # printing value of A and B in function of (c) and (d) with the Binary ASCII print "C value: ",binascii.hexlify(c) print "D value: ",binascii.hexlify(d)
def test_invalid_scalar(): with pytest.raises(ValueError): scalarmult_base('\xff' * 64)
from os import urandom from eccsnacks.curve25519 import scalarmult, scalarmult_base import binascii lamb = urandom(32) a = scalarmult_base(lamb) eps = urandom(32) b = scalarmult_base(eps) c = scalarmult(eps, a) d = scalarmult(lamb, b) print("RFID private key: ", binascii.hexlify(eps)) print("Reader private key: ", binascii.hexlify(lamb)) print("A value: ", binascii.hexlify(a)) print("B value: ", binascii.hexlify(b)) print("C value: ", binascii.hexlify(c)) print("D value: ", binascii.hexlify(d))
def generate_dh(self): a = os.urandom(32).decode('latin1') dh_public_key = scalarmult_base(a).encode('latin1').hex() dh_private_key = a.encode().hex() return dh_public_key, dh_private_key
async def generate(cls, bulletin_secret='', username='', value=0, fee=0.0, rid='', requester_rid='', requested_rid='', public_key='', dh_public_key='', private_key='', dh_private_key='', to='', inputs='', outputs='', coinbase=False, chattext=None, signin=None, relationship='', no_relationship=False, exact_match=False): cls_inst = cls() cls_inst.config = get_config() cls_inst.mongo = cls_inst.config.mongo cls_inst.app_log = getLogger('tornado.application') cls_inst.bulletin_secret = bulletin_secret cls_inst.username = username cls_inst.rid = rid cls_inst.requester_rid = requester_rid cls_inst.requested_rid = requested_rid cls_inst.public_key = public_key cls_inst.dh_public_key = dh_public_key cls_inst.private_key = private_key cls_inst.value = value cls_inst.fee = float(fee) cls_inst.dh_private_key = dh_private_key cls_inst.to = to cls_inst.time = str(int(time.time())) cls_inst.outputs = [] cls_inst.relationship = relationship cls_inst.no_relationship = no_relationship cls_inst.exact_match = exact_match for x in outputs: cls_inst.outputs.append(Output.from_dict(x)) cls_inst.inputs = [] for x in inputs: if 'signature' in x and 'public_key' in x and 'address' in x: cls_inst.inputs.append(ExternalInput.from_dict(x)) else: cls_inst.inputs.append(Input.from_dict(x)) cls_inst.coinbase = coinbase cls_inst.chattext = chattext cls_inst.signin = signin await cls_inst.do_money() inputs_concat = ''.join([ x.id for x in sorted(cls_inst.inputs, key=lambda x: x.id.lower()) ]) outputs_concat = cls_inst.get_output_hashes() if bulletin_secret or rid: if not cls_inst.rid: cls_inst.rid = cls_inst.generate_rid() if cls_inst.chattext: cls_inst.relationship = json.dumps( {"chatText": cls_inst.chattext}) cls_inst.encrypted_relationship = cls_inst.config.cipher.encrypt( cls_inst.relationship) elif cls_inst.signin: for shared_secret in cls_inst.config.GU.get_shared_secrets_by_rid( cls_inst.rid): cls_inst.relationship = SignIn(cls_inst.signin) cls_inst.cipher = Crypt(shared_secret.hex(), shared=True) cls_inst.encrypted_relationship = cls_inst.cipher.shared_encrypt( cls_inst.relationship.to_json()) break elif cls_inst.relationship: cls_inst.encrypted_relationship = cls_inst.relationship elif cls_inst.no_relationship: cls_inst.encrypted_relationship = '' else: if not cls_inst.dh_public_key or not cls_inst.dh_private_key: a = os.urandom(32).decode('latin1') cls_inst.dh_public_key = scalarmult_base(a).encode( 'latin1').hex() cls_inst.dh_private_key = a.encode().hex() cls_inst.relationship = cls_inst.generate_relationship() if not private_key: raise Exception('missing private key') cls_inst.encrypted_relationship = cls_inst.config.cipher.encrypt( cls_inst.relationship.to_json().encode()) else: cls_inst.rid = '' cls_inst.encrypted_relationship = '' cls_inst.header = (cls_inst.public_key + cls_inst.time + cls_inst.dh_public_key + cls_inst.rid + cls_inst.encrypted_relationship + "{0:.8f}".format(cls_inst.fee) + cls_inst.requester_rid + cls_inst.requested_rid + inputs_concat + outputs_concat) cls_inst.hash = hashlib.sha256( cls_inst.header.encode('utf-8')).digest().hex() if cls_inst.private_key: cls_inst.transaction_signature = TU.generate_signature_with_private_key( private_key, cls_inst.hash) else: cls_inst.transaction_signature = '' return cls(cls_inst.time, cls_inst.rid, cls_inst.transaction_signature, cls_inst.encrypted_relationship, cls_inst.public_key, cls_inst.dh_public_key, float(cls_inst.fee), cls_inst.requester_rid, cls_inst.requested_rid, cls_inst.hash, inputs=[x.to_dict() for x in cls_inst.inputs], outputs=[x.to_dict() for x in cls_inst.outputs], coinbase=cls_inst.coinbase)
def __init__(self, config, mongo, block_height, bulletin_secret='', username='', value=0, fee=0.0, requester_rid='', requested_rid='', public_key='', dh_public_key='', private_key='', dh_private_key='', to='', inputs='', outputs='', coinbase=False, chattext=None, signin=None): self.config = config self.mongo = mongo self.block_height = block_height self.bulletin_secret = bulletin_secret self.username = username self.requester_rid = requester_rid self.requested_rid = requested_rid self.public_key = public_key self.dh_public_key = dh_public_key self.private_key = private_key self.value = value self.fee = float(fee) self.dh_private_key = dh_private_key self.to = to self.time = str(int(time.time())) self.outputs = [] for x in outputs: self.outputs.append(Output.from_dict(x)) self.inputs = [] for x in inputs: if 'signature' in x: self.inputs.append( ExternalInput.from_dict(self.config, self.mongo, x)) else: self.inputs.append(Input.from_dict(x)) self.coinbase = coinbase self.chattext = chattext self.signin = signin self.do_money() inputs_concat = self.get_input_hashes() outputs_concat = self.get_output_hashes() if bulletin_secret: self.rid = self.generate_rid() if self.chattext: self.relationship = json.dumps({"chatText": self.chattext}) self.cipher = Crypt(self.config.wif) self.encrypted_relationship = self.cipher.encrypt( self.relationship) elif self.signin: for shared_secret in TU.get_shared_secrets_by_rid( self.config, self.mongo, self.rid): self.relationship = SignIn(self.signin) self.cipher = Crypt(shared_secret.encode('hex'), shared=True) self.encrypted_relationship = self.cipher.shared_encrypt( self.relationship.to_json()) else: if not self.dh_public_key or not self.dh_private_key: a = os.urandom(32) self.dh_public_key = scalarmult_base(a).encode('hex') self.dh_private_key = a.encode('hex') self.relationship = self.generate_relationship() if not private_key: raise BaseException('missing private key') self.cipher = Crypt(self.config.wif) self.encrypted_relationship = self.cipher.encrypt( self.relationship.to_json()) else: self.rid = '' self.encrypted_relationship = '' self.header = (self.public_key + self.time + self.dh_public_key + self.rid + self.encrypted_relationship + "{0:.8f}".format(self.fee) + self.requester_rid + self.requested_rid + inputs_concat + outputs_concat) self.hash = hashlib.sha256(self.header).digest().encode('hex') if self.private_key: self.transaction_signature = TU.generate_signature_with_private_key( private_key, self.hash) else: self.transaction_signature = '' self.transaction = self.generate_transaction()
# dh_25519.py # Demonstrates generating keypair for Alice & Bob, and lastly # compute Diffie-Hellman and compare keys. from os import urandom from eccsnacks.curve25519 import scalarmult, scalarmult_base # Private keys in Curve25519 can be any 32-byte string. a = urandom(32) a_pub = scalarmult_base(a) b = urandom(32) b_pub = scalarmult_base(b) # perform Diffie-Hellman computation for alice and bob k_ab = scalarmult(a, b_pub) k_ba = scalarmult(b, a_pub) # keys should be the same assert k_ab == k_ba
def create_relationship(): # demo site if request.method == 'GET': bulletin_secret = request.args.get('bulletin_secret', '') username = request.args.get('username', '') to = request.args.get('to', '') else: bulletin_secret = request.json.get('bulletin_secret', '') username = request.json.get('username', '') to = request.json.get('to', '') if not bulletin_secret: return 'error: "bulletin_secret" missing', 400 if not username: return 'error: "username" missing', 400 if not to: return 'error: "to" missing', 400 rid = TU.generate_rid(bulletin_secret) dup = Mongo.db.blocks.find({'transactions.rid': rid}) if dup.count(): for txn in dup: if txn['public_key'] == Config.public_key: return json.dumps({ "success": False, "status": "Already added" }) input_txns = BU.get_wallet_unspent_transactions(Config.address) miner_transactions = Mongo.db.miner_transactions.find() mtxn_ids = [] for mtxn in miner_transactions: for mtxninput in mtxn['inputs']: mtxn_ids.append(mtxninput['id']) checked_out_txn_ids = Mongo.db.checked_out_txn_ids.find() for mtxn in checked_out_txn_ids: mtxn_ids.append(mtxn['id']) a = os.urandom(32) dh_public_key = scalarmult_base(a).encode('hex') dh_private_key = a.encode('hex') transaction = TransactionFactory(bulletin_secret=bulletin_secret, username=username, fee=0.01, public_key=Config.public_key, dh_public_key=dh_public_key, private_key=Config.private_key, dh_private_key=dh_private_key, outputs=[Output(to=to, value=1)]) TU.save(transaction.transaction) Mongo.db.miner_transactions.insert(transaction.transaction.to_dict()) job = Process(target=endpoints.TxnBroadcaster.txn_broadcast_job, args=(transaction.transaction, )) job.start() my_bulletin_secret = Config.get_bulletin_secret() bulletin_secrets = sorted([str(my_bulletin_secret), str(bulletin_secret)], key=str.lower) rid = hashlib.sha256(str(bulletin_secrets[0]) + str(bulletin_secrets[1])).digest().encode('hex') Mongo.site_db.friends.insert({ 'rid': rid, 'relationship': { 'bulletin_secret': bulletin_secret } }) return json.dumps({"success": True})