desencriptar.py

import os
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.backends import default_backend
import sys
from tkinter import messagebox

"""---------------------------- METODOS -----------------------------------"""

def borrar_directorio(file_path):
    archivoTxt = "./archivo.txt"
    # Abre el archivo en modo lectura
    with open(archivoTxt, "r") as archivo:
        lineas = archivo.readlines()

    # Sobreescribimos el archivo sin el 'file_path'
    with open(archivoTxt, "w") as archivo:
        for linea in lineas:
            if linea.strip() != file_path:
                archivo.write(linea + "\n")


# Metodo para encriptar
def decrypt_file(file_path, key, iv):
    with open(file_path, "rb") as encrypted_file:
        ciphertext = encrypted_file.read()

    # Elige el mismo modo que se utilizó para encriptar (en este caso, CFB)
    cipher = Cipher(algorithms.AES(key), modes.CFB(iv))
    decryptor = cipher.decryptor()
    plaintext = decryptor.update(ciphertext) + decryptor.finalize()

    # Quitamos .enc
    nombre_archivo, extension = os.path.splitext(file_path)

    # Sobrescribe el archivo encriptado con el contenido desencriptado
    with open(nombre_archivo, "wb") as file:
        file.write(plaintext)

    os.remove(file_path)


# Metodo para listar una ruta
def listar_archivos_con_ruta_completa(directorio):
    if os.path.exists(directorio) and os.path.isdir(directorio):
        archivos = []
        for raiz, directorios, archivos_en_raiz in os.walk(directorio):
            for archivo in archivos_en_raiz:
                ruta_completa = os.path.join(raiz, archivo)
                # Agregar a la lista solo si el archivo termina en ".enc"
                if archivo.endswith(".enc") and os.path.isfile(ruta_completa):
                    archivos.append(ruta_completa)
        return archivos
    else:
        return []


def verificar_firma(archivo_path, firma_path, public_key_hex):
    # Convertir la clave pública de hexadecimal a bytes
    public_key_bytes = bytes.fromhex(public_key_hex)

    # Cargar la clave pública desde los bytes
    public_key = serialization.load_pem_public_key(
        public_key_bytes, backend=default_backend()
    )

    # Leer el contenido del archivo
    with open(archivo_path, "rb") as archivo:
        contenido = archivo.read()

    # Leer la firma desde el archivo
    with open(firma_path, "rb") as firma_archivo:
        firma = firma_archivo.read()

    # Verificar la firma
    try:
        public_key.verify(
            firma,
            contenido,
            padding.PSS(
                mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH
            ),
            hashes.SHA256(),
        )
        print("La firma es válida. El archivo no ha sido modificado.")
    except Exception as e:
        print("Error al verificar la firma")
        sys.exit()


"""------------------------------------------ MAIN -----------------------------------"""
claves = os.path.join(os.path.expanduser("~"), "Desktop/claves.txt")
file_clavePublica = os.path.join(os.path.expanduser("~"), "Desktop/clavePublica.txt")

# Verificar la clave pública
with open(file_clavePublica, 'r') as archivo:
    next(archivo)
    public_key = archivo.read().strip()
verificar_firma(claves, claves + ".sig", public_key)

# Solicita la contraseña para desencriptar la clave privada RSA
password = sys.argv[1].encode("utf-8")
print(password)

# Extraemos las claves encriptadas de cada línea
with open(claves, "r") as file:
    lines = file.readlines()

encrypted_key = lines[0].split(": ")[1].strip()
encrypted_iv = lines[1].split(": ")[1].strip()
encrypted_private_key = lines[2].split(": ")[1].strip()


# Desencripta la clave privada RSA
try:
    private_key = serialization.load_pem_private_key(
        bytes.fromhex(encrypted_private_key), password=password
    )
except:
    raise Exception("Contraseña incorrecta")

# Desencripta la clave AES y el IV usando la clave privada RSA
key = private_key.decrypt(
    bytes.fromhex(encrypted_key),
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None,
    ),
)
iv = private_key.decrypt(
    bytes.fromhex(encrypted_iv),
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None,
    ),
)

# Obtiene la ruta al directorio de prueba
directorio = "prueba"
archivos_en_directorio = listar_archivos_con_ruta_completa(directorio)

if archivos_en_directorio:
    print(f"Archivos en el directorio '{directorio}': ")
    for archivo in archivos_en_directorio:
        decrypt_file(archivo, key, iv)
        print("Desencriptando un archivo")
        print(archivo)
else:
    print(
        f"No se encontraron archivos en el directorio '{directorio}' o el directorio no existe."
    )

messagebox.showinfo("Contraseña correcta!!", "Archivos desencriptados")