From 85db74f4827aaee4f3046fc77032c57c0ec4fe0d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kevin=20Mu=C3=B1oz?= Date: Mon, 24 Jun 2024 08:25:49 -0500 Subject: [PATCH] las versiones 3 son las buenas --- .gitignore | 1 + leerlicencia.py | 47 +++++++++++++++ leerlicencia2.py | 127 +++++++++++++++++++++++++++++++++++++++++ leerlicencia3.py | 126 ++++++++++++++++++++++++++++++++++++++++ licencia.cbs | 13 +++++ licencia.py | 55 ++++++++++++++++++ licencia2.py | 98 +++++++++++++++++++++++++++++++ licencia3.py | 88 ++++++++++++++++++++++++++++ licenciaproduction.cbs | 13 +++++ licenciaqa.cbs | 13 +++++ 10 files changed, 581 insertions(+) create mode 100644 .gitignore create mode 100644 leerlicencia.py create mode 100644 leerlicencia2.py create mode 100644 leerlicencia3.py create mode 100644 licencia.cbs create mode 100644 licencia.py create mode 100644 licencia2.py create mode 100644 licencia3.py create mode 100644 licenciaproduction.cbs create mode 100644 licenciaqa.cbs diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..87a15c2 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/.venv diff --git a/leerlicencia.py b/leerlicencia.py new file mode 100644 index 0000000..9a9cc9e --- /dev/null +++ b/leerlicencia.py @@ -0,0 +1,47 @@ +import gnupg + +def leer_descifrar_y_verificar_licencia(archivo_licencia, passphrase): + # Inicializar GPG + gpg = gnupg.GPG() + + try: + # Leer el contenido cifrado del archivo + with open(archivo_licencia, 'rb') as f: + contenido_cifrado = f.read() + + # Descifrar el contenido + descifrado = gpg.decrypt(contenido_cifrado, passphrase=passphrase) + + if not descifrado.ok: + print(f"Error al descifrar los datos: {descifrado.status}") + return + + print("Datos descifrados correctamente.") + + # Los datos descifrados contienen la licencia firmada + datos_descifrados = descifrado.data.decode('utf-8') + + # Verificar la firma + verificacion = gpg.verify(datos_descifrados) + + if not verificacion: + print("La firma de la licencia no es válida.") + else: + print("La firma de la licencia es válida.") + + # Imprimir los datos de la licencia + print("Datos de la licencia:") + print(datos_descifrados) + + except Exception as e: + print(f"Error al leer, descifrar o verificar los datos: {str(e)}") + +# Archivo de licencia a leer y descifrar +archivo_licencia = 'licencia.cbs' + +# Frase de paso para descifrar +passphrase = '172999' + +# Llamar a la función para leer, descifrar y verificar la licencia +leer_descifrar_y_verificar_licencia(archivo_licencia, passphrase) + diff --git a/leerlicencia2.py b/leerlicencia2.py new file mode 100644 index 0000000..6d7df93 --- /dev/null +++ b/leerlicencia2.py @@ -0,0 +1,127 @@ +import gnupg +import json +import pyodbc + +# Función para obtener conexión a MSSQL +def obtener_conexion(): + return pyodbc.connect( + 'DRIVER={ODBC Driver 18 for SQL Server};' + 'SERVER=140.82.58.83,14338;' + 'DATABASE=licencias;' + 'UID=sa;' + 'PWD=hG0eT6P9CDXQmbVQ3S4IHPX5drBMVxog;' + 'TrustServerCertificate=yes' + ) + +def leer_descifrar_y_validar_licencia(archivo_licencia, passphrase): + # Inicializar GPG + gpg = gnupg.GPG() + + try: + # Leer el archivo cifrado + with open(archivo_licencia, 'rb') as f: + contenido_cifrado = f.read() + + # Descifrar los datos + descifrado = gpg.decrypt(contenido_cifrado, passphrase=passphrase) + + if not descifrado.ok: + print(f"Error al descifrar los datos: {descifrado.status}") + return + + print("Licencia descifrada correctamente.") + + # Verificar la firma de los datos + verificacion = gpg.verify(descifrado.data) + + if verificacion: + print("La firma de la licencia es válida.") + else: + print("La firma de la licencia no es válida.") + print(f"Detalles de la verificación de la firma: {verificacion.stderr}") + return + + # Extraer los datos JSON de la parte firmada + datos_firmados = descifrado.data.decode('utf-8') + + # Los datos firmados con PGP suelen tener la forma: + # -----BEGIN PGP SIGNED MESSAGE----- + # Hash: SHA512 + # + # { + # "software": "MINDS", + # ... + # } + # + # Debemos eliminar los encabezados PGP para obtener el JSON puro. + + # Buscar el comienzo del JSON real (después de los encabezados PGP) + json_inicio = datos_firmados.find("{") + json_final = datos_firmados.rfind("}") + + if json_inicio == -1 or json_final == -1: + print("No se pudo encontrar el bloque JSON en los datos firmados.") + return + + # Extraer el bloque JSON + datos_licencia_json = datos_firmados[json_inicio:json_final + 1] + + # Convertir el JSON a un diccionario de Python + datos_licencia = json.loads(datos_licencia_json) + + print("Datos de la licencia:") + print(datos_licencia) + + # Verificar los datos contra la base de datos + if verificar_datos_contra_bd(datos_licencia): + print("La licencia es válida y coincide con los datos en la base de datos.") + else: + print("La licencia no coincide con los datos almacenados en la base de datos.") + + except Exception as e: + print(f"Error al leer, descifrar y validar la licencia: {str(e)}") + +def verificar_datos_contra_bd(datos_licencia): + try: + # Conectar a la base de datos MSSQL + conn = obtener_conexion() + cursor = conn.cursor() + + # Consultar los datos de la licencia en la base de datos + cursor.execute(''' + SELECT * FROM licencias + WHERE software = ? + AND version = ? + AND license_key = ? + AND expiry_date = ? + AND licensed_to = ? + ''', ( + datos_licencia['software'], + datos_licencia['version'], + datos_licencia['license_key'], + datos_licencia['expiry_date'], + datos_licencia['licensed_to'] + )) + + # Obtener el resultado de la consulta + resultado = cursor.fetchone() + conn.close() + + # Verificar si se encontraron coincidencias + return resultado is not None + + except pyodbc.Error as e: + print(f"Error al verificar la licencia en la base de datos: {str(e)}") + return False + +# Archivo de licencia cifrado +archivo_licencia = 'licencia.cbs' + +# Frase de paso para descifrar +passphrase = '172999' + +# Llamar a la función para leer, descifrar y validar la licencia +leer_descifrar_y_validar_licencia(archivo_licencia, passphrase) + + + diff --git a/leerlicencia3.py b/leerlicencia3.py new file mode 100644 index 0000000..d062c05 --- /dev/null +++ b/leerlicencia3.py @@ -0,0 +1,126 @@ +import gnupg +import json +import pyodbc +import argparse + +# Función para obtener conexión a MSSQL +def obtener_conexion(): + return pyodbc.connect( + 'DRIVER={ODBC Driver 18 for SQL Server};' + 'SERVER=140.82.58.83,14338;' + 'DATABASE=licencias;' + 'UID=sa;' + 'PWD=hG0eT6P9CDXQmbVQ3S4IHPX5drBMVxog;' + 'TrustServerCertificate=yes' + ) + +def leer_descifrar_y_validar_licencia(archivo_licencia, ambiente_esperado): + # Inicializar GPG + gpg = gnupg.GPG() + + try: + # Leer el archivo cifrado + with open(archivo_licencia, 'rb') as f: + contenido_cifrado = f.read() + + # Descifrar los datos usando la clave privada de la YubiKey + descifrado = gpg.decrypt(contenido_cifrado, passphrase='172999') + + if not descifrado.ok: + print(f"Error al descifrar los datos: {descifrado.status}") + return + + print("Licencia descifrada correctamente.") + + # Verificar la firma de los datos + verificacion = gpg.verify(descifrado.data) + + if verificacion.valid: + print("La firma de la licencia es válida.") + else: + print("La firma de la licencia no es válida.") + print(f"Detalles de la verificación de la firma: {verificacion.stderr}") + return + + # Extraer los datos JSON de la parte firmada + datos_firmados = descifrado.data.decode('utf-8') + + # Buscar el comienzo del JSON real (después de los encabezados PGP) + json_inicio = datos_firmados.find("{") + json_final = datos_firmados.rfind("}") + + if json_inicio == -1 or json_final == -1: + print("No se pudo encontrar el bloque JSON en los datos firmados.") + return + + # Extraer el bloque JSON + datos_licencia_json = datos_firmados[json_inicio:json_final + 1] + + # Convertir el JSON a un diccionario de Python + datos_licencia = json.loads(datos_licencia_json) + + print("Datos de la licencia:") + print(datos_licencia) + + # Verificar los datos contra la base de datos + if verificar_datos_contra_bd(datos_licencia): + print("La licencia es válida y coincide con los datos en la base de datos.") + + # Verificar el tipo de ambiente + if datos_licencia.get('environment') == ambiente_esperado: + print(f"La licencia es válida para el ambiente '{ambiente_esperado}'.") + else: + print(f"La licencia no es válida para el ambiente '{ambiente_esperado}'. Encontrado: {datos_licencia.get('environment')}") + else: + print("La licencia no coincide con los datos almacenados en la base de datos.") + + except Exception as e: + print(f"Error al leer, descifrar y validar la licencia: {str(e)}") + +def verificar_datos_contra_bd(datos_licencia): + try: + # Conectar a la base de datos MSSQL + conn = obtener_conexion() + cursor = conn.cursor() + + # Consultar los datos de la licencia en la base de datos + cursor.execute(''' + SELECT * FROM licencias + WHERE software = ? + AND version = ? + AND license_key = ? + AND expiry_date = ? + AND licensed_to = ? + AND environment = ? + ''', ( + datos_licencia['software'], + datos_licencia['version'], + datos_licencia['license_key'], + datos_licencia['expiry_date'], + datos_licencia['licensed_to'], + datos_licencia['environment'] + )) + + # Obtener el resultado de la consulta + resultado = cursor.fetchone() + conn.close() + + # Verificar si se encontraron coincidencias + return resultado is not None + + except pyodbc.Error as e: + print(f"Error al verificar la licencia en la base de datos: {str(e)}") + return False + +# Configuración del analizador de argumentos +parser = argparse.ArgumentParser(description='Leer, descifrar y validar una licencia.') +parser.add_argument('archivo_licencia', type=str, help='Ruta del archivo de licencia cifrado') +parser.add_argument('ambiente', type=str, choices=['QA', 'Production'], help='Ambiente esperado de la licencia') + +# Parsear los argumentos +args = parser.parse_args() + +# Llamar a la función para leer, descifrar y validar la licencia +leer_descifrar_y_validar_licencia(args.archivo_licencia, args.ambiente) + + diff --git a/licencia.cbs b/licencia.cbs new file mode 100644 index 0000000..3b51615 --- /dev/null +++ b/licencia.cbs @@ -0,0 +1,13 @@ +-----BEGIN PGP MESSAGE----- + +jA0ECQMItYzVDXWX8s730sCxAaLP33uhsaSdKDEmAH1AWnUc16KWpGq7B/tjopN4 +VbfUrqAHQm3I2rypI1Tqj031YK7JBd/8sLIsJ7oopi/pcgF+qgeECb6NEAKEGn1x +bTF8v8OJuPifJWlS1aw6EzbUg8xGHez3i0cNvVARpwm3DYdLFUps4CLINcPpyEZb +fwYaBXarxDNsdAGHR3yPPUmgP85lst0wR3gI3z3VOlZj2SA+6zcPsFfXZoi5pHbT +jaH9r1OBTpHpdqwxBleEUAwCQB5IpIV43TG7uWZ64gbJ54FhGPsJAUpYPzZMKsJK +BMefKjUA0laOTN6O3MLw3l0LTAhxjh1bVNgYSEL3QWwbbouyi9YurLbosFp1jovU +xbdvg5hAPrVW3cMWE/F3MAeIYBZecBPr6AT+pBCyFWXqUSXDmA0BmCYTRq/65tjG +g7n4MGKWlbghQXad4WhDwyvrNxJ70kZShUpXNrrpuC9v1WgF7NvjI3baBo0GraJT +gn72 +=gsrq +-----END PGP MESSAGE----- diff --git a/licencia.py b/licencia.py new file mode 100644 index 0000000..e0ac50e --- /dev/null +++ b/licencia.py @@ -0,0 +1,55 @@ +import gnupg +import json + +def firmar_y_cifrar_licencia(datos_licencia, passphrase): + # Inicializar GPG + gpg = gnupg.GPG() + + try: + # Convertir los datos de la licencia a JSON + datos_licencia_json = json.dumps(datos_licencia, indent=4) + + # Firmar los datos de la licencia + firma = gpg.sign(message=datos_licencia_json, detach=False, passphrase=passphrase) + + if not firma: + print("Error al firmar los datos.") + return + + print("Datos firmados correctamente.") + + # Convertir los datos firmados a bytes + datos_firmados = str(firma).encode('utf-8') + + # Cifrar los datos firmados + cifrado = gpg.encrypt(data=datos_firmados, recipients=None, symmetric=True, passphrase=passphrase) + + if not cifrado: + print("Error al cifrar los datos.") + return + + # Guardar los datos cifrados en un archivo + archivo_salida = 'licencia.cbs' + with open(archivo_salida, 'wb') as f: + f.write(cifrado.data) + + print(f"Datos cifrados y guardados en '{archivo_salida}' correctamente.") + + except Exception as e: + print(f"Error al firmar y cifrar los datos: {str(e)}") + +# Datos de la licencia a firmar y cifrar +datos_licencia = { + "software": "MINDS", + "version": "1.0", + "license_key": "ABCD-EFGH-IJKL-MNOP", + "expiry_date": "2025-06-17", + "licensed_to": "USUARIO FAKE" +} + +# Frase de paso para acceder a la clave privada y para cifrar +passphrase = '172999' + +# Llamar a la función para firmar y cifrar la licencia +firmar_y_cifrar_licencia(datos_licencia, passphrase) + diff --git a/licencia2.py b/licencia2.py new file mode 100644 index 0000000..165a289 --- /dev/null +++ b/licencia2.py @@ -0,0 +1,98 @@ +import gnupg +import json +import pyodbc + +# Función para obtener conexión a MSSQL +def obtener_conexion(): + return pyodbc.connect( + 'DRIVER={ODBC Driver 18 for SQL Server};' + 'SERVER=140.82.58.83,14338;' + 'DATABASE=licencias;' + 'UID=sa;' + 'PWD=hG0eT6P9CDXQmbVQ3S4IHPX5drBMVxog;' + 'TrustServerCertificate=yes' + ) + +def firmar_y_cifrar_licencia(datos_licencia, passphrase): + # Inicializar GPG + gpg = gnupg.GPG() + + try: + # Convertir los datos de la licencia a JSON + datos_licencia_json = json.dumps(datos_licencia, indent=4) + + # Firmar los datos de la licencia + firma = gpg.sign(message=datos_licencia_json, detach=False, passphrase=passphrase) + + if not firma: + print("Error al firmar los datos.") + return + + print("Datos firmados correctamente.") + + # Convertir los datos firmados a bytes + datos_firmados = str(firma).encode('utf-8') + + # Cifrar los datos firmados + cifrado = gpg.encrypt(data=datos_firmados, recipients=None, symmetric=True, passphrase=passphrase) + + if not cifrado.ok: + print(f"Error al cifrar los datos: {cifrado.status}") + return + + # Guardar los datos cifrados en un archivo + archivo_salida = 'licencia.cbs' + with open(archivo_salida, 'wb') as f: + f.write(cifrado.data) + + print(f"Datos cifrados y guardados en '{archivo_salida}' correctamente.") + + # Almacenar los datos de la licencia en la base de datos MSSQL + almacenar_licencia_en_db(datos_licencia) + + except Exception as e: + print(f"Error al firmar y cifrar los datos: {str(e)}") + +def almacenar_licencia_en_db(datos_licencia): + try: + # Conectar a la base de datos MSSQL + conn = obtener_conexion() + cursor = conn.cursor() + + # Insertar los datos de la licencia en la tabla + cursor.execute(''' + INSERT INTO licencias (software, version, license_key, expiry_date, licensed_to) + VALUES (?, ?, ?, ?, ?) + ''', ( + datos_licencia['software'], + datos_licencia['version'], + datos_licencia['license_key'], + datos_licencia['expiry_date'], + datos_licencia['licensed_to'] + )) + + # Confirmar los cambios y cerrar la conexión + conn.commit() + conn.close() + + print("Datos de la licencia almacenados en la base de datos correctamente.") + + except pyodbc.Error as e: + print(f"Error al almacenar la licencia en la base de datos: {str(e)}") + +# Datos de la licencia a firmar y cifrar +datos_licencia = { + "software": "MINDS", + "version": "1.0", + "license_key": "ABCD-EFGH-IJKL-MNOP", + "expiry_date": "2025-06-17", + "licensed_to": "USUARIO FAKE" +} + +# Frase de paso para acceder a la clave privada y para cifrar +passphrase = '172999' + +# Llamar a la función para firmar y cifrar la licencia +firmar_y_cifrar_licencia(datos_licencia, passphrase) + + diff --git a/licencia3.py b/licencia3.py new file mode 100644 index 0000000..7f9398d --- /dev/null +++ b/licencia3.py @@ -0,0 +1,88 @@ +import gnupg +import json +import pyodbc +import secrets +from datetime import datetime + +# Inicializar GPG +gpg = gnupg.GPG() + +# Generar una clave de licencia aleatoria +def generar_clave_licencia(): + return secrets.token_urlsafe(16) # Genera una cadena aleatoria de 16 caracteres URL-safe + +# Crear una nueva licencia con una clave aleatoria +def crear_licencia(environment): + datos_licencia = { + "software": "MINDS", + "version": "1.0", + "license_key": generar_clave_licencia(), # Clave de licencia aleatoria + "expiry_date": "2025-06-17", + "licensed_to": "USUARIO FAKE", + "environment": environment + } + + # Convertir los datos a JSON + datos_json = json.dumps(datos_licencia, indent=4) + + # Firmar los datos con la YubiKey + firma = gpg.sign(datos_json, passphrase='172999') + + if not firma: + print("Error al firmar los datos.") + exit() + + # Datos firmados convertidos a cadena + datos_firmados = str(firma) + + # Cifrar los datos firmados usando cifrado asimétrico + cifrado = gpg.encrypt(datos_firmados, recipients=None, symmetric=True, passphrase='172999') + + if not cifrado.ok: + print(f"Error al cifrar los datos: {cifrado.status}") + exit() + + # Guardar los datos cifrados en un archivo + archivo_licencia = f'licencia{environment.lower()}.cbs' + with open(archivo_licencia, 'wb') as f: + f.write(cifrado.data) + + print("Datos firmados correctamente.") + print(f"Datos cifrados y guardados en '{archivo_licencia}' correctamente.") + + # Almacenar los datos en la base de datos + try: + conn = pyodbc.connect( + 'DRIVER={ODBC Driver 18 for SQL Server};' + 'SERVER=140.82.58.83,14338;' + 'DATABASE=licencias;' + 'UID=sa;' + 'PWD=hG0eT6P9CDXQmbVQ3S4IHPX5drBMVxog;' + 'TrustServerCertificate=yes' + ) + cursor = conn.cursor() + + cursor.execute(''' + INSERT INTO licencias (software, version, license_key, expiry_date, licensed_to, environment) + VALUES (?, ?, ?, ?, ?, ?) + ''', ( + datos_licencia['software'], + datos_licencia['version'], + datos_licencia['license_key'], + datos_licencia['expiry_date'], + datos_licencia['licensed_to'], + datos_licencia['environment'] + )) + + conn.commit() + conn.close() + print("Licencia almacenada en la base de datos correctamente.") + + except pyodbc.Error as e: + print(f"Error al almacenar la licencia en la base de datos: {str(e)}") + +# Generar licencia para QA +crear_licencia('QA') + +# Generar licencia para Production +crear_licencia('Production') diff --git a/licenciaproduction.cbs b/licenciaproduction.cbs new file mode 100644 index 0000000..8db1b6e --- /dev/null +++ b/licenciaproduction.cbs @@ -0,0 +1,13 @@ +-----BEGIN PGP MESSAGE----- + +jA0ECQMIfA04dIN73U720sDIAVQpbTv/aI4WYB5Yn5rBQhJrlvefv4FNeNNnmSXT +PJ23A+Diw00BGJilpwM+APaBAlCl68N/FoE1/T7h/YJ/iXns1tJ19hOSmGEy3oOl +bh5ZckJ7I4O1W30tTnD0B4WjXFJinvhqA/5fuggCYbMpNaCsRI4imQj6AwFKTkOe +y0uEXwPoDjNVc75SpezCRrFG/1DRa/oHutvo9M3wH4PSHRLyLSLsYeDTUcnrJPGl +093u487tOuW4qoxc1ouLWJ2uN40lRgp62rnuoP/W3wY1mYEPCb0wEBWMuWGcGmsr +vdcow4/ZILWHqEIiBQxPVecZ9B2uKJUBa+nf9PS4RbHFG06/069WdXIIl3vane5T +ci6am+E7jDdTSxNE5qwIRtChlzeMOaiPoLMH3nQRJoQEFLzRhpDF7WY3FmhSNf1s +Gu3zxQ65ekHTPeox23hAd12zD1vOyc/kf+xYHpJsT8ZR41sPVRV7+vYAS3E5t3Uq +rShydZZBqq22ArldUOAq9QyBHKj3SCtBxqE= +=ziRe +-----END PGP MESSAGE----- diff --git a/licenciaqa.cbs b/licenciaqa.cbs new file mode 100644 index 0000000..b9868f3 --- /dev/null +++ b/licenciaqa.cbs @@ -0,0 +1,13 @@ +-----BEGIN PGP MESSAGE----- + +jA0ECQMIFRf5KGxidqL20sDCAad/AfSgfWYSAIi6ebidEr3qIJJI66xvabrLHLAS +A7hTzND9CK/kjwNdm9Rs20vkFeE0ibuDycLR9Xt6fjei+Jyw6zq0+aXRwLm8Ovl1 +u1p0rDg3ptcFEbPizmV5zjcjNueAxNePB9Xa9nMI7BObJ0Z4JuoKnfgJzGOSaCA1 +2DNWHXwjfh0ziEqHbj7yAazULlfjV5lIXv1XZ9hWFPig9HsMQv0gexvTb++/0ces +GZRAkctkSAjBBgwLjV44CV0gGRoOCC1wNRiOAg3UgfO0fCAwvOQGdKcRFxbIv6oZ +SXHVACSCLEdWauM7kgC4MgNje3eJJjAJd+8wTLnFcpUvJ1ZavY/mv9T/ZVow3UaW +Fs0BZ9M+DGoY18UDPEtmGLmFkIgjGXIDwj3BdV8KMZoOfOKKp/CgWQRuGTq3eSKs +DJacewt1QqM5UgwEdwAzsRe0vjnyR2UU/eHCSFxDYu/6K4HlvQijP/To8DNggbeB +oP3HhJ/P0ZIlzPojV4LLtz87F50= +=rHhN +-----END PGP MESSAGE-----