def remote_call(ipaddress, opcode, **kwargs):
sock = socket(AF_INET, SOCK_STREAM)
sock.connect((ipaddress, DIFUSE_PORT))
write_message(sock, opcode, **kwargs)
resp = read_message(sock)
sock.close()
return resp
def create(self, connsock, addr, message):
if message['path'] in self.files:
write_message(connsock, method='create', errno=EEXIST)
else:
port = [t[1] for t in self.addrs if t[0] == addr[0]][0]
self.files[message['path']] = (addr[0], port)
write_message(connsock, method='create')
def leave(self, connsock, addr, message):
port = [t[1] for t in self.addrs if t[0] == addr[0]][0]
self.addrs.remove((addr[0], port))
self.files = {
k: v
for k, v in self.files.items() if v != (addr[0], port)
}
# For consistent hashing, need to get files
write_message(connsock, method='leave')
def start(self):
actions = {Opcode.JOIN: self.peer_join, Opcode.LEAVE: self.peer_leave}
while True:
conn, addr = self.sock.accept()
req = read_message(conn)
try:
actions[req['opcode']](conn, addr[0])
except KeyError:
write_message(conn,
Opcode.ERROR,
message='Unsupported opcode.')
conn.close()
def peer_leave(self, leave_conn, leave_ip):
# Remove peer for peerlist
leave_iphash = sha256(leave_ip.encode()).hexdigest()
self.remove_peer(leave_iphash)
# Let other peers know this peer is leaving
for peer_tuple in self.peerlist:
sock = socket(AF_INET, SOCK_STREAM)
sock.connect((peer_tuple[1], DIFUSE_PORT))
write_message(sock,
Opcode.LEAVE,
peer_ip=leave_ip,
hash=leave_iphash)
sock.close()
write_message(leave_conn, Opcode.LEAVE, status='ok')
def start(self):
# Contact bootstrap and ask to join network
resp = remote_call(self.bootstrap, Opcode.JOIN)
if resp['opcode'] == Opcode.ERROR:
print(resp['body']['message'])
exit(1)
self.peerlist = resp['body']['peers']
self.myhash = resp['body']['hash']
# Contact next node and ask for files
neighbor = self.next_peer()
# Listen and action loop
actions = {
Opcode.CHMOD: syscalls.chmod,
Opcode.CREATE: syscalls.create,
Opcode.GETATTR: syscalls.getattr,
Opcode.OPEN: syscalls.open,
Opcode.READ: syscalls.read,
Opcode.READDIR: syscalls.readdir,
Opcode.UNLINK: syscalls.unlink,
Opcode.WRITE: syscalls.write,
Opcode.JOIN: self.add_peer,
Opcode.LEAVE: self.remove_peer
}
while True:
conn, addr = self.sock.accept()
req = read_message(conn)
try:
# Body consists of args to local functions
args = req['body']
try:
ret = actions[req['opcode']](conn, **args)
except OSError as e:
write_message(conn,
Opcode.ERROR,
message='OSError: {}'.format(e.errno))
except KeyError:
write_message(conn,
Opcode.ERROR,
message='Unsupported opcode.')
conn.close()
def listen(sock):
actions = {
'chmod': syscalls.chmod,
'create': syscalls.create,
'getattr': syscalls.getattr,
'open': syscalls.open,
'read': syscalls.read,
'readdir': syscalls.readdir,
'unlink': syscalls.unlink,
'write': syscalls.write,
}
while True:
conn, addr = sock.accept()
message = read_message(conn)
method = message.pop('method')
if method == 'write':
message['data'] = message['data'].encode()
try:
ret = actions[method](**message)
if method == 'read':
ret = ret.decode()
if ret is not None:
write_message(conn, method=method, ret=ret)
else:
write_message(conn, method=method)
except OSError:
write_message(conn, method=method, errno=1)
conn.close()
def send_message(user_info, my_info, message, key):
# Package
pay = protocol.write_message(user_info, my_info, message, protocol_version)
# Encrypt
enc_pay = saber.encrypt(pay.encode(), 20, key)
# Convert to string
str_enc_pay = ''
for i in range(len(enc_pay)):
str_enc_pay = str_enc_pay + chr(enc_pay[i])
# Send payload
s = socket.socket(socket.AF_INET , socket.SOCK_STREAM)
s.settimeout(TIMEOUT)
s.connect((user_info[1], port)) # connet() takes tuple (user_ip, port#)
assert s
s.send(str_enc_pay.encode()) #encode converts message to bin
s.shutdown(1)
s.close()
return
def send_message(user_info, my_info, message, key):
# Package
pay = protocol.write_message(user_info, my_info, message, protocol_version)
# Encrypt
enc_pay = saber.encrypt(pay.encode(), 20, key)
# Convert to string
str_enc_pay = ''
for i in range(len(enc_pay)):
str_enc_pay = str_enc_pay + chr(enc_pay[i])
# Send payload
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(TIMEOUT)
s.connect((user_info[1], port)) # connet() takes tuple (user_ip, port#)
assert s
s.send(str_enc_pay.encode()) #encode converts message to bin
s.shutdown(1)
s.close()
return
def peer_join(self, join_conn, join_ip):
# Check to see if ip already exists in peerlist
join_iphash = sha256(join_ip.encode()).hexdigest()
if self.peer_inlist(join_iphash):
write_message(join_conn,
Opcode.ERROR,
message='IP already in network.')
return
# Let other peers know that this peer is joining
for peer_tuple in self.peerlist:
sock = socket(AF_INET, SOCK_STREAM)
sock.connect((peer_tuple[1], DIFUSE_PORT))
write_message(sock, Opcode.JOIN, peer_ip=join_ip, hash=join_iphash)
sock.close()
self.add_peer(join_ip, join_iphash)
write_message(join_conn,
Opcode.JOIN,
status='ok',
peers=self.peerlist,
hash=join_iphash)
t_string = [ord(test_string[i]) for i in range(len(test_string))]
print("Standardized CipherSaber-2 Test String:\n" + test_string)
dec_t_string = saber.decrypt(t_string, 20, 'Al')
dec_test_string = ''
for i in range(len(dec_t_string)):
dec_test_string = dec_test_string + chr(dec_t_string[i])
print("mead == " + dec_test_string)
wait = input("[Enter to Contine]")
wait = None
## protocol.py
print("\n\n<<<< <<<< <<<< Testing Protocol.py >>>> >>>> >>>>")
print("From: Sender\nTo: Reciever\nMessage: This is a protocol test")
print("v0.1")
message = protocol.write_message(("Reciever", '255.255.255.255'),
("Sender", '1.1.1.1'),
"This is a protocol test", '0.1')
print("Composed Message:\n" + message)
read_message = protocol.read_message(message)
print("Decomposed Message:")
print(read_message)
print("v0.2")
message = protocol.write_message(("Reciever", '255.255.255.255'),
("Sender", '1.1.1.1'),
"This is a protocol test", '0.2')
print("Composed Message:\n" + message)
read_message = protocol.read_message(message)
print("Decomposed Message:")
print(read_message)
wait = input("[Enter to Contine]")
test_string = 'Al Dakota buys'
t_string = [ord(test_string[i]) for i in range(len(test_string))]
print("Standardized CipherSaber-2 Test String:\n" + test_string)
dec_t_string = saber.decrypt(t_string, 20, 'Al')
dec_test_string = ''
for i in range(len(dec_t_string)):
dec_test_string = dec_test_string + chr(dec_t_string[i])
print("mead == " + dec_test_string)
wait = input("[Enter to Contine]")
wait = None
## protocol.py
print("\n\n<<<< <<<< <<<< Testing Protocol.py >>>> >>>> >>>>")
print("From: Sender\nTo: Reciever\nMessage: This is a protocol test")
print("v0.1")
message = protocol.write_message(("Reciever", '255.255.255.255'), ("Sender", '1.1.1.1'), "This is a protocol test", '0.1')
print("Composed Message:\n" + message)
read_message = protocol.read_message(message)
print("Decomposed Message:")
print(read_message)
print("v0.2")
message = protocol.write_message(("Reciever", '255.255.255.255'), ("Sender", '1.1.1.1'), "This is a protocol test", '0.2')
print("Composed Message:\n" + message)
read_message = protocol.read_message(message)
print("Decomposed Message:")
print(read_message)
wait = input("[Enter to Contine]")
wait = None
## messages.py
def unlink(self, connsock, addr, message):
self.files.pop(message['path'])
write_message(connsock, method='unlink')
def readdir(self, connsock, addr, message):
write_message(connsock,
method='readdir',
ret=[file[1:] for file in self.files.keys()])
def find(self, connsock, addr, message):
try:
addr = self.files[message['path']]
write_message(connsock, method='find', addr=addr)
except KeyError:
write_message(connsock, method='find', errno=ENOENT)
def join(self, connsock, addr, message):
self.addrs.append((addr[0], message['port']))
write_message(
connsock,
method='join') # For consistent hashing, need to send files
