def create_ledger(key):
global ledger, privkey
# Create root block
root_block = block.Block(block.BlockType.key, None, utils.encode_key(key))
root_block.sign(key)
ledger = Ledger()
ledger.append(root_block)
privkey = key
# Start Listeners
ledger_listeners(True)
def join_ledger(public_key_hash, member):
global ledger
# Check to make sure we aren't part of a ledger yet
if joined():
print("You are already a member of a ledger")
return
utils.log_message("Spawning TCP Connection Thread to {0}".format(member))
join_message = messaging.Message(settings.MSG_TYPE_JOIN,
public_key_hash).prep_tcp()
thread = messaging.TCPMessageThread(member, join_message)
thread.start()
thread.join()
# If the message is a success, import the key
try:
message = json.loads(thread.message, object_hook=utils.message_decoder)
if message.msg_type == settings.MSG_TYPE_SUCCESS:
key = utils.get_key(message.msg)
key_hash = utils.gen_hash(utils.encode_key(key))
if public_key_hash == key_hash:
# Hooray! We have a match
utils.log_message("Joined ledger {}".format(public_key_hash),
utils.Level.FORCE)
# Sync Ledger
messaging.block_sync(member)
# Request peers
messaging.peer_sync(member)
# Start Listeners
ledger_listeners(True)
else:
raise ValueError(
'Public key returned does not match requested hash: {0}'.
format(key_hash))
else:
raise ValueError('Response was not as expected: {0}'.format(
message.msg_type))
except (ValueError, TypeError) as e:
utils.log_message("Not a valid response from {0}: {1}".format(
member, e))
def do_key(self, args):
"""Manage your local private key
Arguments:
gen: Generate a new RSA key
pub (default): Prints the public key
priv: Prints the private key
"""
args = args.lower()
if len(args) <= 0 or args == 'pub':
if daemon.privkey is not None:
print(utils.encode_key(daemon.privkey))
else:
print("You don't have a key to display")
elif args == 'priv':
print(utils.encode_key(daemon.privkey, public=False))
elif args == 'gen':
daemon.privkey = utils.gen_privkey()
self.do_key('')
else:
print("Unknown argument(s): {}".format(args))
def sign(self, privkey):
# Sign the block body hash
h = SHA256.new(self.body.encode('utf-8'))
signer = PKCS1_v1_5.new(privkey)
# Set the block signature values
self.signature = utils.encode(signer.sign(h))
self.signatory_hash = utils.gen_hash(utils.encode_key(privkey))
# Validate our signature is correct
if not self.validate(privkey.publickey()):
self.signature = None
self.signatory_hash = None
raise RuntimeError(
"Could not sign the block - signature validation failed")
def is_root():
if ledger is not None and ledger.root is not None and privkey is not None:
return ledger.root.message == utils.encode_key(privkey)
else:
return False