def handleConnection(self, conn, addr):
try:
key = conn.recv(1024)
username = Encryption().decryptMsg(conn.recv(1024), key)["msg"]
roomId = 0
while True:
roomId = Encryption().decryptMsg(conn.recv(1024), key)["msg"]
if roomId == 0:
room = Room(self)
roomId = room.roomId
self.rooms[roomId] = room
break
elif roomId not in self.rooms:
# vet det er dumt, men for den første gangen må den gjøre det her, tror ikke det gjør så mye
conn.sendall(Encryption().encryptMsg(False, key))
else:
break
room = self.rooms[roomId]
newCon = threading.Thread(target=serverConnection,
args=(conn, addr, key, room, username))
newCon.start()
except:
print("Det skjedde en feil, klient forlot mest sannsynlig")
return
def joinRoom(self, username="******", roomId="12346"):
if self.connected:
self.username = username
try:
self.sock.sendall(Encryption().encryptMsg(
self.username, self.key))
self.sock.sendall(Encryption().encryptMsg(roomId, self.key))
msg = self.sock.recv(1024)
msg = Encryption().decryptMsg(msg, self.key)
if msg["msg"] == False:
return False
self.clientId, self.roomId = msg["msg"]
return True
except Exception as e:
print(e)
return False
else:
print("Not connected")
return False
def handleConnection(self, conn, addr):
key = conn.recv(1024)
while True:
try:
username = Encryption().decryptMsg(conn.recv(1024), key)["msg"]
roomId = int(Encryption().decryptMsg(conn.recv(1024),
key)["msg"])
if roomId == 0:
room = Room(self)
roomId = room.roomId
self.rooms[roomId] = room
break
elif roomId not in self.rooms:
conn.sendall(Encryption().encryptMsg(False, key))
else:
break
except:
print("Klient forlot")
return
# conn.close()
print("startet new con")
room = self.rooms[roomId]
newCon = threading.Thread(target=serverConnection,
args=(conn, addr, key, room, username))
newCon.start()
def __joinRoom(self):
print("0 betyr nytt rom")
roomId = int(input("RoomId: "))
self.sock.sendall(Encryption().encryptMsg(roomId, self.key))
msg = self.sock.recv(1024)
msg = Encryption().decryptMsg(msg, self.key)
return msg, roomId
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 sendMsg(self, msg, username=None, senderId=None):
if username == None and senderId == None:
username = self.username
senderId = self.clientId
msg = Encryption().encryptMsg(msg, self.key, username=username, senderId=senderId)
self.conn.sendall(msg)
def connect(self,
username="******",
roomId="12345",
host="127.0.0.1",
port="9001"):
self.host = host
self.port = int(port)
self.key = fernet.Fernet.generate_key()
try:
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.connect((self.host, self.port))
self.connected = True
self.sock.sendall(self.key)
self.username = str(input("Username: "******"msg"] == False:
print(f"Fant ikke rom med roomId {roomId}")
msg, roomId = self.__joinRoom()
self.clientId, self.roomId = msg["msg"]
print(f"Din klientId: {self.clientId}\nDin romId: {self.roomId}")
self.thread = threading.Thread(target=self.listen)
self.thread.start()
except Exception as e:
print("Klarte ikke å koble til\n", e)
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 cryptography_choice(self):
if self._cryptography == '1':
encryption = Encryption(self.message)
return encryption.transform(self.cipher, self.shift_num)
elif self._cryptography == '2':
decryption = Decryption(self.message)
return decryption.transform(self.cipher)
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 listen(self):
while True:
msg = self.conn.recv(1024)
if len(msg) == 0:
self.room.newMsg(self.username + " left",
username=self.username,
senderId=self.clientId)
self.room.removeClient(self.clientId)
break
if len(msg) > 0:
try:
msg = Encryption().decryptMsg(msg, self.key)
self.room.newMsg(msg["msg"],
username=self.username,
senderId=self.clientId)
except Exception as e:
print(e)
break
self.conn.close()
print(f"{str(self.adr)} stoppet")
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())
def sendMsg(self, msg="TEST"):
try:
msg = Encryption().encryptMsg(msg, self.key)
self.sock.sendall(msg)
except Exception as e:
print(e)
print("Feil med å sende melding")
def get_value(self, section, name):
self.conf_par.read(self.filename)
if name == 'password':
decrypt = Encryption(self._get_serial())
value = decrypt.decrypt_msg(self.conf_par.get(section, name))
else:
value = self.conf_par.get(section, name)
return value
def listen(self):
while True:
msg = self.sock.recv(1024)
msg = Encryption().decryptMsg(msg, self.key)
if msg["clientId"] == self.clientId:
print("You: " + str(msg["msg"]))
else:
print(msg["username"] + ": " + msg["msg"])
def set_value(self, section, name, value):
if name == 'password':
encrypt = Encryption(self._get_serial())
self.conf_par.set(section, name, encrypt.encrypt_msg(value))
else:
conf_par.set(section, name, value)
with open(self.filename, 'wb') as configfile:
self.conf_par.write(configfile)
def initEncryption(self, salt):
self.encryption = Encryption(salt)
# Validation
secrets = self.storage.read()
keys = list(secrets)
if len(keys) > 0:
return self.encryption.validate(secrets[keys[0]])
return False
def test_encryption(self):
req_data = {
"method": "get",
"url": "http://127.0.0.1:9999/demo1.txt",
"headers": None,
"encoding": "base64"
}
ar = Encryption().send(req_data)
print(ar)
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 AutoLogin(self):
Crf = File()
Encrypt = Encryption()
if(Crf.isFile()):
data = Crf.Open()
ra = data[0]
password = data[1]
Login = LoginUTF(Encrypt.Decrypt(ra),Encrypt.Decrypt(password))
return Login.Login()
return False
def __init__(self, address: str):
self.address = address
self.url = f"http://{address}/app"
logger.debug(f"Device url is: {self.url}")
self.encryption = Encryption()
self.key_pair: KeyPair
self.cookie_token: str = ""
self.token: str = ""
self.tp_link_cipher: TpLinkCipher = None
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 getKeys(self):
if (len(sys.argv) > 2):
cypher = Cypher(sys.argv[1], sys.argv[2])
if (len(sys.argv) > 3):
self.pubKey = sys.argv[3]
return chyper
#generate keys
enc = Encryption(79, 83)
print("priv:" + str(enc.private))
print("pub:" + str(enc.pub))
print("mod:" + str(enc.n))
cypher = Cypher(enc.private, enc.n)
self.pubKey = enc.pub
return cypher
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 GetText(self, evt):
text = ""
ra = self.ra.GetValue()
password = self.password.GetValue()
Encrypt = Encryption()
Crf = File()
Crf.Save(Encrypt.Encrypt(ra), Encrypt.Encrypt(password))
Login = LoginUTF(ra, password)
if Login.Login():
SM = wx.MessageBox("Login Successful", "Login", wx.OK)
SM.ShowModal()
else:
FM = wx.MessageBox("Login Unsuccessful", "Login", wx.OK)
FM.ShowModal()
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 listen(self):
while True:
msg = self.sock.recv(1024)
try:
msgArr = Encryption().decryptMsg(msg, self.key)
print(msgArr)
except:
print("Stopped listener")
self.disconnect()
break
if msgArr["clientId"] == self.clientId:
msg = str(msgArr["msg"])
client = True
else:
msg = msgArr["username"] + ": " + msgArr["msg"]
client = False
self.gui.newMsg(msg, client, color=msgArr["color"])
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 __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 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}"
