secure-credentials-roan 0.1.0__tar.gz

secure_credentials_roan-0.1.0/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: secure-credentials-roan
+Version: 0.1.0
+Summary: Paquete sencillo para cifrar y descifrar archivos de credenciales
+Author: Angel Rogelio Argonza Roblero
+License: MIT
+Project-URL: Homepage, https://github.com/TU_USUARIO/secure_credentials_roan
+Project-URL: Repository, https://github.com/TU_USUARIO/secure_credentials_roan
+Project-URL: Issues, https://github.com/TU_USUARIO/secure_credentials_roan/issues
+Keywords: python,credentials,encryption,security,fernet
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=42.0.0
+
+# Secure Credentials Roan
+
+Paquete de Python para cifrar y descifrar archivos de credenciales con formato clave=valor.
+
+## Instalación
+
+```bash
+pip install secure-credentials-roan
+
+## Uso básico
+from secure_credentials import create_key_file, encrypt_file, load_credentials
+
+create_key_file("secret.key")
+
+encrypt_file(
+    input_path="credentials.txt",
+    output_path="credentials.enc",
+    key_path="secret.key",
+)
+
+credentials = load_credentials(
+    encrypted_path="credentials.enc",
+    key_path="secret.key",
+)
+
+print(credentials)
+
+## Formato del archivo de credenciales
+user=root
+password=mysql_5
+database=automcae
+host=localhost
+port=3306

secure_credentials_roan-0.1.0/README.md

@@ -0,0 +1,33 @@
+# Secure Credentials Roan
+
+Paquete de Python para cifrar y descifrar archivos de credenciales con formato clave=valor.
+
+## Instalación
+
+```bash
+pip install secure-credentials-roan
+
+## Uso básico
+from secure_credentials import create_key_file, encrypt_file, load_credentials
+
+create_key_file("secret.key")
+
+encrypt_file(
+    input_path="credentials.txt",
+    output_path="credentials.enc",
+    key_path="secret.key",
+)
+
+credentials = load_credentials(
+    encrypted_path="credentials.enc",
+    key_path="secret.key",
+)
+
+print(credentials)
+
+## Formato del archivo de credenciales
+user=root
+password=mysql_5
+database=automcae
+host=localhost
+port=3306

