def login(userfield, passfield, controller):
global loginid, loginpass, loginSuccess, counter
counter = 0
loginSuccess = False
# loginid=input("Enter username: "******"Enter password: "******"Error", "Empty fields cannot be accepted!")
else:
apps = list(db.collection(loginid).stream())
if len(apps) != 0:
print(
str(
security.decrypt(apps[0].to_dict()['username'],
loginpass)[2:-1]))
if str(security.decrypt(apps[0].to_dict()['username'],
loginpass))[2:-1] == loginid and str(
security.decrypt(
apps[0].to_dict()['password'],
loginpass))[2:-1] == loginpass:
loginSuccess = True
controller.show_frame("Choice")
messagebox.showinfo("Success", "Login Successful")
else:
messagebox.showinfo("Error", "Invalid Credentials")
else:
messagebox.showinfo("Error", "User Does Not Exist")
def test_encrypt_decrypt():
key = security.hashKey(pow(A, b, p))
encmsg = base64.b64encode(security.encrypt(key, "{key: value}"))
assert security.decrypt(key, encmsg) == "{key: value}"
encmsg = base64.b64encode(security.encrypt(key, ""))
assert security.decrypt(key, encmsg) == ""
def process_data(self, message: str) -> bool:
"""
Processes a DATA message from the client
This message should contain a chunk of the file
:param message: The message to process
:return: Boolean indicating the success of the operation
"""
logger.debug("Process Data: {}".format(message))
if self.state == STATE_OPEN:
self.state = STATE_DATA
# First Packet
elif self.state == STATE_DATA:
data = security.decrypt_message(message, self.sym_key,
self.rsa_private_key)
message = data.get('message', None).replace("'", "\"")
message = json.loads(message)
data = message.get('data', None)
else:
logger.warning("Invalid state. Discarding")
return False
try:
if data is None:
logger.debug("Invalid message. No data found")
return False
iv = base64.b64decode(message['iv'])
bdata = base64.b64decode(message['data'])
#get decryptor to decrypt the encrypted data
iv, key, decryptor = security.decryptor(key=self.shared_key, iv=iv)
bdata = security.decrypt(self.decryptor,
bdata,
hashing=self.cript['digest'])
bdata = security.decrypt(decryptor,
bdata,
hashing=self.cript['digest'])
except:
logger.exception(
"Could not decode base64 content from message.data")
return False
try:
self.file.write(bdata)
self.file.flush()
except:
logger.exception("Could not write to file")
return False
return True
def display(frame, lbx):
global loginid, loginpass, counter, boxCreated
print(loginid)
apps = list(db.collection(loginid).stream())
print(len(apps))
print(boxCreated)
if boxCreated == True:
# lbx.listNodes.delete(0,'end')
lbx.delete(0, END)
lbx.pack_forget()
# lbx = Listbox(frame, width=50, height=15)
if len(apps) != 0:
print(loginid, loginpass)
# if apps[0].to_dict()['username']==loginid and apps[0].to_dict()['password']==loginpass:
for app in apps:
if app.id != '0':
lbx.insert(
counter,
"--------------------------------------------------------------------------------------------------"
)
counter += 1
lbx.insert(counter, "#" + app.id)
counter += 1
lbx.insert(
counter,
" "
)
counter += 1
lbx.insert(
counter, "Username: "******"Password : "******"--------------------------------------------------------------------------------------------------"
)
counter += 1
# print(app.id)
# print("\t", str(security.decrypt(app.to_dict()['username'], loginpass))[2:-1], " ", str(security.decrypt(app.to_dict()['password'], loginpass))[2:-1])
lbx.pack(side=LEFT)
frame.pack(side=LEFT)
boxCreated = True
def change_note(login: str, password: str) -> bool:
os.chdir('..')
list_error = ["\\", "/", ":", "*", "?", "\"", "|", "<", ">"]
flag = True
files = os.listdir(login)
files.remove("maininf.conf")
files.remove("encodeinf.conf")
os.chdir(login)
kappa = []
kappa.append("maininf.conf")
kappa.append("encodeinf.conf")
path = os.getcwd()
with open('encodeinf.conf', 'rb') as encode_file:
encode_key = encode_file.read()
if len(files) == 0:
print("Список заметок пуст")
return False
else:
print("Ваш список заметок")
print(files)
while flag:
try:
nissan = input("Выберите заметку,которую хотите изменить:")
for ch in nissan:
if list_error.count(ch) != 0:
print("Неправильные символы в файле")
if nissan in kappa:
print("Это конфигурационный файл,а не заметка")
if nissan in files:
master_key = security.master_key(password)
encode_key = security.decrypt(encode_key, master_key)
with open(nissan, 'rb') as changing_note:
text = changing_note.read()
text = security.decrypt(text, encode_key)
text_dec = text.decode()
with open(nissan, 'w') as decrypted_note:
decrypted_note.write(text_dec)
os.chmod(path, stat.S_IXOTH)
path_kek = os.path.join(path, nissan)
os.system(path_kek)
with open(nissan, 'r') as crypting_note:
c_text = crypting_note.read()
with open(nissan, 'wb') as bytes_note:
cr_text = security.encrypt(c_text.encode(), encode_key)
bytes_note.write(cr_text)
return True
except FileNotFoundError:
print("Такой заметки нет")
return False
def decrypt():
if request.method == 'POST':
if request.values['send'] == 'DECRYPT':
ciphertext = request.values['CipherText']
pvk = request.values['PrivateKey'].encode()
plain = sec.decrypt(ciphertext, pvk)
return render_template('decrypt.html',
name=request.values['send'],
Contents=plain.decode())
elif request.values['send'] == 'Authenticate':
sender = request.values['sender']
mac = int(request.values['mac'])
with open('member.json', 'r') as file:
users = json.load(file)
pbk = users[sender]["PublicKey"].encode()
number = sec.signature(mac, pbk)
if number == int(users[sender]["MAC"]):
IdentityMsg = "Identity Authentication Success !"
else:
IdentityMsg = "Identity Authentication Failed !"
return render_template('decrypt.html',
name=request.values['send'],
Contents=request.values['CipherText'],
IdentityMsg=IdentityMsg)
return render_template('decrypt.html', name="")
def auth_ldap():
ldap_params = ldapauth.LDAPParameters(
url=request.headers['X-Ldap-URL'],
bind_dn=request.headers['X-Ldap-BindDN'],
bind_passwd=request.headers['X-Ldap-BindPass'],
base_dn=request.headers['X-Ldap-BaseDN'],
search_filter=request.headers['X-Ldap-SearchFilter'],
# disable_referrals=request.headers['X-Ldap-DisableReferrals'],
# starttls=request.headers['X-Ldap-Starttls'],
# realm=request.headers['X-Ldap-Realm']
)
auth_cookie_name = request.headers['X-AuthCookieName']
auth_cookie = request.cookies[auth_cookie_name]
if not auth_cookie:
raise RuntimeError('user not is authenticated')
seal_encrypted_decode_b64 = base64.b64decode(auth_cookie)
seal_decrypted_encode_b64 = security.decrypt(
seal_encrypted_decode_b64.decode('utf-8'))
user, password = security.unseal_auth_b64(seal_decrypted_encode_b64)
auth_handler = ldapauth.LDAPAuthHandler(ldap_params)
auth_handler.check_credentials(user, password)
response = make_response()
response.status_code = 200
return response
def change_key(login: str, master_key: bytes) -> None:
try:
checker1 = db.info(login)
if checker1 is None:
raise Error(
"Error in main.change_key(): A user with this login " +
"is not registered")
except db.db_Error as e:
raise Error(str(e))
info: Tuple[str, bytes, str, bytes, bytes] = checker1
encrypted_data: Dict[str, bytes] = {"ciphertext": info[3], "iv": info[4]}
try:
checker2: bytes = security.decrypt(encrypted_data, master_key)
except security.security_Error as e:
raise Error(str(e))
old_key: object = checker2
key: bytes = security.gen_key()
try:
checker4 = security.encrypt_new(key, master_key)
except security.security_Error as e:
raise Error(str(e))
enc_key: bytes = checker4["ciphertext"]
iv: bytes = checker4["iv"]
try:
checker6 = db.update(login=login, enc_key=enc_key, iv=iv)
except db.db_Error as e:
raise Error(str(e))
print("The key change was successful")
return None
def change_pass(login: str, old_master_key: bytes) -> None:
try:
checker1 = db.info(login)
if checker1 is None:
raise Error(
"Error in main.change_pass(): A user with this login " +
"is not registered")
except db.db_Error as e:
raise Error(str(e))
info: Tuple[str, bytes, str, bytes, bytes] = checker1
password: str = input("Enter your new password: "******"Error in main.change_pass(): Invalid password")
error_list: List[str] = list()
for elem in password:
if elem not in _ALLOWED_CHARACTERS:
error_list.append(elem)
if len(error_list) != 0:
raise Error(
f"Error in main.change_pass(): '{''.join(error_list)}' " +
"is not allowed")
password_bytes: bytes = password.encode(encoding="utf-8")
encrypted_data: Dict[str, bytes] = {"ciphertext": info[3], "iv": info[4]}
try:
checker2: bytes = security.decrypt(encrypted_data, old_master_key)
except security.security_Error as e:
raise Error(str(e))
key: bytes = checker2
try:
checker3 = security.gen_master_key(password_bytes)
except security.security_Error as e:
raise Error(str(e))
master_key_new: bytes = checker3
try:
checker4 = security.encrypt(key, master_key_new, info[4])
except security.security_Error as e:
raise Error(str(e))
enc_key = checker4["ciphertext"]
try:
checker5 = security.hash(password_bytes)
except security.security_Error as e:
raise Error(str(e))
password_bytes_hash: bytes = checker5
try:
checker6 = db.update(
login=login, hash=password_bytes_hash, enc_key=enc_key)
except db.db_Error as e:
raise Error(str(e))
print("Password change was successful")
return None
def readDatabase(self, filepath):
print "Reading database..."
passwd = raw_input("Enter master password : "******"Read {} entries.".format(len(self.entries))
return True
def read_note(login: str, password: str) -> bool:
os.chdir('..')
list_error = ["\\", "/", ":", "*", "?", "\"", "|", "<", ">"]
flag = True
files = os.listdir(login)
files.remove("maininf.conf")
files.remove("encodeinf.conf")
os.chdir(login)
kappa = []
kappa.append("maininf.conf")
kappa.append("encodeinf.conf")
if len(files) == 0:
print("Список заметок пуст")
return False
print("Ваш список заметок")
print(files)
while flag:
try:
command = input("Выберите заметку которую хотите прочитать:")
for ch in command:
if list_error.count(ch) != 0:
print("Неправильные символы в файле")
if command in kappa:
print("Это конфигурационный файл,а не заметка")
if command in files:
with open('encodeinf.conf', 'rb') as encode_file:
encode_key = encode_file.read()
master_key = security.master_key(password)
with open(command, 'rb') as changing_note:
encode_key = security.decrypt(encode_key, master_key)
text = changing_note.read()
text = security.decrypt(text, encode_key)
text_d = text.decode()
print(text_d)
return True
except FileNotFoundError:
print("Такой заметки нет")
return False
def process_challenge(self, message) -> bool:
"""
Returns true if the attemp sent by the
client corresponds to the solution expected
"""
nonce = message['nonce']
solution = message['solution'].encode('iso-8859-1')
solution = security.decrypt(self.private_key, solution)[0]
if security.verifyPasswordChallenge(self.password, self.challenge,
nonce, solution) != True:
return False
message = {'type': 'OK'}
self._send(message)
return True
def _decrypt_text(login: str, master_key: bytes, ct: bytes) -> str:
if not isinstance(login, str) or not isinstance(master_key, bytes) \
or not isinstance(ct, bytes):
raise notes_Error("Error in notes._decrypt_text(): Invalid input type")
try:
checker1: Union[Tuple[str, bytes, str, bytes, bytes],
None] = db.info(login)
if checker1 is None:
raise notes_Error(f"Error in notes._encrypt_text(): \
User with login {login} not found")
except db.db_Error as e:
raise notes_Error(str(e))
info: Tuple[str, bytes, str, bytes, bytes] = checker1
encrypted_data: Dict[str, bytes] = {"ciphertext": info[3], "iv": info[4]}
try:
checker2 = security.decrypt(encrypted_data, master_key)
except security.security_Error as e:
raise notes_Error(str(e))
key: bytes = checker2
encrypted_text = {"ciphertext": ct, "iv": info[4]}
try:
checker3 = security.decrypt(encrypted_text, key)
except security.security_Error as e:
raise notes_Error(str(e))
text: bytes = checker3
result = text.decode(encoding="utf-8")
if not isinstance(result, str):
raise notes_Error(
"Error in notes._decrypt_text(): Invalid output type")
return result
def process_otp_authentication(self, message) -> bool:
"""
Returns true if the attemp sent by the
client corresponds to the solution expected
"""
solution = message['solution'].encode('iso-8859-1')
solution = security.decrypt(self.private_key, solution)[0]
if solution == security.otp(index=self.index,
root=self.raiz,
password=self.password) != True:
return False
message = {'type': 'OK'}
#generate new random index for next authentication
self.index = random.randint(3, 9)
self._send(message)
return True
def test_encrypted_flow():
user = '******'
passwd = 'neto'
seal_source = security.seal_auth_b64(user, passwd)
seal_encrypted = security.encrypt(seal_source)
seal_encrypted_encode_b64 = base64.b64encode(seal_encrypted.encode())
seal_encrypted_decode_b64 = base64.b64decode(seal_encrypted_encode_b64)
seal_decrypted = security.decrypt(seal_encrypted_decode_b64)
user_post_processed, passwd_post_processed = security.unseal_auth_b64(
seal_decrypted)
assert user == user_post_processed
assert passwd == passwd_post_processed
def _login(cur, user, pword):
cur.execute("""
SELECT password FROM users WHERE username=%s
""", (user, ))
try:
p = cur.fetchone()[0]
except:
return None, "user"
if decrypt(p) == pword:
token = session_token()
cur.execute(
"""
UPDATE users SET token=%s WHERE username=%s
""", (token, user))
return token, ""
else:
return None, "password"
def receive_message(client_socket, ack=1):
message_header = client_socket.recv(HEADER_LENGTH)
# print('header - ', message_header)
if not len(message_header):
# client closed the connection
return False
message_length = int(message_header.decode('utf-8').strip())
d1 = client_socket.recv(message_length)
try:
d2 = decrypt(d1)
msg = message_format(message_header, d2)
if ack:
# send an acknowlegement
# print('send ack')
sendACK(client_socket)
return msg
# return {"header": message_header, "data": d2}
except ValueError as e:
print('Unauthorized user tried to access')
return False
def process_client_asym_key_authentication(self, message) -> bool:
"""
Client receives an auth request
Using its private asym key decrypts the nonce
Generates the hash with decrypted nonce and compares with digest sent
"""
client_digest = message['digest'].encode('iso-8859-1')
enc_nonce = message['nonce'].encode('iso-8859-1')
nonce = security.decrypt(self.rsa_private_key, enc_nonce)[0]
digest = security.hash(nonce)
if client_digest != digest:
return False
self.send_assymetric_key_authentication()
return True
def create_note(login: str, password: str) -> bool:
os.chdir('..')
files = os.listdir(login)
os.chdir(login)
for i in range(3):
try:
try:
name, check = pathcheck('txt')
if check is False:
return False
if ' ' in name:
i += 1
elif len(name) < 1:
i += 1
elif len(name) > 100:
i += 1
if name in files:
i += 1
else:
with open('encodeinf.conf', 'rb') as encode_file:
encode_key = encode_file.read()
master_key = security.master_key(password)
encode_key = security.decrypt(encode_key, master_key)
karapa = ''
space = karapa.encode(encoding='utf-8')
space = security.encrypt(space, encode_key)
new_zap = open(name, 'wb')
new_zap.write(space)
new_zap.close()
return True
if i == 3:
return False
except FileExistsError:
print("Такая заметка уже существует")
except BaseException:
print("Проблемы с заметкой")
return False
def change_password() -> bool:
os.chdir('TheFourth')
files = os.listdir('notes')
for j in range(3):
try:
change_login = input("Введите логин аккаунта который изменяете:")
if change_login in files:
break
else:
j += 1
if j == 3:
os.chdir('..')
return False
except FileNotFoundError:
print("Не найдено такого аккаунта")
os.chdir('notes')
os.chdir(change_login)
with open("maininf.conf", 'r', encoding='utf-8') as change_file:
method = change_file.readline().rstrip().split(' ')
for i in range(3):
try:
change_pass = input("Введите пароль для данного аккаунта:")
if security.check_password(method[1], change_pass) is True:
check = True
break
else:
i += 1
if i == 3:
os.chdir('..')
os.chdir('..')
os.chdir('..')
return False
except BaseException:
print("Проблемы с паролем")
if check is True:
for i in range(3):
try:
new_pass = input("Введите ваш новый пароль(без пробелов):")
if ' ' in new_pass:
i += 1
elif len(new_pass) < 1:
i += 1
elif len(new_pass) > 30:
i += 1
else:
choise = True
break
if i == 3:
os.chdir('..')
os.chdir('..')
os.chdir('..')
return False
except BaseException:
print("Проблемы с паролем")
if choise is True:
with open('encodeinf.conf', 'rb') as encode_file:
encode_key = encode_file.read()
master_key = security.master_key(change_pass)
new_master_key = security.master_key(new_pass)
new_encode_key = security.decrypt(encode_key, master_key)
new_encode_key = security.encrypt(new_encode_key, new_master_key)
mainf = open("maininf.conf", 'w')
mainf.write(change_login + ' ' + security.hash_password(new_pass))
mainf.close()
encodefile = open("encodeinf.conf", 'wb')
encodefile.write(new_encode_key)
encodefile.close()
os.chdir('..')
os.chdir('..')
os.chdir('..')
return True
return False
first_match = service_matches[0]
port = first_match["port"]
name = first_match["name"]
host = first_match["host"]
print "找到蓝牙服务", first_match
# 创建客户端 Socket
socket = BluetoothSocket(RFCOMM)
socket.connect((host, port))
my_public_key = security.get_public_key()
socket.send(my_public_key)
server_public_key = socket.recv(1024)
# 收发数据
while True:
q = raw_input("我：")
if q == "exit":
break
elif q:
# 向客户端发送内容
socket.send(security.encrypt(q, server_public_key))
# 获取客户发送的内容
print "对方：", security.decrypt(socket.recv(1024))
# 关闭连接
socket.close()
import os
import socket
import security as sec
port = 8888
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
def cls():
os.system('cls' if os.name == 'nt' else 'clear')
print("===== Socket Chat Client by kde713 =====")
s.connect((input("Input Host Address: "), port))
key = input("Type Security-Key (Server Set): ")
cls()
print("===== Socket Chat Client by kde713 =====")
print()
while 1:
msg = input(">> ")
s.send(sec.encrypt(key, msg).encode('utf-8'))
reply = s.recv(1024)
if not reply:
break
print("Server says '", sec.decrypt(key, reply.decode('utf-8')), "'")
print("(!) Connection Lost")
s.close()
def main():
global tcp_s
server_addr = ("xcoa.av.it.pt", 8080)
tcp_s = net.tcpConnect(server_addr)
values = security.DHInitialValues()
initial_value = str(values).strip('()').replace(
" ", "") # transformar (A, p, g) para string válida "A,p,g"
# Tentar efetuar a troca de parametros inicial
# Se a resposta do servidor estiver corrompida durante esta fase inicial então não será possivel continuar a comunicação,
# Visto que o servidor estará à espera da mensagem READ encriptada mas o cliente não saberá calcular a chave do AES devido a ter recebido o parametro B de forma corrompida
try:
token, B = initialExchange(initial_value)
secret = security.DHGetSecret(values[1], B)
# Enviar "READ <token>" ao server
net.tcpSend(security.encrypt(secret, "READ " + str(token)), True)
except KeyboardInterrupt:
tcp_s.close()
sys.exit(0)
except:
handleFatalError()
wrote_header = False
started_receiving = False
# Receber e tratar das respostas do server indefinitivamente
while 1:
data = net.tcpRead()
if isValidJSON(data):
# Se for JSON válido então os dados enviados não foram encriptados. Logo, deve ser uma mensagem de erro
data = readJSON(data)
else:
# Se não for JSON válido então os dados devem estar encriptados, como se estava à espera
try:
data = readJSON(security.decrypt(secret, data))
except KeyboardInterrupt:
tcp_s.close()
sys.exit(0)
except:
print(
colors.warning(
"DECODE ERROR : A última mensagem do servidor estava corrompida."
))
# Se ainda não tinha sido recebida a mensagem {type : 'OK'}, executar a lógica de erro fatal
if not started_receiving:
handleFatalError()
else:
continue
if ("type" in data.keys()) and (data['type'] == "OK"):
# Foi recebida mensagem "{type : 'OK'}"
started_receiving = True
print(
colors.okgreen("Conexão ao servidor bem sucedida!\n") +
"Serão recolhidos novos valores a cada " +
colors.bold("10 segundos") + ".\nEstes serão registados em " +
colors.bold("data.csv"))
file = open("data.csv", "w+")
print("\n" + colors.bold(" Temperatura") + " | " +
colors.bold("Humidade") + " | " + colors.bold("Vento"))
print("-------------|------------|-----------")
elif hasError(data):
# Fazer print à mensagem de erro vinda do servidor
try:
print(colors.fail(data['type'] + ": " + data['content']))
except KeyboardInterrupt:
tcp_s.close()
sys.exit(0)
except ValueError:
print(
colors.warning(
"ERROR: A última mensagem do servidor era um erro mas pelo menos uma key estava corrompida."
))
else:
try:
temp = data['TEMPERATURE']
hum = data['HUMIDITY']
wind = data['WIND']
except KeyboardInterrupt:
tcp_s.close()
sys.exit(0)
except ValueError:
print(
colors.warning(
"ERROR: A última mensagem do servidor não continha os valores esperados."
))
continue
print(
(colors.okblue(" %8.5f ") + "|" +
colors.okblue(" %8.5f ") + "|" + colors.okblue(" %8.5f")) %
(temp, hum, wind))
getInfo(temp, hum, wind)
if not wrote_header:
fields = [key for key in data.keys()]
fields.insert(0, 'TIME')
fw = csv.DictWriter(file, fieldnames=fields)
fw.writeheader()
wrote_header = True
data.update({'TIME': datetime.now()})
fw.writerow(data)
file.flush() # escreve as alterações feitas no buffer
tcp_s.close()
service_id=uuid,
service_classes=[uuid, SERIAL_PORT_CLASS],
profiles=[SERIAL_PORT_PROFILE],
)
# 获取客户端连接
client, client_info = bluetooth_socket.accept()
print "客户连接：", client_info
my_public_key = security.get_public_key()
client.send(my_public_key)
client_public_key = client.recv(1024)
while True:
# 获取客户发送的内容
print "对方：", security.decrypt(client.recv(1024))
q = raw_input("我：")
if q == "exit":
break
elif q:
# 向客户端发送内容
client.send(security.encrypt(q, client_public_key))
# 关闭客户端连接
client.close()
# 关闭服务器连接。
bluetooth_socket.close()
#!/usr/bin/python
# -*- coding: utf-8 -*-
import socket
import security as sec
import makereply as mr
port = 8888
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('', port))
s.listen(1)
print("## Host:", socket.gethostbyname(socket.getfqdn()))
key = input("Enter Security-Key: ")
print("Log) Socket Listen Started.")
connector, addr = s.accept()
while 1:
msg = connector.recv(1024)
if not msg:
break
print("Log) Message Received: ", msg.decode('utf-8'))
print("Log) Decrypted: ", sec.decrypt(key, msg.decode('utf-8')))
reply = mr.echo(sec.decrypt(key, msg.decode('utf-8')))
connector.send(sec.encrypt(key, reply).encode('utf-8'))
s.close()
