class Connection(object):
def __init__(self, server_ip, server_port, private_key, server_pubkey=None):
self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._socket.connect((server_ip, server_port))
if server_pubkey:
self._crypt = Crypt(private_key, server_pubkey)
else:
self._crypt = Crypt(private_key, get_server_public_key())
self._sendPublicKey(private_key)
def __del__(self):
self.close()
def _sendPublicKey(self, private_key):
self._socket.sendall(private_key.publickey().exportKey(format='DER'))
def send(self, data):
data = self._crypt.sign_and_encrypt(data)
self._socket.sendall(data)
def receive(self, size=1024):
data = self._crypt.decrypt_and_auth(self._socket.recv(size))
return data
def close(self):
if not self._socket is None:
self.send(MSG_TYPES.CLOSE)
self._socket.close()
self._socket = None
def __init__(self, server_ip, server_port, private_key, server_pubkey=None):
self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._socket.connect((server_ip, server_port))
if server_pubkey:
self._crypt = Crypt(private_key, server_pubkey)
else:
self._crypt = Crypt(private_key, get_server_public_key())
self._sendPublicKey(private_key)
def __init__(self, server_address, cdb, raw_pubkey, request_handler):
router_logger.info("Setting up server...")
super(CustomTCPServer, self).__init__(server_address, request_handler)
self.key = Crypt().generate_key()
self.crypt = Crypt(self.key)
self.cdb = CircuitDatabase(db_path=cdb,
rid='\x00' * 8,
raw_pubkey=raw_pubkey)
router_logger.info("Server running")
def get_route(self):
route = []
# print self.routers
for r in self.routers[:3]:
ip, port, pk = r
c = Crypt(public_key=pk, private_key=self.private_key)
sid = urandom(8)
sym_key = urandom(16)
enc_pkt = c.sign_and_encrypt("ESTB" + self.rid + sid + sym_key)
route.append((enc_pkt, ip, port, pk, sid, sym_key))
return route
def __init__(self, server_ip, server_port):
self._server_ip = server_ip
self._server_port = server_port
self._router_id = None
self.private_key = Crypt().generate_key()
self.rid = urandom(16)
self.routers = []
def get_file(self):
filename = askopenfilename(filetypes=[("Code files","*.txt"),("All files","*")])
self.crypt=Crypt(filename)
self.orig=self.crypt.get_message()
self.mainPart.delete(0.0,self.mainPart.index(END))
self.mainPart.insert("%d.%d" % (0, 0),self.crypt)
self.mainPart.insert("%d.%d" % (0, 0),'\n')
def read_info(key: bytes, username: str):
conn = sqlite3.connect(keypaths.get(username, None).datapath)
c = conn.cursor()
c.execute("""
SELECT * FROM accounts
""")
rows = c.fetchall()
if rows is None:
print("Error reading database")
return
elif rows == []:
print("Database empty")
return
else:
crypt: Crypt = Crypt(key)
fields: Tuple[str] = ("application", "password", "mnemonic", "pin",
"additional information")
for row in rows:
for field, item in zip(fields, row):
print(f"{field}: {crypt.decrypt(item)}")
print()
conn.close()
return
def _test_connection(self, request):
router_id = request
to_router_id = self._determine_test_router(router_id)
if to_router_id is None:
self._send("NONE")
return
to_router = self.server.tor_routers[to_router_id]
c = Crypt(public_key=self.server.private_key.publickey(),
private_key=self.server.private_key)
now = now_as_str()
payload = c.sign_and_encrypt(now + router_id + to_router_id)
self._send(
struct.pack("!4sI", socket.inet_aton(to_router["ip_addr"]),
to_router["daemon_port"]) + payload)
def code_to_file(self,*args):
g = open('tmp.txt', "w")
g.write(self.code.get())
g.close()
self.crypt=Crypt('tmp.txt')
os.remove('tmp.txt')
self.orig=self.crypt.get_message()
self.mainPart.delete(0.0,self.mainPart.index(END))
self.mainPart.insert("%d.%d" % (0, 0),self.crypt)
self.mainPart.insert("%d.%d" % (0, 0),'\n')
def _create_route(self):
route = ""
shuffled_keys = self.server.tor_routers.keys()
shuffle(shuffled_keys)
for i in range(min(len(shuffled_keys), MAX_PATH_LENGTH)):
details = self.server.tor_routers[shuffled_keys[i]]
c = Crypt(public_key=RSA.import_key(details["pub_key"]),
private_key=self.server.private_key)
sid = get_random_bytes(8)
sym_key = get_random_bytes(16)
enc_pkt = c.sign_and_encrypt("ESTB" + self.server.rid + sid +
sym_key)
route += struct.pack(ROUTE_STRUCT_FMT, enc_pkt,
socket.inet_aton(details["ip_addr"]),
details["port"], details["pub_key"], sid,
sym_key)
self._send(route)
def __init__(self):
# init main window
tk.Tk.__init__(self)
self.lokr_file = ''
self.user_file = '.lokrdata/usrs.ulokr'
self.user = ''
self.wm_iconbitmap(
self, default=self.resource_path('assets\\closedlock.ico'))
self.logo = tk.PhotoImage(file=self.resource_path('assets\\lock.png'))
self.title('LOKR LOGIN')
self.minsize(350, 200)
plain_text_file = open('.lokrdata/cset.dlokr', 'rb')
cipher_text_file = open('.lokrdata/cpcset.dlokr', 'rb')
plain_text = pickle.load(plain_text_file)
cipher_text = pickle.load(cipher_text_file)
plain_text_file.close()
cipher_text_file.close()
self.crypt = Crypt(cipher_text, plain_text)
LoginFrame(self)
self.mainloop()
def __init__(self):
# init main window
tk.Tk.__init__(self)
self.lokr_file = ""
self.user_file = self.resource_path(".lokrdata/usrs.ulokr")
self.user = ""
self.iconbitmap(self.resource_path("assets/closedlock.ico"))
self.logo = tk.PhotoImage(file=self.resource_path("assets/lock.png"))
self.title("LOKR LOGIN")
self.minsize(350, 200)
plain_text_file = open(self.resource_path(".lokrdata/cset.dlokr"),
"rb")
cipher_text_file = open(self.resource_path(".lokrdata/cpcset.dlokr"),
"rb")
plain_text = pickle.load(plain_text_file)
cipher_text = pickle.load(cipher_text_file)
plain_text_file.close()
cipher_text_file.close()
self.crypt = Crypt(cipher_text, plain_text)
LoginFrame(self)
self.mainloop()
def _connection_test_results(self, request):
now = datetime.utcnow()
c = Crypt(public_key=self.server.private_key.publickey(),
private_key=self.server.private_key)
header = c.decrypt_and_auth(request[:512])
start_time = header[:TIME_STR_SIZE]
from_router_id = header[TIME_STR_SIZE:TIME_STR_SIZE + ROUTER_ID_SIZE]
to_router_id = header[TIME_STR_SIZE + ROUTER_ID_SIZE:]
i = 1
times = [datetime_from_str(start_time)]
for router_id in [from_router_id, to_router_id]:
router = self.server.tor_routers.get(router_id, None)
if router is None:
return
c = Crypt(public_key=RSA.import_key(router["pub_key"]),
private_key=self.server.private_key)
times.append(
datetime_from_str(
c.decrypt_and_auth(request[i * 512:(i + 1) * 512])))
i += 1
times.append(now)
for i in range(1, len(times)):
if times[i] < times[i - 1]:
# error, malicious or otherwise
return
latency = (times[2] - times[1]).total_seconds() * 1000
def write_info(key: bytes, username: str):
conn = sqlite3.connect(keypaths.get(username, None).datapath)
c = conn.cursor()
application: str = str(
input("""
Please input the name of the application you are storing information for:
(Enter nothing or any placeholder text you want if this field is not pertinent)
"""))
application_password: str = str(
input("""
Please input application's password:
(Enter nothing or any placeholder text you want if this field is not pertinent)
"""))
mnemonic: str = str(
input("""
Please input application's mnemonic:
(Enter nothing or any placeholder text you want if this field is not pertinent)
(Enter the mnemonic separated by commas without pressing enter, like so: hello, how, are, you)
Press enter only when you are done entering the mnemonic
"""))
pin: str = str(
input("""
Please input application's pin number:
(Enter nothing or any placeholder text you want if this field is not pertinent)
(Enter the pin separated by commas without pressing enter, like so: 1, 2, 3, 4, 5)
Press enter only when you are done entering the pin
"""))
additional: str = str(
input("""
Please input any additional information about the application you may need:
(Enter one continuous string like with the pin or mnemonic, you can input any text you like)
Please press enter only when you are done entering the additional information
"""))
crypt: Crypt = Crypt(key)
c.execute(
"""
INSERT INTO accounts (application, password, mnemonic, pin, additional) VALUES
(?, ?, ?, ?, ?)
""", (crypt.encrypt(application), crypt.encrypt(application_password),
crypt.encrypt(mnemonic), crypt.encrypt(pin),
crypt.encrypt(additional)))
conn.commit()
conn.close()
print("Information Successfully Stored!")
def build_circuit(self, prev_sock):
"""build_circuit
Builds a circuit from the client initialization
Args:
prev_sock (socket.socket): socket connection to the previous hop
"""
body, status = self._get_payload(
prev_sock, self.client_sym) # TODO: handle bad status
der_len = Crypt().PUB_DER_LEN
raw_clientkey, body = body[:der_len], body[der_len:]
self.pubkey = RSA.importKey(raw_clientkey)
self.prev_symkey, self.next_symkey, next_ip, self.port, next_payload = \
struct.unpack(">16s16s4sl%ds" % (max((len(body) - 40), 0)), body)
self.ip = socket.inet_ntoa(next_ip)
self.prev_sym = Symmetric(self.prev_symkey)
if self.port == -1:
self.is_exit = True
circuit_logger.debug("Built exit node! *****")
payload = self.client_sym.encrypt_payload('', 'OKOK')
payload = self.prev_sym.encrypt_payload(payload, 'OKOK')
else:
self.is_exit = False
self.next_sym = Symmetric(self.next_symkey)
circuit_logger.debug("Connecting to %s:%d" % (self.ip, self.port))
next_sock = socket.socket()
next_sock.connect((self.ip, self.port))
next_sock.sendall(next_payload)
circuit_logger.debug("Getting response from %s:%d" %
(self.ip, self.port))
payload, status = self._get_payload(
next_sock, self.next_sym) # TODO: handle bad status
payload = self.client_sym.encrypt_payload(payload, 'OKOK')
payload = self.prev_sym.encrypt_payload(payload, 'OKOK')
prev_sock.sendall(payload)
from Crypt import Crypt
import numpy as np
crypter = Crypt()
for i in range(10):
i = i + 1
# print()
data, key = crypter.encrypt(''.join([
crypter.dic[int(np.random.rand() * (len(crypter.dic) - 1))]
for j in range(i * 10)
]))
print(len(data) / (i * 10))
def append_current_time(payload, private_key, server_pubey=None):
if server_pubey:
c = Crypt(public_key=server_pubey, private_key=private_key)
else:
c = Crypt(public_key=get_server_public_key(), private_key=private_key)
return payload + c.sign_and_encrypt(now_as_str())
def main():
print "SHOULD NOT BE CALLED DIRECTLY. INTENDED FOR TESTING PURPOSED ONLY"
start(sys.argv[1], int(sys.argv[2]),
Crypt().generate_key(),
uuid.uuid4().bytes)
# daemon for tor routers to report network info to the pathing server
import sys
import uuid
import time
import threading
import struct
import socket
from SocketServer import TCPServer, BaseRequestHandler
from Crypt import Crypt
from shared import *
CONN_KEY = Crypt().generate_key()
def append_current_time(payload, private_key, server_pubey=None):
if server_pubey:
c = Crypt(public_key=server_pubey, private_key=private_key)
else:
c = Crypt(public_key=get_server_public_key(), private_key=private_key)
return payload + c.sign_and_encrypt(now_as_str())
class CustomTCPServer(TCPServer, object):
def __init__(self,
server_address,
request_handler,
pathing_server_ip,
pathing_server_port,
router_private_key,
server_pubkey=None):
Removed a circuit from the database
Args:
circ (Circuit): circuit to remove
"""
cid = circ.cid.encode("hex")
if circ.is_pf:
self.cur.execute("DELETE FROM pfs WHERE id = (?);", (cid, ))
else:
self.cur.execute("DELETE FROM circuits WHERE id = (?);", (cid, ))
cdb_logger.debug("Removed circuit " + repr(circ.name))
if __name__ == "__main__":
cid = urandom(8)
symkey = Crypt().generate_key()
k1 = Crypt().generate_key()
k2 = Crypt().generate_key()
c_client = Crypt(public_key=k1.publickey(), private_key=k2)
c_router = Crypt(public_key=k2.publickey(), private_key=k1)
pkt = c_client.sign_and_encrypt("CLNT" + cid + symkey)
data, hash = c_router.decrypt(pkt)
cd = CircuitDatabase(db_path="circuitdb_1234.db")
c = ClientCircuit(cid, cid, c_router)
cd.add(c)
# cd.get(data, hash, c_router)
# cd.remove(c)
# cd.remove(c)
# try:
# cd.get('ABCD')
try:
import crypto
except ImportError:
print(
"Please install Ark crypto library by running 'pip install arkecosystem-crypto'"
)
raise SystemExit(1)
from Crypt import Crypt
from . import CryptArk
Crypt.registerCrypto("Ark", CryptArk)
def setup(self):
self._crypt = Crypt(self.server.private_key)
self._id = self.server.getUniqueConnectionId()
class TCPHandler(BaseRequestHandler):
def _output(self, message, indent=True):
if indent:
message = "--- " + message
print "id%d: %s" % (self._id, message)
def _send(self, message):
data = self._crypt.sign_and_encrypt(message)
self.request.sendall(data)
def _register_router(self, request):
(port, pub_key) = struct.unpack("!I%ds" % DER_KEY_SIZE, request)
self._output("Registering new router: %s:%d" %
(self.client_address[0], port))
router_id = uuid.uuid4().bytes
self.server.tor_routers[router_id] = {
"ip_addr": self.client_address[0],
"port": port,
"pub_key": pub_key
}
self.server.connection_tests[router_id] = {}
self._send(router_id)
def _register_daemon(self, request):
(router_id, daemon_port) = struct.unpack("!%dsI" % ROUTER_ID_SIZE,
request)
if router_id in self.server.tor_routers:
self.server.tor_routers[router_id]["daemon_port"] = daemon_port
def _determine_test_router(self, from_router_id):
for k in self.server.tor_routers.keys():
if k != from_router_id and "daemon_port" in self.server.tor_routers[
k]:
return k
return None
def _test_connection(self, request):
router_id = request
to_router_id = self._determine_test_router(router_id)
if to_router_id is None:
self._send("NONE")
return
to_router = self.server.tor_routers[to_router_id]
c = Crypt(public_key=self.server.private_key.publickey(),
private_key=self.server.private_key)
now = now_as_str()
payload = c.sign_and_encrypt(now + router_id + to_router_id)
self._send(
struct.pack("!4sI", socket.inet_aton(to_router["ip_addr"]),
to_router["daemon_port"]) + payload)
def _connection_test_results(self, request):
now = datetime.utcnow()
c = Crypt(public_key=self.server.private_key.publickey(),
private_key=self.server.private_key)
header = c.decrypt_and_auth(request[:512])
start_time = header[:TIME_STR_SIZE]
from_router_id = header[TIME_STR_SIZE:TIME_STR_SIZE + ROUTER_ID_SIZE]
to_router_id = header[TIME_STR_SIZE + ROUTER_ID_SIZE:]
i = 1
times = [datetime_from_str(start_time)]
for router_id in [from_router_id, to_router_id]:
router = self.server.tor_routers.get(router_id, None)
if router is None:
return
c = Crypt(public_key=RSA.import_key(router["pub_key"]),
private_key=self.server.private_key)
times.append(
datetime_from_str(
c.decrypt_and_auth(request[i * 512:(i + 1) * 512])))
i += 1
times.append(now)
for i in range(1, len(times)):
if times[i] < times[i - 1]:
# error, malicious or otherwise
return
latency = (times[2] - times[1]).total_seconds() * 1000
def _unregister_router(self, request):
router_id = request[:ROUTER_ID_SIZE]
if self.server.tor_routers[router_id][
"ip_addr"] == self.client_address[0]:
details = self.server.tor_routers.pop(router_id, None)
self.server.connection_tests.pop(router_id, None)
if not details is None:
self._output("Deregistering router: %s:%d" %
(details["ip_addr"], details["port"]))
def _create_route(self):
route = ""
shuffled_keys = self.server.tor_routers.keys()
shuffle(shuffled_keys)
for i in range(min(len(shuffled_keys), MAX_PATH_LENGTH)):
details = self.server.tor_routers[shuffled_keys[i]]
c = Crypt(public_key=RSA.import_key(details["pub_key"]),
private_key=self.server.private_key)
sid = get_random_bytes(8)
sym_key = get_random_bytes(16)
enc_pkt = c.sign_and_encrypt("ESTB" + self.server.rid + sid +
sym_key)
route += struct.pack(ROUTE_STRUCT_FMT, enc_pkt,
socket.inet_aton(details["ip_addr"]),
details["port"], details["pub_key"], sid,
sym_key)
self._send(route)
def setup(self):
self._crypt = Crypt(self.server.private_key)
self._id = self.server.getUniqueConnectionId()
def handle(self):
self._output("Establishing connection with with %s, port %s" %
self.client_address,
indent=False)
request = self.request.recv(DER_KEY_SIZE)
self._crypt.setPublicKey(RSA.import_key(request))
while True:
request = self.request.recv(4096)
if len(request) == 0:
continue
try:
request = self._crypt.decrypt_and_auth(request)
request_type = request[0]
request = request[1:]
except:
self._output("ERROR: Message authentication failed")
return
if request_type == MSG_TYPES.REGISTER_SERVER:
self._register_router(request)
elif request_type == MSG_TYPES.DEREGISTER_SERVER:
self._unregister_router(request)
elif request_type == MSG_TYPES.GET_ROUTE:
self._output("Creating route")
self._create_route()
elif request_type == MSG_TYPES.REGISTER_DAEMON:
self._output("Registering daemon for router")
self._register_daemon(request)
elif request_type == MSG_TYPES.TEST_CONNECTION:
self._output("Testing connection")
self._test_connection(request)
elif request_type == MSG_TYPES.CONNECTION_TEST_RESULTS:
self._output("Getting connection test results")
self._connection_test_results(request)
elif request_type == MSG_TYPES.CLOSE:
self._output("Client exiting connection")
return
class Application:
'''Creates a GUI to interact with.'''
def __init__(self,master):
'''Initializes the GUI.'''
self.crypt=''
self.encrypt='e'
self.orig=''
self.shif=StringVar()
self.mult=StringVar()
self.code=StringVar()
master.title("Crypt")
self.makeMenuBar(master)
top_frame = Frame(master)
top_frame.pack(fill=X, expand=1)
self.label =Label(top_frame, text='Enter a code here or open a file:')
self.label.pack(side=LEFT)
self.go=Button(top_frame, text="Ok",command=self.code_to_file,default=ACTIVE)
self.go.pack(side=RIGHT)
self.entry = Entry(top_frame, width=50, textvariable=self.code)
self.entry.pack(side=RIGHT)
self.mainPart = Text(master,
background = 'white',
padx = 20,
pady = 20)
self.mainPart.pack(fill = 'both', expand = 1)
mid_frame = Frame(master)
mid_frame.pack(fill=X, expand=1)
bottom_frame = Frame(master)
bottom_frame.pack(fill=X,expand=1)
self.shift_button = Button(mid_frame, text="Shift Substitution:\nC=P+b", command=self.shift)
self.shift_button.pack(side=LEFT,fill=X)
self.multi_button = Button(mid_frame, text="Multiplicative Substitution:\nC=mP", command=self.multi)
self.multi_button.pack(side=RIGHT,fill=X)
self.v=StringVar()
self.v.set('e')
self.encrypt_button = Radiobutton(mid_frame, text="Encrpyt", variable=self.v,value='e',command=self.en)
self.encrypt_button.pack(anchor=S)
self.encrypt_button = Radiobutton(mid_frame, text="Decrpyt",variable=self.v,value='d',command=self.en)
self.encrypt_button.pack(anchor=S)
Label(text='Amount to Shift(b)').pack(side=LEFT)
self.shift_entry=Entry(bottom_frame,textvariable=self.shif,justify=CENTER)
self.shift_entry.pack(side=LEFT)
self.shift_entry.insert(ANCHOR,'1')
Label(text='Amount to Multiply(m)').pack(side=RIGHT)
self.mult_entry=Entry(bottom_frame,textvariable=self.mult,justify=CENTER)
self.mult_entry.pack(side=RIGHT)
self.mult_entry.insert(ANCHOR,'3')
self.affine_button = Button(bottom_frame, text="Affine Substitution:\nC=mP+b", command=self.affine)
self.affine_button.pack(side=BOTTOM,fill=X)
self.letterfrequency=Button(master, text='Display Letter Frequency', command=self.letters)
self.letterfrequency.pack(side=BOTTOM)
self.entry.bind('<Return>', self.code_to_file)
def code_to_file(self,*args):
g = open('tmp.txt', "w")
g.write(self.code.get())
g.close()
self.crypt=Crypt('tmp.txt')
os.remove('tmp.txt')
self.orig=self.crypt.get_message()
self.mainPart.delete(0.0,self.mainPart.index(END))
self.mainPart.insert("%d.%d" % (0, 0),self.crypt)
self.mainPart.insert("%d.%d" % (0, 0),'\n')
def makeMenuBar(self,frame):
menubar = Frame(frame,relief=RAISED,borderwidth=1)
menubar.pack(fill=X)
mb_file = Menubutton(menubar,text='File')
mb_file.pack(side=LEFT)
mb_file.menu = Menu(mb_file)
mb_file.menu.add_command(label="Load a file", command=self.get_file)
mb_file.menu.add_command(label="Save", command=self.save_file)
mb_file.menu.add_command(label='Quit', command=quit)
# mb_edit = Menubutton(menubar,text='edit')
# mb_edit.pack(side=LEFT)
# mb_edit.menu = Menu(mb_edit)
# mb_edit.menu.add_command(label='copy')
# mb_edit.menu.add_command(label='paste')
mb_help = Menubutton(menubar,text='Help')
mb_help.pack(padx=25,side=RIGHT)
mb_help.menu = Menu(mb_help)
mb_help.menu.add_command(label="Instructions", command=self.help)
mb_file['menu'] = mb_file.menu
mb_help['menu'] = mb_help.menu
def help(self):
print 'TO BE MADE. POP UP HELP'
def en(self):
self.encrypt=self.v.get()
def get_file(self):
filename = askopenfilename(filetypes=[("Code files","*.txt"),("All files","*")])
self.crypt=Crypt(filename)
self.orig=self.crypt.get_message()
self.mainPart.delete(0.0,self.mainPart.index(END))
self.mainPart.insert("%d.%d" % (0, 0),self.crypt)
self.mainPart.insert("%d.%d" % (0, 0),'\n')
def save_file(self):
filename = asksaveasfilename(filetypes=[("Code files","*.txt"),("All files","*")])
g = open(filename, "w")
g.write(self.crypt.get_message())
g.close()
def shift(self):
if self.crypt!='':
self.crypt.shift(int(self.shif.get()), self.encrypt)
self.mainPart.delete(0.0,self.mainPart.index(END))
self.mainPart.insert("%d.%d" % (0, 0),self.orig)
self.mainPart.insert("%d.%d" % (0, 0),'\n')
self.mainPart.insert(0.0,self.crypt)
def multi(self):
if self.crypt!='':
if int(self.mult.get())%2!=0 and int(self.mult.get())!=13:
self.crypt.multiply(int(self.mult.get()), self.encrypt)
self.mainPart.delete(0.0,self.mainPart.index(END))
self.mainPart.insert("%d.%d" % (0, 0),self.orig)
self.mainPart.insert("%d.%d" % (0, 0),'\n')
self.mainPart.insert(0.0,self.crypt)
def affine(self):
if self.crypt!='':
if int(self.mult.get())%2!=0 and int(self.mult.get())!=13:
self.crypt.affine(int(self.shif.get()),int(self.mult.get()), self.encrypt)
self.mainPart.delete(0.0,self.mainPart.index(END))
self.mainPart.insert("%d.%d" % (0, 0),self.orig)
self.mainPart.insert("%d.%d" % (0, 0),'\n')
self.mainPart.insert(0.0,self.crypt)
def letters(self):
if self.crypt!='':
self.crypt.letter_frequency()
from Crypt import Crypt
from Decrypt import Decrypt
from Utils import Utils
utils = Utils()
running = True
mainMenu = ["Encryptar", "Decryptar", "Salir"]
cryptMenu = ["Encryptar mensaje", "Mostrar public key", "Mostrar private key", "Mostrar mod n", "Salir"]
decryptMenu = ["Dencryptar mensaje", "Setear nuevo mod n", "Setear nuevo private key", "Salir"]
while running:
mainKey = utils.chooseKey(mainMenu)
if mainKey == 1:
cm = True
crypt = Crypt()
while cm:
cryptKey = utils.chooseKey(cryptMenu)
if cryptKey == 1:
crypt.cryptMessage(input("Ingrese el mensaje que desea encryptar:\n"))
elif cryptKey == 2:
crypt.showPublicKey()
elif cryptKey == 3:
crypt.showPrivateKey()
elif cryptKey == 4:
crypt.showModN()
else:
print("Ha salido del menu")
cm = False
elif mainKey == 2:
cm = True
decrypt = Decrypt()
while cm:
class Lokr(tk.Tk):
ver = 1.2
def __init__(self):
# init main window
tk.Tk.__init__(self)
self.lokr_file = ""
self.user_file = self.resource_path(".lokrdata/usrs.ulokr")
self.user = ""
self.iconbitmap(self.resource_path("assets/closedlock.ico"))
self.logo = tk.PhotoImage(file=self.resource_path("assets/lock.png"))
self.title("LOKR LOGIN")
self.minsize(350, 200)
plain_text_file = open(self.resource_path(".lokrdata/cset.dlokr"),
"rb")
cipher_text_file = open(self.resource_path(".lokrdata/cpcset.dlokr"),
"rb")
plain_text = pickle.load(plain_text_file)
cipher_text = pickle.load(cipher_text_file)
plain_text_file.close()
cipher_text_file.close()
self.crypt = Crypt(cipher_text, plain_text)
LoginFrame(self)
self.mainloop()
# PASSWORD MANIPULATION METHODS
def savePassword(self, label, pwd, key):
# appends encrypted pass, key, lbl to user's .lokr file
encrypted_label = self.crypt.encrypt(label, key)
encrypted_password = self.crypt.encrypt(pwd, key)
file = open(self.resource_path(self.lokr_file), "rb")
file.seek(0)
whatsinside = pickle.load(file)
file.close()
whatsinside[encrypted_label] = {str(key): encrypted_password}
file = open(self.resource_path(self.lokr_file), "wb")
pickle.dump(whatsinside, file)
file.close()
def editPassword(self, index, label, pwd):
# edits password: delete and resaves with new info
keys = self.parseLokrFile("keys")
self.deletePassword(index)
self.savePassword(label, pwd, int(keys[index]))
def deletePassword(self, index):
# delete password from user's .lokr
labels = self.parseLokrFile("labels")
file = open(self.resource_path(self.lokr_file), "rb")
file.seek(0)
contents = pickle.load(file)
file.close()
del contents[labels[index]]
file = open(self.resource_path(self.lokr_file), "wb")
pickle.dump(contents, file)
file.close()
# USER MANAGEMENT METHODS
def setUserLokrFile(self, username):
# set user's lokr file
self.user = username
for file in os.listdir(self.resource_path(".lokrdata")):
if file == (self.crypt.encrypt(username, 11) + ".lokr"):
self.lokr_file = ".lokrdata/" + file
def readUsersFile(self):
# reads USR file, returns: decrypted usr info as a dict in format: usr:pwd
file = open(self.resource_path(self.user_file), "rb")
user_data = pickle.load(file)
file.close()
decrypted_user_data = {}
for user, pwd in user_data.items():
decrypted_user_data[self.crypt.decrypt(user,
7)] = self.crypt.decrypt(
pwd, 7)
return decrypted_user_data
def saveUser(self, usr, pwd):
# appends usr and pwd to USR file
file = open(self.resource_path(self.user_file), "rb")
user_data = pickle.load(file)
file.close()
user_data[self.crypt.encrypt(usr, 7)] = self.crypt.encrypt(pwd, 7)
file = open(self.resource_path(self.user_file), "wb")
pickle.dump(user_data, file)
file.close()
def authenticate(self, usr, pwd):
# checks if usr and pwd match USR file, returns True if correct
for user, password in self.readUsersFile().items():
if user == usr and password == pwd:
return True
return False
# LOKR FILE METHODS
def parseLokrFile(self, call):
# reads .lokr, input: call('keys', 'labels, or 'pwds'), returns: requested info as a list
file = open(self.resource_path(self.lokr_file), "rb")
file.seek(0)
lokr_data = pickle.load(file)
labels = list(lokr_data.keys())
keys = []
pwds = []
file.close()
for k, i in enumerate(list(lokr_data.keys())):
keys.append((list(list(lokr_data.values())[k].keys())[0]))
for k, i in enumerate(list(lokr_data.keys())):
pwds.append((list(list(lokr_data.values())[k].values())[0]))
if call == "keys":
return keys
if call == "labels":
return labels
if call == "pwds":
return pwds
def decryptLokr(self, info):
# decrypts .lokr file, input: info('labels' or 'pwds'), returns: requested info as a list
keys = self.parseLokrFile("keys")
labels = self.parseLokrFile("labels")
pwds = self.parseLokrFile("pwds")
newlabels = [
self.crypt.decrypt(labels[x], keys[x]) for x in range(len(keys))
]
newpwds = [
self.crypt.decrypt(pwds[x], keys[x]) for x in range(len(keys))
]
if info == "labels":
return newlabels
if info == "pwds":
return newpwds
def createLokr(self, name):
# creates new .lokr file for user with defaults
file = open(
self.resource_path(".lokrdata/" + self.crypt.encrypt(name, 11) +
".lokr"),
"wb",
)
pickle.dump({"ExampleLabel": {5: "ExamplePassword"}}, file)
file.close()
# HELPER METHODS
def resource_path(self, relative_path):
# PyInstaller creates a temp folder and stores path in _MEIPASS
current_file_path = __file__
current_file_dir = os.path.dirname(__file__)
# os.path.join(current_file_dir,
try:
base_path = sys._MEIPASS
except Exception:
base_path = os.path.abspath(".")
return os.path.join(current_file_dir, relative_path)
def __init__(self, server_ip, server_port, server_pubkey=None):
self._server_ip = server_ip
self._server_port = server_port
self._router_id = None
self._private_key = Crypt().generate_key()
self._server_pubkey = server_pubkey
from Crypt import Crypt
from datetime import datetime
import socket
from Crypto.PublicKey import RSA
def now_as_str():
return str(datetime.utcnow())
def datetime_from_str(string):
return datetime.strptime(string, "%Y-%m-%d %H:%M:%S.%f")
def get_server_public_key():
with open('public.pem','r') as f:
return RSA.import_key(f.read())
DER_KEY_SIZE = len(Crypt().generate_key().publickey().exportKey(format='DER'))
ROUTER_ID_SIZE = len(uuid.uuid4().bytes)
TIME_STR_SIZE = len(now_as_str())
ENC_PACKET_ROUTE_SIZE = 512
ROUTE_STRUCT_FMT = "!%ds4sI%ds8s16s" % (ENC_PACKET_ROUTE_SIZE, DER_KEY_SIZE)
HEARTBEAT_INTERVAL_SEC = 10
class MSG_TYPES(object):
REGISTER_SERVER = chr(1)
DEREGISTER_SERVER = chr(2)
GET_ROUTE = chr(3)
CLOSE = chr(4)
REGISTER_DAEMON = chr(5)
TEST_CONNECTION = chr(6)
CONNECTION_TEST_RESULTS = chr(7)
class MyTCPHandler(BaseRequestHandler):
CT_BLOCK_SIZE = 256
HEADER_SIZE = CT_BLOCK_SIZE * 2
DER_LEN = len(Crypt().generate_key().publickey().exportKey(format='DER'))
def setup(self):
# router_logger.info("Setting up TCPHandler")
self.exit = False
self.next_sock = None
self.client_crypt = None
self.prev_crypt = None
self.next_crypt = None
def pull(self, sock, length):
message = ''
while len(message) < length:
message += sock.recv(length - len(message))
return message
def handle(self):
router_logger.info('handling connection from %s:%s' %
self.client_address)
router_logger.debug("Waiting for header...")
header = self.pull(self.request, self.HEADER_SIZE)
router_logger.debug("Pulled header (%dB) %s" %
(len(header), repr(header.encode('hex')[:8])))
try:
method, circ = self.server.cdb.get(header, self.server.crypt)
except BadMethod:
e = sys.exc_info()
raise e[0], e[1], e[2]
if method == self.server.cdb.ESTB:
router_logger.info("Building circuit")
circ.build_circuit(self.request)
self.server.cdb.add(circ)
else:
router_logger.info("Handling request")
status = circ.handle_connection(self.request)
if status == circ.EXIT:
router_logger.info("Removing circuit %s" % repr(circ.name))
self.server.cdb.remove(circ)
else:
router_logger.info("Sucessfully returned request")
def make_next_hop(self, next_hop, data):
router_logger.info("Sending establishment circuit to next router")
self.next_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.next_sock.connect(next_hop)
self.next_sock.sendall(data)
def forward_payload(self):
router_logger.info('Waiting for payload to forward...')
header = self.pull(self.request, self.HEADER_SIZE)
router_logger.info('Received header of payload (%dB)' % len(header))
header = self.client_crypt.decrypt_and_auth(header)
if self.exit:
num_chunks, ip, port = header.split(":")
if ip == "CLOSE":
router_logger.info("Closing circuit")
return False
close = "OK"
router_logger.info("Sending payload to %s:%s" % (ip, port))
self.next_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.next_sock.connect((ip, int(port)))
else:
num_chunks, close = header.split(":")
data = self.pull(self.request, self.CT_BLOCK_SIZE * int(num_chunks))
data = self.client_crypt.decrypt_and_auth(data)
if close == "CLOSE":
router_logger.info("Closing circuit")
self.next_sock.sendall(data)
return False
router_logger.info("Forwarding payload (%dB)" % len(data))
self.next_sock.sendall(data)
return True
def forward_response(self):
if self.exit:
router_logger.info("Getting response from website...")
chunk = 'asdf'
payload = ''
self.next_sock.settimeout(1)
while len(chunk) > 0:
try:
chunk = self.next_sock.recv(1024)
except timeout:
chunk = ''
router_logger.debug("Received chunk from website (%dB)" %
len(chunk))
payload += chunk
self.next_sock.settimeout(None)
payload = self.client_crypt.sign_and_encrypt(payload)
else:
router_logger.info("Getting response from next router...")
header = self.pull(self.next_sock, self.HEADER_SIZE)
num_chunks = self.next_crypt.decrypt_and_auth(header)
payload = self.pull(self.next_sock,
int(num_chunks) * self.CT_BLOCK_SIZE)
payload = self.client_crypt.sign_and_encrypt(payload)
header = self.prev_crypt.sign_and_encrypt(
str(len(payload) / self.CT_BLOCK_SIZE))
router_logger.info("Forwarding payload")
self.request.sendall(header + payload)
def MainConfig(cls):
logger.info("Initializing Xml configuration")
try:
configurationDetails = ET.parse(
'configuration.xml'
) #This file may not exist, introduce fatal error
except Exception as err:
logger.critical("Cannot parse configuration.xml")
ConfigDict = {}
if configurationDetails is not None:
#Checking the log level
logger.info("configuration.xml parsed successfully")
ConfigDict["loggingLevel"] = configurationDetails.find(
'loggingLevel').text
if ConfigDict["loggingLevel"] != "DEBUG":
level = Log.getLogLevel(ConfigDict["loggingLevel"])
Log.loggingLevel = level
logger.setLevel(level)
for handler in logger.handlers:
handler.setLevel(level)
# Check if Email notifications are Enabled
ConfigDict["EmailNotifications"] = configurationDetails.find(
'EmailNotifications').text
ConfigDict["JarvisEmail"] = configurationDetails.find(
'JarvisEmail').text
encPassword = configurationDetails.find('JarvisPasscode').text
ConfigDict["JarvisPasscode"] = encPassword
# Performing the Password decryption only if Email notifications are enabled
if ConfigDict["EmailNotifications"] == 'Enabled':
logger.debug("Performing the Password decryption")
key = Crypt.loadKeyFile()
if key is not "KO":
logger.debug("Password decryption key is found")
c = Crypt()
decPassword = c.decrypt(encPassword.strip(), key)
if decPassword != "":
ConfigDict["JarvisPasscode"] = decPassword
else:
logger.critical("Error decrypting password"
) # Raise Fatal Error here
else:
logger.critical(
"Error fetching key") # Raise Fatal Error here
ConfigDict["PrimaryCustEmail"] = configurationDetails.find(
'PrimaryCustEmail').text
ConfigDict["smtpHost"] = configurationDetails.find('smtpHost').text
ConfigDict["smtpPort"] = configurationDetails.find('smtpPort').text
ConfigDict["IdentifierFile"] = configurationDetails.find(
'IdentifierFile').text
ConfigDict["BackupDirName"] = configurationDetails.find(
'BackupDirName').text
ConfigDict["CheckedPathsFileName"] = configurationDetails.find(
'CheckedPathsFileName').text
ConfigDict["BackupSummaryFileName"] = configurationDetails.find(
'BackupSummaryFileName').text
ConfigDict["NotificationEmailSubject"] = configurationDetails.find(
'NotificationEmailSubject').text
logger.info("Finished reading configuration.xml")
return ConfigDict
