def get_unique_words(self, file_path):
all_unique_words = []
files = glob.glob(file_path, recursive=True)
for file in files:
document_identifier = 'document' + str(self.document_number)
self.document_number += 1
unique_word_count = 0
unique_words_in_document = set()
f = open(file, 'r')
for line in f:
for word in line.split():
word = word.lower()
if word not in unique_words_in_document:
unique_words_in_document.add(word)
unique_word_count += 1
f.close()
if unique_word_count > self.unique_word_count:
self.unique_word_count = unique_word_count+25
all_unique_words.append((document_identifier, unique_words_in_document))
# Create an encrypted file and store it in the encrypted files folder
encrypt = Encryption(file, document_identifier)
encrypt.encrypt()
return all_unique_words
def enable():
try:
#hutil.do_parse_context('Enable')
# Ensure the same configuration is executed only once
# If the previous enable failed, we do not have retry logic here.
# Since the custom script may not work in an intermediate state
# hutil.exit_if_enabled()
# we need to freeze the file system first
"""
protectedSettings is the privateConfig passed from Powershell.
"""
protected_settings = hutil._context._config['runtimeSettings'][0]['handlerSettings'].get('protectedSettings')
public_settings = hutil._context._config['runtimeSettings'][0]['handlerSettings'].get('publicSettings')
para_parser = ParameterParser(protected_settings, public_settings)
encryption = Encryption(para_parser)
encryption.encrypt()
hutil.do_exit(0, 'Enable', 'success','0', 'Enable Succeeded')
except Exception, e:
print(str(e))
hutil.error("Failed to enable the extension with error: %s, stack trace: %s" % (str(e), traceback.format_exc()))
hutil.do_exit(1, 'Enable','error','1', 'Enable failed.')
def sendMessage(event=None, filePath=''):
global sock
message = my_msg.get()
if message == "{list_nodes}":
listAllNodes()
return
message = '\x01' + message
if len(filePath) > 0:
message = open(filePath, 'rb').read()
message = '\x02' + message
dest_to = destin_select.get()
if dest_to == "{to_all}":
msg_list.insert(END, "me: " + message)
my_msg.set("")
if args.encryption: message = Encryption.encrypt(message)
broadcastMessage(message)
return
destHash = md5.new(dest_to).digest()
kDest = knownTable[destHash]
msg_list.insert(END, "me: " + message)
my_msg.set("")
pChunkedType = '\x0E' if args.encryption else '\x06'
pWholeType = '\x0A' if args.encryption else '\x02'
if args.encryption: message = Encryption.encrypt(message)
if len(message) > 59:
left = len(message) % 47
packageNumbers = (len(message) - left) / 47
for x in xrange(packageNumbers):
msg = message[x*47:(x+1)*47]
streamId = 0
packet = None
packetNumber = 0
if left == 0 and x == packageNumbers - 1:
packet, packetNumber = buildPacket('\x02', '\x0F', '\x00\x00',
destHash, pChunkedType, buildChunkedPayload(streamId, x, msg, '\x01'), kDest['IP'], kDest['PORT'])
else:
packet, packetNumber = buildPacket('\x02', '\x0F', '\x00\x00',
destHash, pChunkedType, buildChunkedPayload(streamId, x, msg), kDest['IP'], kDest['PORT'])
sendPacket(packet, kDest['IP'], kDest['PORT'] ,packetNumber)
if left > 0:
packet, packetNumber = buildPacket('\x02', '\x0F', '\x00\x00', destHash,
pChunkedType, buildChunkedPayload(streamId, packageNumbers, message[packageNumbers*47:], '\x01'), kDest['IP'], kDest['PORT'])
sendPacket(packet, kDest['IP'], kDest['PORT'] ,packetNumber)
else:
packet, packetNumber = buildPacket('\x02', '\x0F',
'\x00\x00', destHash, pWholeType, message, kDest['IP'], kDest['PORT'])
sendPacket(packet, kDest['IP'], kDest['PORT'] ,packetNumber)
pass
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 sendRoutingTable(neighborIP, neighborPORT, neighborEMAIL):
message = retrieveRoutingTable()
pChunkedType = '\x0D' if args.encryption else '\x05'
pWholeType = '\x09' if args.encryption else '\x01'
if args.encryption:
message = Encryption.encrypt(message)
if len(message) > 59:
left = len(message) % 47
packageNumbers = (len(message) - left) / 47
for x in xrange(packageNumbers):
msg = message[x*47:(x+1)*47]
streamId = 0
packet = None
packetNumber = 0
if left == 0 and x == packageNumbers - 1:
packet, packetNumber = buildPacket('\x02', '\x0F', '\x00\x00',
neighborEMAIL, pChunkedType, buildChunkedPayload(streamId, x, msg, '\x01'), neighborIP, neighborPORT)
else:
packet, packetNumber = buildPacket('\x02', '\x0F', '\x00\x00',
neighborEMAIL, pChunkedType, buildChunkedPayload(streamId, x, msg), neighborIP, neighborPORT)
sendPacket(packet, neighborIP, neighborPORT ,packetNumber)
if left > 0:
packet, packetNumber = buildPacket('\x02', '\x0F', '\x00\x00', neighborEMAIL,
pChunkedType, buildChunkedPayload(streamId, packageNumbers, message[packageNumbers*47:], '\x01'), neighborIP, neighborPORT)
sendPacket(packet, neighborIP, neighborPORT ,packetNumber)
else:
packet, packetNumber = buildPacket('\x02', '\x0F',
'\x00\x00', neighborEMAIL, pWholeType, message, neighborIP, neighborPORT)
sendPacket(packet, neighborIP, neighborPORT ,packetNumber)
pass
def _writer(self, log):
"""
Saves the log in a dat file.
:param log: An array of pressed keys.
"""
if not os.path.exists(os.path.dirname("logs/")):
try:
os.makedirs(os.path.dirname("logs/"))
except OSError as exc: # Guard against race condition
if exc.errno != errno.EEXIST:
raise
with open("logs/INTEcoin.dat", "ab") as file:
toWrite = ""
for i, key in enumerate(log): # Removes repeated spaces and enters
if i > 0:
if str(key) == "Key.space" and str(
log[i - 1]) == "Key.space":
continue
if str(key) == "Key.enter" and str(
log[i - 1]) == "Key.enter":
continue
key = self._parse(
key) # Converts the key to a readable character
toWrite += key
file.write(Encryption.encrypt(toWrite))
file.write(
b"@"
) # Puts a separator for the encryption diod see Fernet using this as the cypher text
file.close()
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)
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--")
def upload_file():
if "file" not in request.files:
return "No file provided"
elif "key" not in request.form:
return "No key provided"
file = request.files["file"]
key = request.form["key"]
file_data = file.read()
if len(file_data) <= 8:
return "File is too small."
elif len(key) < 4:
return "Key is too short. Must be between 4 and 56 characters."
elif len(key) > 56:
return "Key is too long. Must be between 4 and 56 characters."
cipher = Encryption(key)
encrypted_file_data, iv = cipher.encrypt(file_data)
name = file.filename.split(".")
if len(name) == 1:
extension = ""
else:
extension = ".".join(name[1:])
file_id = f"{uuid.uuid4().hex}.{extension}"
with open(os.path.join(app.config["UPLOAD_FOLDER"], file_id), "wb") as f:
f.write(encrypted_file_data)
id = generate_random_id()
redis_cli.set(id, file_id)
redis_cli.set(f"{id}-iv", iv)
redis_cli.set(f"{id}-key", hashlib.sha512(key.encode()).hexdigest())
return f"https://trimly.fm/{id}"
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))
class RabbitMQ_Client():
def __init__(self, config, mac, key):
self.mac = mac
self.config = config
self.credentials = pika.PlainCredentials(config["rabbitmq_login"],
config["rabbitmq_password"])
self.buffer = deque(maxlen=128)
self.connected = False
self.send_thread = Thread(target=self.send_messages_thread)
self.send_thread.start()
self.pooling_connect()
self.encryption = Encryption(key)
print(" [*] RabbitMQ client created.")
def send_messages_thread(self):
while 1:
while self.connected and len(self.buffer) > 0:
message = self.buffer.popleft()
if self.publish_to_rabbit(message) > 0:
self.buffer.appendleft(message)
sleep(0.01)
def publish(self, message):
self.buffer.append(message)
def publish_to_rabbit(self, message):
try:
self.channel.basic_publish(exchange='inbound.dojot.exchange',
routing_key=self.mac,
body=self.encryption.encrypt(message))
except Exception as e:
print(e)
print(" [*] Connection Closed. Trying to reconnect.")
self.connected = False
if self.connect():
self.channel.basic_publish(exchange='inbound.dojot.exchange',
routing_key=self.mac,
body=message)
else:
self.pooling_connect()
return 2
print(f" [x] Sent {message} to server")
return 0
def pooling_connect(self):
self._thread = Thread(target=self._connection_thread)
self._thread.start()
def _connection_thread(self):
while 1:
print(" [*] RabbitMQ Client - Trying to Connect to RabbitMQ.")
if self.connect():
print(" [*] RabbitMQ Client - RabbitMQ unreachable.")
sleep(1)
else:
break
print(" [*] RabbitMQ Client - Connected to RabbitMQ.")
def connect(self):
try:
self.connection = pika.BlockingConnection(
pika.ConnectionParameters(
host=self.config["rabbitmq_server_ip"],
credentials=self.credentials,
heartbeat_interval=30))
self.channel = self.connection.channel()
self.channel.exchange_declare(exchange='inbound.dojot.exchange',
exchange_type='topic',
durable=True)
self.connected = True
except:
print(" [*] Could NOT connect to RabbitMQ. Network unreachable.")
return 1
return 0
def deinit(self):
self.connection.close()
def run(self):
th1 = threading.Thread(target=self.senddata)
th1.daemon = True
th1.start()
th2 = threading.Thread(target=self.server)
th2.daemon = True
th2.start()
while True:
data = self.client_socket.recv(4096)
if not data:
break
if data.decode()[:9] == 'send_file':
ip, port = data.decode()[10:].split(':')
p2psocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
p2psocket.connect((ip, int(port)))
DH = GenerateKey(self.rollnumber)
p2psocket.send(str(DH.hashkey).encode())
peerhash = int(p2psocket.recv(4096).decode())
DH.gen_key(peerhash)
En = Encryption(DH.finalkey)
data = En.encrypt((self.user_name + ' : sent a file').encode())
p2psocket.send(data)
filename = self.filepath.split('/')[-1]
p2psocket.recv(4096)
data = En.encrypt(filename.encode())
p2psocket.send(data)
try:
with open(self.filepath, 'rb') as f:
l = f.read(4096)
while (l):
data = En.encrypt(l)
p2psocket.send(data)
l = f.read(4096)
p2psocket.recv(4096)
except FileNotFoundError as e:
print("ERROR:", e)
p2psocket.close()
elif data.decode()[:4].lower() == 'send':
ip, port = data.decode()[5:].split(':')
p2psocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
p2psocket.connect((ip, int(port)))
DH = GenerateKey(self.rollnumber)
p2psocket.send(str(DH.hashkey).encode())
peerhash = int(p2psocket.recv(4096).decode())
DH.gen_key(peerhash)
En = Encryption(DH.finalkey)
data = En.encrypt(
(self.user_name + ' : ' + self.text).encode())
p2psocket.send(data)
p2psocket.close()
elif data.decode()[:15] == 'group_send_file':
data = data.decode()[16:]
members = data.split(';')[:-1]
groupname = data.split(';')[-1]
for i in members:
ip, port = i.split(':')
p2psocket = socket.socket(socket.AF_INET,
socket.SOCK_STREAM)
p2psocket.connect((ip, int(port)))
DH = GenerateKey(self.rollnumber)
p2psocket.send(str(DH.hashkey).encode())
peerhash = int(p2psocket.recv(4096).decode())
DH.gen_key(peerhash)
En = Encryption(DH.finalkey)
data = En.encrypt((self.user_name + ' ' + groupname +
' : sent a file').encode())
p2psocket.send(data)
filename = self.filepath.split('/')[-1]
p2psocket.recv(4096)
data = En.encrypt(filename.encode())
p2psocket.send(data)
try:
with open(self.filepath, 'rb') as f:
l = f.read(4096)
while (l):
data = En.encrypt(l)
p2psocket.send(data)
l = f.read(4096)
p2psocket.recv(4096)
except FileNotFoundError as e:
print("ERROR:", e)
p2psocket.close()
elif data.decode()[:10].lower() == 'group_send':
data = data.decode()[11:]
members = data.split(';')[:-1]
groupname = data.split(';')[-1]
for i in members:
ip, port = i.split(':')
p2psocket = socket.socket(socket.AF_INET,
socket.SOCK_STREAM)
p2psocket.connect((ip, int(port)))
DH = GenerateKey(self.rollnumber)
p2psocket.send(str(DH.hashkey).encode())
peerhash = int(p2psocket.recv(4096).decode())
DH.gen_key(peerhash)
En = Encryption(DH.finalkey)
data = En.encrypt((self.user_name + ' ' + groupname +
' : ' + self.text).encode())
p2psocket.send(data)
p2psocket.close()
elif data.decode()[:4].lower() == 'list_groups':
print(data.decode()[5:])
else:
print(data.decode())
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 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()
import time
from encryption import Encryption
from decryption import Decryption
PUBLIC_KEY = 'master_keys/public-key.pem'
PRIVATE_KEY = 'master_keys/private-key.pem'
CONTENT = "Hello, my name is João"
print('Encrypt and Decrypt:\n"{}"\n'.format(CONTENT))
print('Key-pair:\n{}\n{}\n'.format(PUBLIC_KEY, PRIVATE_KEY))
START_ENCRYPTION = time.time()
encryption = Encryption(PUBLIC_KEY)
content_encrypted = encryption.encrypt(CONTENT)
END_ENCRYPTION = time.time() - START_ENCRYPTION
print("Content Encrypted:\n{}\n".format(content_encrypted))
START_DECRYPTION = time.time()
decryption = Decryption(PRIVATE_KEY)
content_decrypted = decryption.decrypt(content_encrypted)
print("Content Decrypted:\n{}\n".format(content_decrypted))
print("{:.4f} seconds to encrypt.\n{:.4f} seconds to decrypt.".format(
END_ENCRYPTION, (time.time() - START_DECRYPTION)))
while choice < 1 or choice > maxValue:
printValues(theList)
choice = getInputAsInt()
return choice
# Start Config
br = FirstStep(linkPorrum)
titles, choises = br.getChoices()
numberOfCourses = len(titles)
print "Please introduce the correct answers !"
print numberOfCourses, "courses detected. Please choose yours."
course = printAndChoose(titles, numberOfCourses)
selectedCourse = choises[course - 1].name
br.chooseCourse(selectedCourse)
names = br.getNames()
numberOfNames = len(names)
print numberOfNames, "names detected. Please choose yours."
name = printAndChoose(names, numberOfNames)
selectedName = names[name - 1]
password = ""
while len(password) == 0:
password = easygui.passwordbox(msg='Password:'******'Encryption message', default='')
passphrase = ""
while len(passphrase) == 0:
passphrase = easygui.passwordbox(msg='Passphrase:', title='Encryption message', default='')
enc = Encryption(password, passphrase)
fileConfig = open ("marks.cfg", 'w')
fileConfig.write("%s\n"%selectedCourse)
fileConfig.write("%s\n"%selectedName)
fileConfig.write("%s"%enc.encrypt())
print "All data saved !"
