def get_user_msgs():
# make sure we've the longest chain
required_fields = ["sender", "receiver", "prikey"]
for field in required_fields:
if field not in request.form:
return "Sender or Receiver not provided", 404
sender = unquote(request.form["sender"])
receiver = unquote(request.form["receiver"])
prikey = request.form["prikey"]
# print(repr(prikey))
prikey = prikey.replace("\\n", "\n")
# print(repr(prikey))
try:
key = encryption.read_private_key_string(prikey.encode("ascii"))
except ValueError as e:
return json.dumps({
"length":
0,
"messages":
[[2, "Decryption Error. This account is probably deleted."]],
"peers":
list(peers)
})
consensus()
messages = []
for block in blockchain.chain:
# chain_data.append(block.__dict__)
d = block.__dict__
dt = [
transaction for transaction in d["transactions"]
if (transaction["sender"] == sender and transaction["receiver"] ==
receiver) or (transaction["sender"] == receiver
and transaction["receiver"] == sender)
]
print(dt)
for transaction in dt:
if transaction["sender"] == sender:
try:
msg = encryption.decrypt_message(
bytes(transaction["message"]), key)
messages.append([1, msg, transaction["timestamp"]])
except TypeError:
pass
elif transaction["sender"] == receiver:
try:
msg = encryption.decrypt_message(
bytes(transaction["message"]), key)
messages.append([2, msg, transaction["timestamp"]])
except TypeError:
pass
print(messages)
return json.dumps({
"length": len(messages),
"messages": messages,
"peers": list(peers)
})
def fetch_posts():
"""
Function to fetch the chain from a blockchain node, parse the
data and store it locally.
"""
prikey = """
"""
get_chain_address = "{}/chain".format(CONNECTED_NODE_ADDRESS)
response = requests.get(get_chain_address)
if response.status_code == 200:
content = []
chain = json.loads(response.content)
for block in chain["chain"]:
for tx in block["transactions"]:
tx["index"] = block["index"]
tx["hash"] = block["previous_hash"]
tx["message"] = (encryption.decrypt_message(
tx["message"],
encryption.read_private_key_string(
prikey.encode("ascii")))).decode("ascii")
content.append(tx)
global posts
posts = sorted(content, key=lambda k: k['timestamp'], reverse=True)
print(posts)
def find_password():
website = website_entry.get().title()
try:
with open("data.json", "r") as file:
data = json.load(file)
email = data[website]["email"]
password = encryption.decrypt_message(data[website]["password"])
except (FileNotFoundError, json.decoder.JSONDecodeError):
messagebox.showerror(title="Error", message="No data found.")
except KeyError:
messagebox.showerror(
title="Error",
message=f"No details, for the website {website}, exist.")
else:
messagebox.showinfo(title=website,
message=f"Email : {email}\nPassword : {password}")
def message_receiver(name: str, sock: socket):
"""
Handle receiving messages from server.
:param name: message sender
:param sock: socket
"""
while True:
try:
msg_length = sock.recv(HEADER).decode(FORMAT)
if msg_length:
msg_length = int(msg_length)
message = encryption.decrypt_message(sock.recv(msg_length),
KEY).decode(FORMAT)
sender_length = int(sock.recv(HEADER).decode(FORMAT))
sender = sock.recv(sender_length).decode(FORMAT)
print(f"\n{sender}: {message}\nYou({name}): ", end='')
except OSError as e:
print(e)
break
def get_new_received_msgs():
# make sure we've the longest chain
required_fields = ["sender", "receiver", "prikey", "timestamp"]
for field in required_fields:
if field not in request.form:
return "Sender, Receiver, Private key or Timestamp not provided", 403
sender = request.form["sender"]
receiver = request.form["receiver"]
prikey = clean_key(request.form["prikey"])
timestamp = float(request.form["timestamp"])
# print(repr(prikey))
prikey = prikey.replace("\\n", "\n")
# print(repr(prikey))
key = encryption.read_private_key_string(prikey.encode("ascii"))
consensus()
messages = []
for block in blockchain.chain:
# chain_data.append(block.__dict__)
d = block.__dict__
dt = [
transaction for transaction in d["transactions"]
if (transaction["sender"] == receiver
and transaction["receiver"] == sender)
]
# print(dt)
for transaction in dt:
if transaction["timestamp"] > timestamp:
try:
msg = encryption.decrypt_message(
bytes(transaction["message"]), key)
messages.append([msg, transaction["timestamp"]])
except TypeError:
pass
# print(messages)
return json.dumps({
"length": len(messages),
"messages": messages,
"peers": list(peers)
})
conn.close()
s.close()
sys.exit(0)
signal.signal(signal.SIGINT, exit_gracefully)
signal.signal(signal.SIGTERM, exit_gracefully)
while True:
conn, addr = s.accept()
conn.settimeout(10)
try:
received_data = conn.recv(BUFFER_SIZE)
eprint("bank received " + str(len(received_data)) +
" bytes (encrypted)")
if received_data:
decrypted_data = encryption.decrypt_message(received_data, key)
# eprint("bank received (decrypted): " + my_base64encode(received_data))
if decrypted_data is None:
myprint("protocol_error")
conn.send(
encryption.encrypt_message(constants.FAILURE, key))
else:
eprint("processing message: " + decrypted_data)
success = True
request = Request.from_string(decrypted_data)
if request is None:
success = False
else:
success = process_request(request)
if success:
eprint("processing message -> SUCCESS")
def main():
args = arguments.read_atm_arguments(sys.argv[1:])
if args is None:
eprint("parsing ATM arguments failed. terminating...")
input_error_exit()
(auth_filename, ip_address, port, card_filename, account_name, command,
amount) = args
if ip_address is None:
ip_address = "127.0.0.1"
if port is None:
port = constants.DEFAULT_PORT
if card_filename is None:
card_filename = account_name + ".card"
if auth_filename is None:
auth_filename = "bank.auth"
pin, key = None, None
try:
if command != "n":
card_file = open(card_filename, 'r')
pin = card_file.read()
card_file.close()
else:
if os.path.isfile(card_filename):
eprint("card file already exists:", card_filename)
input_error_exit()
pin = my_base64encode(encryption.create_random_key())
auth_file = open(auth_filename, 'rb')
key = auth_file.read()
eprint("atm key (base64): " + base64.b64encode(key).decode("utf-8"))
auth_file.close()
except IOError as e:
eprint(e)
input_error_exit()
request = Request.Request(account_name, pin, command, amount)
s = socket.socket()
s.settimeout(10)
try:
s.connect((ip_address, port))
data_to_send = str(request)
eprint("atm, sending (decrypted): " + data_to_send)
encrypted_data_to_send = encryption.encrypt_message(data_to_send, key)
eprint("atm, sending " + str(len(encrypted_data_to_send)) +
" bytes, (encrypted)")
s.send(encrypted_data_to_send)
received_data = s.recv(BUFFER_SIZE)
if not received_data:
s.close()
protocol_error_exit()
decrypted_data = encryption.decrypt_message(received_data, key)
if decrypted_data is None:
s.close()
protocol_error_exit()
else:
if decrypted_data == constants.FAILURE:
eprint("received FAILURE code from bank. terminating...")
s.close()
input_error_exit()
else: # success
eprint("received JSON result from bank")
myprint(decrypted_data)
if command == "n":
card_file = open(card_filename, 'w')
card_file.write(pin)
card_file.close()
except Exception as e:
eprint("socket error:", e)
s.close()
protocol_error_exit()