def receive_file(self, file_info):
"""
receive file from server
"""
port, sock = misc.port_using(4001)
#make list of server ip (without uid) be a circular list
server_cycle = cycle([item[1] for item in self.primary_server])
#Use variable primary_server -> [ [uid,ip], [uid,ip] ... ]
server_conn = self.rpc.set_server(next(server_cycle))
salt = server_conn.get_salt(file_info.relative_filepath, self.user_id)
if (salt == 0):
print("This file can't be found")
return
file_obj = file.File()
read_key = file_obj.set_keys(self.configs.loaded_config.get("User", "private key"), salt)
total_parts_file = 3 # FIXME: colocar para descobrir automaticamante numero de partes
name_parts_file = []
for num_part in range(total_parts_file):
name_file = file_info.absolute_enc_filepath + '.' + str(num_part)
name_parts_file.append(name_file)
# make a thread that will receive file in socket
thr = Thread(target=misc.receive_file, args=(sock, name_file))
thr.start()
# ask to server a file with name (keys[0] = hash)
# client ip and your port to receive file
if ( server_conn.give_file( misc.my_ip(),port, file_obj.verify_key, num_part) ):
# exit with error and kill thread thr
sys.exit("An error occured. Try again later.")
thr.join()
server_conn = self.rpc.set_server(next(server_cycle))
misc.join_file(name_parts_file, file_info.enc_filename)
crypto.decrypt_file(read_key, file_info.enc_filename, file_info.absolute_filepath, 16)
#remove temp files from workstation -> parts
for file_to_rm in name_parts_file:
os.remove(file_to_rm)
#remove temp files from workstation -> complete
os.remove(file_info.absolute_enc_filepath)
def on_dec_click(self):
try:
output = decrypt_file(self.textbox.text(), self.label.text())
QMessageBox.information(self, "解密完毕", "解密完毕! 解密文件路径: " + output,
QMessageBox.Close)
except ValueError:
QMessageBox.warning(self, "解密失败", "解密失败! 待解密文件解析出错",
QMessageBox.Close)
def main(options):
for attempt in (1,2,3):
try:
passphrase = getpass.getpass('Enter the passphrase to decrypt %s: ' % (options.filename,))
cleartext = decrypt_file(passphrase, filename=options.filename)
break
except GPGOperationFailed, error:
if 'DECRYPTION_FAILED' in error.status:
print("Wrong password; try again.")
else:
print("Unknown error; %s" % (error,))
def open_password_file(password_file: str = None,
key_path: str = None) -> None:
"""Open a Password File if the right key file is given.
Args:
password_file (str): Path to Password File
key_path (str): Path to Key file
"""
if password_file is None:
password_file = input("Path to password file: ")
if key_path is None:
key_path = input("Path to key file: ")
decrypt_file(password_file, load_key(key_path))
with open(password_file, "rb") as file:
password_object = pickle.load(file)
password_object.master_key = key_path
password_object.menu()
def sql_show(con, fileName):
"""
Functie ce afiseaza decriptat file-ul: fileName, prin decriptarea fisierului cripptat asociat in folderul encrypted, folosind private key-ul sau stocat in metadate on baza de date.
:param con: conexiunea la baza de data curenta
:param fileName: numele fisierului ce dorim sa il vizualizam
:return: None- ia key-ul de decriptare din baza de date si file-ul criptat din folderul de criptate, si in final il decripteaza prin metoda RSA cu key-ul aferent.
Mesajul decriptat va fi deschis intr-o fereastra.
"""
cursorObj = con.cursor()
try:
rez = \
cursorObj.execute("SELECT COUNT(*) from encryptedDatabase WHERE fileName = ?", (str(fileName),)).fetchone()[
0]
if rez == 0:
print("Nu exista acest fisier! Incercati altul!")
return
try:
decryption_key = []
fileToView = \
cursorObj.execute("SELECT encryptedPath from encryptedDatabase WHERE fileName = ?",
(fileName,)).fetchone()[
0]
private_key = \
cursorObj.execute("SELECT fileKey FROM encryptedDatabase WHERE fileName = ?", (fileName,)).fetchone()[0]
private_key = private_key.strip("()").split(",")
decryption_key.append(int(private_key[0]))
decryption_key.append(int(private_key[1]))
print(f"Continutul fisierului {fileName} va fi afisat.\n\n")
crypto.decrypt_file(fileToView, decryption_key)
except Error:
print(Error)
except Error:
print(Error)
def decrypt(self, file):
print('\nEl usuario actual es ' + self.user.user_short())
# Leer fichero
enc = open(file, 'rb').read()
# Obtener clave privada del destinatario (en el propio ordenador)
self.user.private_key = RSA.import_key(
open('Users/' + self.user.id + '/' + self.user.id + '.bin',
'r').read())
# Desciframos el mensaje
mes = crypto.decrypt_file(enc, self.user.private_key)
# Lo guardamos con su nombre original
file = file.split('/')[-1]
name = 'Archivos/' + file[:-4]
r = open(name, 'wb')
r.write(mes)
r.close()
print('\nFichero descifrado guardado en ' + name)
parser.add_argument('-d', '--decrypt', dest='decrypt', help='Decrypt mode', default=False, action='store_true')
parser.add_argument('-i', '--input', dest='input', type=str, help='The input file (or folder)', default='')
parser.add_argument('-o', '--output', dest='output', type=str, help='The output file (or folder, optional)',
default='')
parser.add_argument('-p', '--password', dest='password', type=str, help='The password of the file',
default='')
args = parser.parse_args()
if not args.input or (not args.decrypt and not args.encrypt):
print("Invalid arguments.")
exit(0)
if args.password:
password = args.password
else:
password = getpass()
if args.encrypt:
if args.output:
print(crypto.encrypt_file(args.input, args.output, password))
else:
print(crypto.encrypt(args.input, password))
elif args.decrypt:
if args.output:
print(crypto.decrypt_file(args.input, args.output, password))
else:
print(crypto.decrypt(args.input, password))
else:
print("Invalid arguments.")
import os
import sys
import crypto
def fail_exit():
print('Usage: python edcrypt.py -e(encrypt)/-d(decrypt) filename password')
raise SystemExit(1)
# check command line args are valid
if len(sys.argv) != 4:
fail_exit()
if not os.path.isfile(sys.argv[2]):
print('File ' + sys.argv[2] + ' does not exist.')
raise SystemExit(1)
# parse command line args
if sys.argv[1] == '-e':
crypto.encrypt_file(sys.argv[3].encode(), sys.argv[2])
elif sys.argv[1] == '-d':
crypto.decrypt_file(sys.argv[3].encode(), sys.argv[2])
else:
fail_exit()
decrypted = crypto.decrypt_RSA(encrypted, private_key)
if text == decrypted:
print("Cifrado RSA exitoso\n")
else:
print("Cifrado RSA fallido\n")
# Test de cifrado de fichero
f = 'ideas'
file = open(f, 'r')
content = file.read()
file.close()
encrypted = crypto.encrypt_file(f, public_key)
decrypted = crypto.decrypt_file(encrypted, private_key)
if content == decrypted:
print("Cifrado fichero exitoso\n")
else:
print("Cifrado fichero fallido\n")
# Test de firma digital
signature = crypto.digital_signature(text, private_key)
if crypto.verify_signature(text, public_key, signature):
print("Firma digital verificada\n")
else:
print("Firma digital rechazada\n")
with open(ensemble_file) as f:
ensemble = yaml.load(f, Loader=yaml.SafeLoader)
all_models = set()
for predicts in ensemble:
for pred in predicts['predicts']:
filename = pred.replace('_train_', '_test_')
m = re.match(r'level1_test_(.*).npy', os.path.basename(filename))
assert m
all_models.add(m.group(1) + '.pth')
for path in glob(MODEL_PATH + '**/*.enc'):
if os.path.basename(path)[:-4] in all_models:
os.makedirs(UNPACK_PATH, exist_ok=True)
out_path = os.path.join(UNPACK_PATH, os.path.basename(path)[:-4])
decrypt_file(path, out_path)
model2path = {os.path.basename(path): path for path in glob(MODEL_PATH + '**/*.pth')}
model2path.update({os.path.basename(path): path for path in glob(UNPACK_PATH + '**/*.pth')})
print('models found', model2path.keys())
for predicts in ensemble:
for pred in predicts['predicts']:
predict_filename = pred.replace('_train_', '_test_')
if not os.path.exists(predict_filename):
generate_predict(predict_filename)
run(['python3.6', 'ensemble_blend.py', 'submission.npy', ensemble_file])
run(['python3.6', 'gen_submission.py', 'submission.npy'])