secure_credentials_roan-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "secure-credentials-roan"
+version = "0.1.0"
+description = "Paquete sencillo para cifrar y descifrar archivos de credenciales"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [
+    { name = "Angel Rogelio Argonza Roblero" }
+]
+license = { text = "MIT" }
+keywords = ["python", "credentials", "encryption", "security", "fernet"]
+
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Security",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+dependencies = [
+    "cryptography>=42.0.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/TU_USUARIO/secure_credentials_roan"
+Repository = "https://github.com/TU_USUARIO/secure_credentials_roan"
+Issues = "https://github.com/TU_USUARIO/secure_credentials_roan/issues"
+
+[build-system]
+requires = ["setuptools>=68.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["secure_credentials*"]
+exclude = ["securevenv*", "venv*", ".venv*", "env*", "tests*", "examples*"]

secure_credentials_roan-0.1.0/secure_credentials/__init__.py

@@ -0,0 +1,33 @@
+##########################
+# author: roan           #
+# date: 2026/06/25       #
+##########################
+# Propose: Exponer funciones principales del paquete
+
+from secure_credentials.crypto import(
+    generate_key,
+    save_key,
+    load_key,
+    create_key_file,
+    encrypt_text,
+    decrypt_text,
+    encrypt_file,
+    decrypt_file,
+    load_credentials
+)
+
+from secure_credentials.parser import get_dict
+
+__all__ = [
+    "generate_key",
+    "save_key",
+    "load_key",
+    "create_key_file",
+    "encrypt_text",
+    "decrypt_text",
+    "encrypt_file",
+    "decrypt_file",
+    "load_credentials",
+    "get_dict",
+
+]

secure_credentials_roan-0.1.0/secure_credentials/crypto.py

@@ -0,0 +1,150 @@
+##########################
+# author: roan           #
+# date: 2026/06/24       #
+##########################
+# Propose: Realizar cifrado y descifrado de archivos, generar una llave, guardarla y cargarla
+#          Retornar valores cifrados para ser usados
+
+import os
+from cryptography.fernet import Fernet, InvalidToken
+from secure_credentials.parser import get_dict
+from pathlib import Path
+
+
+#Generar llave
+def generate_key() -> bytes:
+    #Genera una llave y la regresa para ser guardada
+    return Fernet.generate_key()
+
+#Guardar llave secreta en un archivo
+def save_key(key: bytes, key_path: str | Path) -> None:
+    
+    #Verificamos si existe la ruta si no se crea
+    key_path = Path(key_path)
+    key_path.parent.mkdir(parents=True, exist_ok=True)
+
+    #Guardar la llave en modo binario
+    with open(key_path, "wb") as file:
+        file.write(key)
+
+#Lee la llave secreta desde un archivo
+def load_key(key_path: str | Path) -> bytes:
+
+    key_path = Path(key_path)
+
+    #Verificar que existe el path
+    if not key_path.exists():
+        raise FileNotFoundError (f"No se encontró la llave en la ruta: {key_path}")
+
+    #Cargar/retornar llave que se leyo del archivo
+    with open(key_path, "rb") as f:
+        return f.read()
+
+#Genera una llave secreta y la guarda en un archivo
+def create_key_file(key_path: str | Path, overwrite: bool = False) -> bytes:
+
+    key_path = Path(key_path)
+
+    #Verificar si existe la llave
+    if key_path.exists() and not overwrite:
+        raise FileExistsError(f"La llave {key_path} ya existe en el sistema, utiliza overrite = True si deseas reemplazarla")
+
+    #Crear la llave
+    key = generate_key()
+
+    #Guardar la llave
+    save_key(key, key_path)
+
+    return key
+
+    
+#Cifrar texto usando la llave Fernet
+def encrypt_text(text: str, key: bytes) -> bytes:
+    #Se inicia la instancia de fernet con la llave
+    fernet = Fernet(key)
+
+    #Convertir el texto en bytes
+    text_bytes = text.encode("utf-8")
+
+    #cifrar el contenido
+    encrypted_data = fernet.encrypt(text_bytes)
+
+    return encrypted_data
+
+
+#descifrar datos usando la llave fernet
+def decrypt_text(encrypted_data: bytes, key: bytes) -> str:
+    
+    #Iniciar instancia con la llave
+    fernet = Fernet(key)
+
+    #Se realiza el descifrado
+    try:
+        #Descifrando datos
+        decrypted_data = fernet.decrypt(encrypted_data)
+    
+    #Mensaje de error en caso de que no se pueda descifrar
+    except InvalidToken as it:
+        raise ValueError(f"No se pudo descifrar el contenido, Verifica que la llave sea la correcta") from it
+    
+    #Devuelve los valores en formato str
+    return decrypted_data.decode("utf-8")
+
+
+#Lee un archivo de texto, cifra su contenido y guarda el archivo cifrado.
+def encrypt_file(original_file: str | Path, output_file: str | Path, key_path: str | Path) -> None:
+
+    original_file = Path(original_file)
+    #Verificar que existe el archivo que vamos a cifrar
+    if not original_file.exists():
+        raise FileNotFoundError(f"No se encontró un archivo para cidfrar en {original_file}")
+    
+    #Cargar la llave
+    key = load_key(key_path)
+
+    #Se lee el archivo original como texto
+    with open(original_file, "r", encoding="utf-8") as file:
+        original_text = file.read()
+
+    #Cifrar el texto
+    encrypted_data = encrypt_text(original_text, key)
+
+    #Crear la carpeta destino si no existe
+    output_file = Path(output_file)
+    output_file.parent.mkdir(parents= True, exist_ok=True)
+
+    #Guardar contenido cifrado en modo binario
+    with open(output_file, "wb") as file:
+        file.write(encrypted_data)
+
+
+#Lee un archivo cifrado y devuelve su contenido descifrado como texto.
+def decrypt_file(encrypted_file: str | Path, key_path: str):
+
+    #Verificar que el path a descifrar existe
+    encrypted_path = Path(encrypted_file)
+
+    if not encrypted_path.exists():
+        raise FileNotFoundError(f"El archivo a decifrar no existe en la ruta {encrypted_path}")
+    
+    #cargar la llave
+    key = load_key(key_path)
+
+    with open(encrypted_path, "rb") as file:
+
+        data_decrypt = file.read()
+
+    text = decrypt_text(data_decrypt, key)
+
+    return text
+
+#Descifra un archivo de credenciales y retorna sus valores como diccionario.
+def load_credentials(encrypted_path: str | Path, key_path: str | Path) -> dict [str:str]:
+
+    #Descifrar el archivo
+    decrypted_text = decrypt_file(encrypted_path, key_path)
+
+    #Formatear credenciales en formato
+    credentials = get_dict(decrypted_text)
+
+    return credentials

secure_credentials_roan-0.1.0/secure_credentials/parser.py

@@ -0,0 +1,44 @@
+##########################
+# author: roan           #
+# date: 22/06/2026       #
+##########################
+# Propose: Obtener un diccionario de datos para cifrar
+
+def get_dict(data_text: str) -> dict [str:str]:
+    #Diccionario para organizar los datos clave=valor
+    dict_data = {}
+
+    #Comienza recorriendo linea por linea
+    for line_number, linea in enumerate(data_text.splitlines(), start=1):
+        #Qutar espacios al inicio y al final
+        cleanline = linea.strip()
+
+        #Ignorar las lineas vacias
+        if not cleanline:
+            continue
+
+        #Ignoramos lineas con comentarios
+        if cleanline.startswith("#"):
+            continue
+        
+        #Validar el formato de linea
+        if "=" not in cleanline:
+            raise ValueError(f"La línea {line_number} no contiene el formato clave=valor: {cleanline}")
+
+        #Obtener clave valor de la cadena
+        key, value = cleanline.split("=")
+
+        #Limpiar espacios
+        keyClean = key.strip()
+        valueClean = value.strip()
+
+        #Validar que la clave no este vacia
+        if not keyClean:
+            raise ValueError(f"La linea {linea} tiene una clave vacia")
+        
+        #Retornar diccionario listo para cifrar los datos
+        dict_data[keyClean] = valueClean
+
+    return dict_data
+
+            

secure_credentials_roan-0.1.0/secure_credentials_roan.egg-info/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: secure-credentials-roan
+Version: 0.1.0
+Summary: Paquete sencillo para cifrar y descifrar archivos de credenciales
+Author: Angel Rogelio Argonza Roblero
+License: MIT
+Project-URL: Homepage, https://github.com/TU_USUARIO/secure_credentials_roan
+Project-URL: Repository, https://github.com/TU_USUARIO/secure_credentials_roan
+Project-URL: Issues, https://github.com/TU_USUARIO/secure_credentials_roan/issues
+Keywords: python,credentials,encryption,security,fernet
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=42.0.0
+
+# Secure Credentials Roan
+
+Paquete de Python para cifrar y descifrar archivos de credenciales con formato clave=valor.
+
+## Instalación
+
+```bash
+pip install secure-credentials-roan
+
+## Uso básico
+from secure_credentials import create_key_file, encrypt_file, load_credentials
+
+create_key_file("secret.key")
+
+encrypt_file(
+    input_path="credentials.txt",
+    output_path="credentials.enc",
+    key_path="secret.key",
+)
+
+credentials = load_credentials(
+    encrypted_path="credentials.enc",
+    key_path="secret.key",
+)
+
+print(credentials)
+
+## Formato del archivo de credenciales
+user=root
+password=mysql_5
+database=automcae
+host=localhost
+port=3306

secure_credentials_roan-0.1.0/secure_credentials_roan.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+secure_credentials/__init__.py
+secure_credentials/crypto.py
+secure_credentials/parser.py
+secure_credentials_roan.egg-info/PKG-INFO
+secure_credentials_roan.egg-info/SOURCES.txt
+secure_credentials_roan.egg-info/dependency_links.txt
+secure_credentials_roan.egg-info/requires.txt
+secure_credentials_roan.egg-info/top_level.txt
+tests/test_secure_credential.py

secure_credentials_roan-0.1.0/secure_credentials_roan.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

secure_credentials_roan-0.1.0/secure_credentials_roan.egg-info/requires.txt

@@ -0,0 +1 @@
+cryptography>=42.0.0

secure_credentials_roan-0.1.0/secure_credentials_roan.egg-info/top_level.txt

@@ -0,0 +1 @@
+secure_credentials

secure_credentials_roan-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

secure_credentials_roan-0.1.0/tests/test_secure_credential.py

@@ -0,0 +1,23 @@
+##########################
+# author: roan           #
+# date: 2026/06/24       #
+##########################
+# Propose: test
+
+import unittest
+from pathlib import Path
+from secure_credentials.parser import get_dict
+from secure_credentials.crypto import save_key
+
+BASE_DIR = Path(__file__).resolve().parent
+
+class TestSecureCredential(unittest.TestCase):
+
+    #Prueba de lectura de archivos
+    def test_readfile(self):
+        path_file = BASE_DIR / "secret.txt"
+
+        dict = get_dict(path_file)
+
+    def test_save_key(self):
+        save_key()