las versiones 3 son las buenas

.gitignore

@@ -0,0 +1 @@
+/.venv

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)
+

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)
+
+
+

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)
+
+

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-----

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)
+

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)
+
+

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')

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-----

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-----