devkanan 0.2.0__tar.gz

devkanan-0.2.0/LICENSE

@@ -0,0 +1,20 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2026 Vilchis
+
+   Portions derived from Cryptolens Python SDK (Apache-2.0):
+   Copyright (C) 2015-2023 Cryptolens AB
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

devkanan-0.2.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: devkanan
+Version: 0.2.0
+Summary: Cliente Python para DevKanan — validación local + API online de licencias firmadas RSA
+Author-email: Vilchis <vilchislalo98@gmail.com>
+License: Apache-2.0
+Project-URL: Homepage, https://devkanan.dev
+Keywords: license,licensing,rsa,drm,devkanan,kanan
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cryptography>=41.0.0
+Requires-Dist: requests>=2.28.0
+Dynamic: license-file
+
+# qustomlicensing
+
+Cliente Python ligero para validar archivos de licencia `.dat` firmados con RSA, emitidos por **LicensingServer** SaaS o QustomLicenseServer.
+
+API estilo Cryptolens — fácil migración si vienes de su SDK.
+
+## Instalación
+
+```bash
+pip install qustomlicensing
+```
+
+O para desarrollo:
+```bash
+pip install -e .
+```
+
+## Uso básico
+
+```python
+from qustomlicensing import LicenseKey, Helpers
+
+# Clave pública RSA del tenant (XML o PEM)
+RSA_PUB_KEY = """-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA...
+-----END PUBLIC KEY-----"""
+
+# Obtener machine code de esta PC
+machine_code = Helpers.GetMachineCode(v=2)
+
+# Leer y validar .dat
+with open("license.dat", "r", encoding="utf-8-sig") as f:
+    license_key = LicenseKey.load_from_string(RSA_PUB_KEY, f.read(), max_age_days=1)
+
+if license_key is None:
+    print("Licencia invalida o firma corrupta")
+    exit(1)
+
+# Verificar esta máquina
+if not license_key.is_on_right_machine(machine_code):
+    print("Esta maquina no esta autorizada")
+    exit(1)
+
+# Verificar features
+if license_key.F1:
+    print("Feature Pro activado")
+
+print(f"Licencia valida hasta {license_key.expires}")
+```
+
+## API
+
+### `Helpers.GetMachineCode(v=2)`
+Genera un machine code único basado en propiedades del hardware. `v=2` es el algoritmo actual (SHA-256 sobre identificadores).
+
+### `LicenseKey.load_from_string(rsa_pub_key, content, max_age_days=0)`
+Parsea un `.dat` JSON, verifica firma RSA y freshness.
+
+| Parámetro | Tipo | Descripción |
+|---|---|---|
+| `rsa_pub_key` | str | XML (.NET) o PEM. Auto-detecta. |
+| `content` | str | Contenido del archivo `.dat` |
+| `max_age_days` | int | Máx. días desde `signDate`. 0 = ilimitado o usa el del `.dat`. |
+
+Devuelve un objeto `LicenseKey` o `None` si la validación falla.
+
+### Atributos de `LicenseKey`
+| Atributo | Tipo |
+|---|---|
+| `product_id`, `id`, `key`, `notes` | datos básicos |
+| `created`, `expires`, `sign_date` | datetimes UTC |
+| `period`, `max_no_of_machines`, `max_offline_days` | enteros |
+| `F1`..`F8`, `block`, `trial_activation` | flags |
+| `activated_machines` | List[ActivatedMachine] |
+| `data_objects` | List[DataObject] |
+| `customer` | Customer o None |
+| `offline_mode` | str (FloatingLease/FloatingManual/Locked) |
+
+### `license_key.is_on_right_machine(machine_code)`
+Verifica que el machine code esté en `activatedMachines`.
+
+### `license_key.has_not_expired()`
+Verifica que `expires > now`.
+
+### `license_key.has_feature(n)`
+Atajo para `getattr(license_key, f'F{n}')`.
+
+## Comparación con SDK Cryptolens
+
+| | Cryptolens SDK | qustomlicensing |
+|---|---|---|
+| Activate online | ✅ | ❌ (usa requests directamente) |
+| Validar .skm/.dat offline | ✅ | ✅ |
+| `Helpers.GetMachineCode` | ✅ | ✅ (compatible) |
+| `LicenseKey.load_from_string` | ✅ | ✅ (compatible) |
+| Tamaño | ~2 MB con deps | ~50 KB |
+| Dependencias | `pycryptodome`, `requests` | solo `cryptography` |
+
+## Licencia
+
+Apache-2.0. Basado en código del SDK de Cryptolens (también Apache-2.0).

devkanan-0.2.0/README.md

@@ -0,0 +1,101 @@
+# qustomlicensing
+
+Cliente Python ligero para validar archivos de licencia `.dat` firmados con RSA, emitidos por **LicensingServer** SaaS o QustomLicenseServer.
+
+API estilo Cryptolens — fácil migración si vienes de su SDK.
+
+## Instalación
+
+```bash
+pip install qustomlicensing
+```
+
+O para desarrollo:
+```bash
+pip install -e .
+```
+
+## Uso básico
+
+```python
+from qustomlicensing import LicenseKey, Helpers
+
+# Clave pública RSA del tenant (XML o PEM)
+RSA_PUB_KEY = """-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA...
+-----END PUBLIC KEY-----"""
+
+# Obtener machine code de esta PC
+machine_code = Helpers.GetMachineCode(v=2)
+
+# Leer y validar .dat
+with open("license.dat", "r", encoding="utf-8-sig") as f:
+    license_key = LicenseKey.load_from_string(RSA_PUB_KEY, f.read(), max_age_days=1)
+
+if license_key is None:
+    print("Licencia invalida o firma corrupta")
+    exit(1)
+
+# Verificar esta máquina
+if not license_key.is_on_right_machine(machine_code):
+    print("Esta maquina no esta autorizada")
+    exit(1)
+
+# Verificar features
+if license_key.F1:
+    print("Feature Pro activado")
+
+print(f"Licencia valida hasta {license_key.expires}")
+```
+
+## API
+
+### `Helpers.GetMachineCode(v=2)`
+Genera un machine code único basado en propiedades del hardware. `v=2` es el algoritmo actual (SHA-256 sobre identificadores).
+
+### `LicenseKey.load_from_string(rsa_pub_key, content, max_age_days=0)`
+Parsea un `.dat` JSON, verifica firma RSA y freshness.
+
+| Parámetro | Tipo | Descripción |
+|---|---|---|
+| `rsa_pub_key` | str | XML (.NET) o PEM. Auto-detecta. |
+| `content` | str | Contenido del archivo `.dat` |
+| `max_age_days` | int | Máx. días desde `signDate`. 0 = ilimitado o usa el del `.dat`. |
+
+Devuelve un objeto `LicenseKey` o `None` si la validación falla.
+
+### Atributos de `LicenseKey`
+| Atributo | Tipo |
+|---|---|
+| `product_id`, `id`, `key`, `notes` | datos básicos |
+| `created`, `expires`, `sign_date` | datetimes UTC |
+| `period`, `max_no_of_machines`, `max_offline_days` | enteros |
+| `F1`..`F8`, `block`, `trial_activation` | flags |
+| `activated_machines` | List[ActivatedMachine] |
+| `data_objects` | List[DataObject] |
+| `customer` | Customer o None |
+| `offline_mode` | str (FloatingLease/FloatingManual/Locked) |
+
+### `license_key.is_on_right_machine(machine_code)`
+Verifica que el machine code esté en `activatedMachines`.
+
+### `license_key.has_not_expired()`
+Verifica que `expires > now`.
+
+### `license_key.has_feature(n)`
+Atajo para `getattr(license_key, f'F{n}')`.
+
+## Comparación con SDK Cryptolens
+
+| | Cryptolens SDK | qustomlicensing |
+|---|---|---|
+| Activate online | ✅ | ❌ (usa requests directamente) |
+| Validar .skm/.dat offline | ✅ | ✅ |
+| `Helpers.GetMachineCode` | ✅ | ✅ (compatible) |
+| `LicenseKey.load_from_string` | ✅ | ✅ (compatible) |
+| Tamaño | ~2 MB con deps | ~50 KB |
+| Dependencias | `pycryptodome`, `requests` | solo `cryptography` |
+
+## Licencia
+
+Apache-2.0. Basado en código del SDK de Cryptolens (también Apache-2.0).

devkanan-0.2.0/devkanan/__init__.py

@@ -0,0 +1,42 @@
+"""
+DevKanan — cliente Python para validación y activación de licencias.
+
+Uso offline (validar un .dat):
+    from devkanan import LicenseKey, Helpers
+
+    with open("license.dat", encoding="utf-8-sig") as f:
+        lk = LicenseKey.load_from_string(RSA_PUB_KEY, f.read(), max_age_days=1)
+
+    if lk and lk.is_on_right_machine(Helpers.GetMachineCode(v=2)):
+        print("OK")
+
+Uso online (activar contra el SaaS):
+    from devkanan import Key, Helpers
+
+    license_key, msg = Key.activate(
+        token=TOKEN_ACT,
+        rsa_pub_key=RSA_PUBLIC_KEY,
+        product_id=PRODUCT_ID,
+        key=serial_key,
+        machine_code=Helpers.GetMachineCode(v=2),
+        server_url="https://devkanan.dev",  # opcional
+    )
+
+    if license_key:
+        print(f"Activated: {license_key.key}")
+"""
+
+from .helpers import Helpers
+from .license_key import LicenseKey, ActivatedMachine, DataObject, Customer
+from .key import Key, Credits
+
+__version__ = "0.2.0"
+__all__ = [
+    "LicenseKey",
+    "Helpers",
+    "Key",
+    "Credits",
+    "ActivatedMachine",
+    "DataObject",
+    "Customer",
+]

devkanan-0.2.0/devkanan/helpers.py

@@ -0,0 +1,110 @@
+"""
+Helpers — machine code generation compatible bit-a-bit con el SDK de Cryptolens.
+
+Algoritmos disponibles:
+  v=1 → Windows: `wmic csproduct get uuid`  (UUID de la BIOS)
+  v=2 → Windows: PowerShell `(Get-CimInstance Win32_ComputerSystemProduct).UUID`
+        (recomendado — más estable cross-instalación de Windows)
+
+Linux/Mac usan el mismo algoritmo en ambas versiones.
+"""
+
+import hashlib
+import platform
+import subprocess
+
+
+class Helpers:
+    """Wrapper estilo Cryptolens SDK."""
+
+    @staticmethod
+    def GetMachineCode(v: int = 2) -> str:
+        """
+        Devuelve el SHA-256 hex de un identificador único de hardware.
+
+        Args:
+            v: 1 = algoritmo wmic (legacy), 2 = PowerShell CIM (default, recomendado).
+
+        Returns:
+            Hash hex de 64 caracteres. Cadena vacía si no se pudo obtener.
+        """
+        if "windows" in platform.platform().lower():
+            if v == 2:
+                seed = HelperMethods.start_process_ps_v2()
+            else:
+                seed = HelperMethods.start_process(["cmd.exe", "/C", "wmic", "csproduct", "get", "uuid"], v)
+
+            if not seed:
+                machine_guid = HelperMethods.read_registry_value(
+                    r"SOFTWARE\Microsoft\Cryptography", "MachineGuid"
+                )
+                if machine_guid:
+                    return HelperMethods.get_SHA256(machine_guid)
+                return ""
+            return HelperMethods.get_SHA256(seed)
+
+        if "mac" in platform.platform().lower() or "darwin" in platform.platform().lower():
+            seed = HelperMethods.start_process(["system_profiler", "SPHardwareDataType"], v)
+            if not seed:
+                return ""
+            idx = seed.find("UUID")
+            if idx < 0:
+                return ""
+            return HelperMethods.get_SHA256(seed[idx:].strip())
+
+        # Linux / otros
+        for path in ("/etc/machine-id", "/var/lib/dbus/machine-id"):
+            try:
+                with open(path) as f:
+                    return HelperMethods.get_SHA256(f.read().strip())
+            except Exception:
+                continue
+        return ""
+
+
+class HelperMethods:
+    """Métodos internos de bajo nivel — mismas firmas que el SDK Cryptolens."""
+
+    @staticmethod
+    def start_process(cmd: list, v: int = 1) -> str:
+        """Ejecuta un comando y devuelve la primera línea no-header de su output."""
+        try:
+            proc = subprocess.Popen(
+                cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True
+            )
+            out, _ = proc.communicate(timeout=30)
+            text = out.decode("utf-8", errors="replace").strip()
+            # Output típico de wmic: "UUID\n<valor>\n" — descartamos el header.
+            lines = [l.strip() for l in text.splitlines() if l.strip() and l.strip().upper() != "UUID"]
+            return lines[0] if lines else ""
+        except Exception:
+            return ""
+
+    @staticmethod
+    def start_process_ps_v2() -> str:
+        """v=2: usa PowerShell para obtener Win32_ComputerSystemProduct.UUID."""
+        try:
+            proc = subprocess.Popen(
+                ["powershell", "-Command", "(Get-CimInstance -Class Win32_ComputerSystemProduct).UUID"],
+                stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True,
+            )
+            out, _ = proc.communicate(timeout=30)
+            return out.decode("utf-8", errors="replace").strip()
+        except Exception:
+            return ""
+
+    @staticmethod
+    def read_registry_value(subkey: str, name: str) -> str:
+        """Lee un valor de HKEY_LOCAL_MACHINE\\<subkey>. Solo Windows."""
+        try:
+            import winreg  # type: ignore
+            with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, subkey) as key:
+                value, _ = winreg.QueryValueEx(key, name)
+                return str(value) if value else ""
+        except Exception:
+            return ""
+
+    @staticmethod
+    def get_SHA256(data: str) -> str:
+        """SHA-256 hex en minúsculas."""
+        return hashlib.sha256(data.encode("utf-8")).hexdigest()

devkanan-0.2.0/devkanan/key.py

@@ -0,0 +1,231 @@
+"""
+Key — operaciones online contra el SaaS DevKanan.
+API estilo Cryptolens SDK: Key.activate / Key.deactivate / Key.get_key.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Optional, Tuple
+
+import requests
+
+from .license_key import LicenseKey, _from_dict
+
+
+DEFAULT_SERVER_URL = "https://devkanan.dev"
+
+
+class Key:
+    """Operaciones contra la API REST de DevKanan."""
+
+    @staticmethod
+    def activate(
+        token: str,
+        rsa_pub_key: str,
+        product_id: int,
+        key: str,
+        machine_code: str,
+        friendly_name: Optional[str] = None,
+        floating_time_interval: int = 0,
+        max_overdraft: int = 0,
+        server_url: str = DEFAULT_SERVER_URL,
+        timeout: int = 10,
+    ) -> Tuple[Optional[LicenseKey], str]:
+        """
+        Activa una licencia contra el servidor DevKanan.
+
+        Returns:
+            (LicenseKey, mensaje) si éxito.
+            (None, mensaje_error) si falla.
+        """
+        try:
+            data = {
+                "token": token,
+                "product_id": product_id,
+                "key": key,
+                "machine_code": machine_code,
+                "max_overdraft": max_overdraft,
+            }
+            if friendly_name:
+                data["friendly_name"] = friendly_name
+            if floating_time_interval > 0:
+                data["floating_time_interval"] = floating_time_interval
+
+            r = requests.post(f"{server_url.rstrip('/')}/api/key/activate", data=data, timeout=timeout)
+            response = r.json()
+        except requests.RequestException as ex:
+            return None, f"Network error: {ex}"
+        except Exception as ex:
+            return None, f"Error: {ex}"
+
+        if response.get("result") != 0:
+            return None, response.get("message", "Unknown error")
+
+        # Verificar firma del licenseKey devuelto
+        license_obj = response.get("licenseKey")
+        signature_b64 = response.get("signature", "")
+        if not license_obj or not signature_b64:
+            return None, "Invalid server response (missing licenseKey or signature)"
+
+        # Re-serializar como hace el server para validar la firma
+        from cryptography.exceptions import InvalidSignature
+        from cryptography.hazmat.primitives import hashes
+        from cryptography.hazmat.primitives.asymmetric import padding
+        from .license_key import _load_public_key
+        import base64
+
+        try:
+            pub = _load_public_key(rsa_pub_key)
+            payload = json.dumps(license_obj, separators=(",", ":"), ensure_ascii=False)
+            signature = base64.b64decode(signature_b64)
+            pub.verify(signature, payload.encode("utf-8"), padding.PKCS1v15(), hashes.SHA256())
+        except InvalidSignature:
+            return None, "Response signature invalid — possible MITM or wrong RSA key"
+        except Exception as ex:
+            return None, f"Signature verification failed: {ex}"
+
+        return _from_dict(license_obj), response.get("message", "")
+
+    @staticmethod
+    def deactivate(
+        token: str,
+        product_id: int,
+        key: str,
+        machine_code: str,
+        floating: bool = False,
+        server_url: str = DEFAULT_SERVER_URL,
+        timeout: int = 10,
+    ) -> Tuple[bool, str]:
+        """Libera la máquina actual de una licencia."""
+        try:
+            r = requests.post(
+                f"{server_url.rstrip('/')}/api/key/deactivate",
+                data={
+                    "token": token,
+                    "product_id": product_id,
+                    "key": key,
+                    "machine_code": machine_code,
+                    "floating": str(floating).lower(),
+                },
+                timeout=timeout,
+            )
+            response = r.json()
+        except Exception as ex:
+            return False, f"Error: {ex}"
+
+        return response.get("result") == 0, response.get("message", "")
+
+    @staticmethod
+    def get_key(
+        token: str,
+        rsa_pub_key: str,
+        product_id: int,
+        key: str,
+        server_url: str = DEFAULT_SERVER_URL,
+        timeout: int = 10,
+    ) -> Tuple[Optional[LicenseKey], str]:
+        """Consulta info de una licencia sin activarla."""
+        try:
+            r = requests.post(
+                f"{server_url.rstrip('/')}/api/key/getkey",
+                data={
+                    "token": token,
+                    "product_id": product_id,
+                    "key": key,
+                },
+                timeout=timeout,
+            )
+            response = r.json()
+        except Exception as ex:
+            return None, f"Error: {ex}"
+
+        if response.get("result") != 0:
+            return None, response.get("message", "Unknown error")
+
+        license_obj = response.get("licenseKey")
+        signature_b64 = response.get("signature", "")
+        if not license_obj or not signature_b64:
+            return None, "Invalid server response"
+
+        # Verificar firma
+        from cryptography.exceptions import InvalidSignature
+        from cryptography.hazmat.primitives import hashes
+        from cryptography.hazmat.primitives.asymmetric import padding
+        from .license_key import _load_public_key
+        import base64
+
+        try:
+            pub = _load_public_key(rsa_pub_key)
+            payload = json.dumps(license_obj, separators=(",", ":"), ensure_ascii=False)
+            signature = base64.b64decode(signature_b64)
+            pub.verify(signature, payload.encode("utf-8"), padding.PKCS1v15(), hashes.SHA256())
+        except InvalidSignature:
+            return None, "Response signature invalid"
+        except Exception as ex:
+            return None, f"Signature verification failed: {ex}"
+
+        return _from_dict(license_obj), response.get("message", "")
+
+    @staticmethod
+    def save_to_file(license_key_response: dict, file_path: str) -> None:
+        """Guarda la respuesta completa de activate/get_key (con firma) en un .dat para uso offline posterior."""
+        with open(file_path, "w", encoding="utf-8") as f:
+            json.dump(license_key_response, f, indent=2, ensure_ascii=False)
+
+
+class Credits:
+    """Operaciones de créditos contra DevKanan."""
+
+    @staticmethod
+    def record(
+        token: str,
+        product_id: int,
+        key: str,
+        amount: int,
+        feature: Optional[str] = None,
+        machine_code: Optional[str] = None,
+        server_url: str = DEFAULT_SERVER_URL,
+        timeout: int = 10,
+    ) -> Tuple[bool, int, str]:
+        """
+        Descuenta créditos. Devuelve (success, balance_restante, mensaje).
+        """
+        try:
+            data = {"token": token, "product_id": product_id, "key": key, "amount": amount}
+            if feature:
+                data["feature"] = feature
+            if machine_code:
+                data["machine_code"] = machine_code
+
+            r = requests.post(f"{server_url.rstrip('/')}/api/credits/record", data=data, timeout=timeout)
+            response = r.json()
+        except Exception as ex:
+            return False, 0, f"Error: {ex}"
+
+        ok = response.get("result") == 0
+        return ok, int(response.get("balance", 0) or 0), response.get("message", "")
+
+    @staticmethod
+    def balance(
+        token: str,
+        product_id: int,
+        key: str,
+        server_url: str = DEFAULT_SERVER_URL,
+        timeout: int = 10,
+    ) -> Tuple[bool, int, str]:
+        """Consulta saldo actual. Devuelve (enabled, balance, mensaje)."""
+        try:
+            r = requests.post(
+                f"{server_url.rstrip('/')}/api/credits/balance",
+                data={"token": token, "product_id": product_id, "key": key},
+                timeout=timeout,
+            )
+            response = r.json()
+        except Exception as ex:
+            return False, 0, f"Error: {ex}"
+
+        if response.get("result") != 0:
+            return False, 0, response.get("message", "")
+
+        return bool(response.get("enabled", False)), int(response.get("balance", 0) or 0), ""

devkanan-0.2.0/devkanan/license_key.py

@@ -0,0 +1,267 @@
+"""
+LicenseKey — clase para parsear, verificar y consultar un archivo .dat firmado.
+API compatible con el SDK de Cryptolens: LicenseKey.load_from_string(pub_key, content, max_age_days).
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import List, Optional
+
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import padding, rsa
+from cryptography.hazmat.backends import default_backend
+
+
+@dataclass
+class ActivatedMachine:
+    mid: str = ""
+    ip: str = ""
+    time: int = 0
+    friendly_name: str = ""
+    floating_expires: int = 0
+
+
+@dataclass
+class DataObject:
+    id: int = 0
+    name: str = ""
+    string_value: str = ""
+    int_value: int = 0
+
+
+@dataclass
+class Customer:
+    id: int = 0
+    name: str = ""
+    email: str = ""
+    company_name: str = ""
+
+
+@dataclass
+class LicenseKey:
+    """Representa una licencia firmada cargada desde un .dat."""
+
+    product_id: int = 0
+    id: int = 0
+    key: str = ""
+    created: int = 0
+    expires: int = 0
+    period: int = 0
+    f1: bool = False
+    f2: bool = False
+    f3: bool = False
+    f4: bool = False
+    f5: bool = False
+    f6: bool = False
+    f7: bool = False
+    f8: bool = False
+    notes: str = ""
+    block: bool = False
+    global_id: int = 0
+    customer: Optional[Customer] = None
+    activated_machines: List[ActivatedMachine] = field(default_factory=list)
+    trial_activation: bool = False
+    max_no_of_machines: int = 0
+    offline_mode: str = "FloatingLease"
+    allowed_machines: str = ""
+    data_objects: List[DataObject] = field(default_factory=list)
+    sign_date: int = 0
+
+    # Aliases PascalCase (compat SDK Cryptolens)
+    @property
+    def ProductId(self) -> int: return self.product_id
+    @property
+    def ID(self) -> int: return self.id
+    @property
+    def Key(self) -> str: return self.key
+    @property
+    def Expires(self) -> int: return self.expires
+    @property
+    def SignDate(self) -> int: return self.sign_date
+    @property
+    def F1(self) -> bool: return self.f1
+    @property
+    def F2(self) -> bool: return self.f2
+    @property
+    def F3(self) -> bool: return self.f3
+    @property
+    def F4(self) -> bool: return self.f4
+    @property
+    def F5(self) -> bool: return self.f5
+    @property
+    def F6(self) -> bool: return self.f6
+    @property
+    def F7(self) -> bool: return self.f7
+    @property
+    def F8(self) -> bool: return self.f8
+
+    @staticmethod
+    def load_from_string(rsa_pub_key: str, content: str, max_age_days: int = 0) -> Optional["LicenseKey"]:
+        """
+        Parsea un .dat, verifica firma RSA y freshness.
+
+        Args:
+            rsa_pub_key: Clave pública en XML (.NET) o PEM (estándar).
+            content: Contenido del archivo .dat (JSON).
+            max_age_days: Días máximos desde signDate como fallback.
+                          Si el .dat trae `maxOfflineDays>0`, ese valor sobrescribe.
+
+        Returns:
+            LicenseKey si todo valida, None si falla cualquier check.
+        """
+        try:
+            content = content.lstrip("")  # quita BOM si existe
+            data = json.loads(content)
+        except Exception:
+            return None
+
+        license_obj = data.get("licenseKey") or data.get("LicenseKey")
+        signature_b64 = data.get("signature") or data.get("Signature")
+        if license_obj is None or not signature_b64:
+            return None
+
+        # Si licenseKey es base64 string (formato .skm legacy), decodificar
+        if isinstance(license_obj, str):
+            try:
+                license_obj = json.loads(base64.b64decode(license_obj).decode("utf-8"))
+            except Exception:
+                return None
+
+        # Verificar firma RSA
+        try:
+            pub = _load_public_key(rsa_pub_key)
+            payload = json.dumps(license_obj, separators=(",", ":"), ensure_ascii=False)
+            signature = base64.b64decode(signature_b64)
+            pub.verify(signature, payload.encode("utf-8"), padding.PKCS1v15(), hashes.SHA256())
+        except InvalidSignature:
+            return None
+        except Exception:
+            return None
+
+        lk = _from_dict(license_obj)
+
+        # Freshness check — controlado únicamente por el cliente
+        if max_age_days > 0 and lk.sign_date > 0:
+            signed_at = datetime.fromtimestamp(lk.sign_date, tz=timezone.utc)
+            age_days = (datetime.now(tz=timezone.utc) - signed_at).total_seconds() / 86400
+            if age_days > max_age_days:
+                return None
+
+        if lk.block:
+            return None
+
+        return lk
+
+    def is_on_right_machine(self, machine_code: str) -> bool:
+        """Verifica que el machine code esté entre las máquinas autorizadas."""
+        if not self.activated_machines:
+            return True  # Sin máquinas = licencia flotante general
+        return any(
+            m.mid == machine_code or m.mid == f"floating:{machine_code}"
+            for m in self.activated_machines
+        )
+
+    def has_not_expired(self) -> bool:
+        """True si la licencia aún no ha llegado a su fecha de expiración."""
+        return self.expires > int(datetime.now(tz=timezone.utc).timestamp())
+
+    def has_feature(self, n: int) -> bool:
+        """Atajo para F<n> (n=1..8)."""
+        if 1 <= n <= 8:
+            return getattr(self, f"f{n}", False)
+        return False
+
+    def __repr__(self) -> str:
+        exp = datetime.fromtimestamp(self.expires, tz=timezone.utc).strftime("%Y-%m-%d") if self.expires else "?"
+        return (
+            f"LicenseKey(key={self.key!r}, product_id={self.product_id}, "
+            f"expires={exp}, machines={len(self.activated_machines)}/{self.max_no_of_machines})"
+        )
+
+
+def _load_public_key(key_str: str):
+    """Carga una clave pública RSA desde PEM o XML (.NET)."""
+    key_str = key_str.strip()
+    if "BEGIN PUBLIC KEY" in key_str:
+        return serialization.load_pem_public_key(key_str.encode(), backend=default_backend())
+    if "<RSAKeyValue>" in key_str:
+        import re
+        m = re.search(r"<Modulus>([^<]+)</Modulus>", key_str)
+        e = re.search(r"<Exponent>([^<]+)</Exponent>", key_str)
+        if not m or not e:
+            raise ValueError("Invalid XML RSA key")
+        modulus = int.from_bytes(base64.b64decode(m.group(1)), "big")
+        exponent = int.from_bytes(base64.b64decode(e.group(1)), "big")
+        return rsa.RSAPublicNumbers(exponent, modulus).public_key(default_backend())
+    raise ValueError("Unrecognized public key format (use PEM or XML)")
+
+
+def _from_dict(d: dict) -> LicenseKey:
+    """Construye LicenseKey desde dict camelCase o PascalCase."""
+    def g(*keys, default=None):
+        for k in keys:
+            if k in d:
+                return d[k]
+        return default
+
+    customer = None
+    c = g("customer", "Customer")
+    if isinstance(c, dict):
+        customer = Customer(
+            id=c.get("id", c.get("Id", 0)),
+            name=c.get("name", c.get("Name", "")),
+            email=c.get("email", c.get("Email", "")),
+            company_name=c.get("companyName", c.get("CompanyName", "")),
+        )
+
+    machines = []
+    for m in g("activatedMachines", "ActivatedMachines", default=[]) or []:
+        machines.append(ActivatedMachine(
+            mid=m.get("mid", m.get("Mid", "")),
+            ip=m.get("ip", m.get("IP", "")),
+            time=int(m.get("time", m.get("Time", 0)) or 0),
+            friendly_name=m.get("friendlyName", m.get("FriendlyName", "")),
+            floating_expires=int(m.get("floatingExpires", m.get("FloatingExpires", 0)) or 0),
+        ))
+
+    data_objects = []
+    for o in g("dataObjects", "DataObjects", default=[]) or []:
+        data_objects.append(DataObject(
+            id=o.get("id", o.get("Id", 0)),
+            name=o.get("name", o.get("Name", "")),
+            string_value=o.get("stringValue", o.get("StringValue", "")),
+            int_value=int(o.get("intValue", o.get("IntValue", 0)) or 0),
+        ))
+
+    return LicenseKey(
+        product_id=int(g("productId", "ProductId", default=0) or 0),
+        id=int(g("id", "ID", default=0) or 0),
+        key=g("key", "Key", default="") or "",
+        created=int(g("created", "Created", default=0) or 0),
+        expires=int(g("expires", "Expires", default=0) or 0),
+        period=int(g("period", "Period", default=0) or 0),
+        f1=bool(g("f1", "F1", default=False)),
+        f2=bool(g("f2", "F2", default=False)),
+        f3=bool(g("f3", "F3", default=False)),
+        f4=bool(g("f4", "F4", default=False)),
+        f5=bool(g("f5", "F5", default=False)),
+        f6=bool(g("f6", "F6", default=False)),
+        f7=bool(g("f7", "F7", default=False)),
+        f8=bool(g("f8", "F8", default=False)),
+        notes=g("notes", "Notes", default="") or "",
+        block=bool(g("block", "Block", default=False)),
+        global_id=int(g("globalId", "GlobalId", default=0) or 0),
+        customer=customer,
+        activated_machines=machines,
+        trial_activation=bool(g("trialActivation", "TrialActivation", default=False)),
+        max_no_of_machines=int(g("maxNoOfMachines", "MaxNoOfMachines", default=0) or 0),
+        offline_mode=g("offlineMode", "OfflineMode", default="FloatingLease") or "FloatingLease",
+        allowed_machines=g("allowedMachines", "AllowedMachines", default="") or "",
+        data_objects=data_objects,
+        sign_date=int(g("signDate", "SignDate", default=0) or 0),
+    )

devkanan-0.2.0/devkanan.egg-info/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: devkanan
+Version: 0.2.0
+Summary: Cliente Python para DevKanan — validación local + API online de licencias firmadas RSA
+Author-email: Vilchis <vilchislalo98@gmail.com>
+License: Apache-2.0
+Project-URL: Homepage, https://devkanan.dev
+Keywords: license,licensing,rsa,drm,devkanan,kanan
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cryptography>=41.0.0
+Requires-Dist: requests>=2.28.0
+Dynamic: license-file
+
+# qustomlicensing
+
+Cliente Python ligero para validar archivos de licencia `.dat` firmados con RSA, emitidos por **LicensingServer** SaaS o QustomLicenseServer.
+
+API estilo Cryptolens — fácil migración si vienes de su SDK.
+
+## Instalación
+
+```bash
+pip install qustomlicensing
+```
+
+O para desarrollo:
+```bash
+pip install -e .
+```
+
+## Uso básico
+
+```python
+from qustomlicensing import LicenseKey, Helpers
+
+# Clave pública RSA del tenant (XML o PEM)
+RSA_PUB_KEY = """-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA...
+-----END PUBLIC KEY-----"""
+
+# Obtener machine code de esta PC
+machine_code = Helpers.GetMachineCode(v=2)
+
+# Leer y validar .dat
+with open("license.dat", "r", encoding="utf-8-sig") as f:
+    license_key = LicenseKey.load_from_string(RSA_PUB_KEY, f.read(), max_age_days=1)
+
+if license_key is None:
+    print("Licencia invalida o firma corrupta")
+    exit(1)
+
+# Verificar esta máquina
+if not license_key.is_on_right_machine(machine_code):
+    print("Esta maquina no esta autorizada")
+    exit(1)
+
+# Verificar features
+if license_key.F1:
+    print("Feature Pro activado")
+
+print(f"Licencia valida hasta {license_key.expires}")
+```
+
+## API
+
+### `Helpers.GetMachineCode(v=2)`
+Genera un machine code único basado en propiedades del hardware. `v=2` es el algoritmo actual (SHA-256 sobre identificadores).
+
+### `LicenseKey.load_from_string(rsa_pub_key, content, max_age_days=0)`
+Parsea un `.dat` JSON, verifica firma RSA y freshness.
+
+| Parámetro | Tipo | Descripción |
+|---|---|---|
+| `rsa_pub_key` | str | XML (.NET) o PEM. Auto-detecta. |
+| `content` | str | Contenido del archivo `.dat` |
+| `max_age_days` | int | Máx. días desde `signDate`. 0 = ilimitado o usa el del `.dat`. |
+
+Devuelve un objeto `LicenseKey` o `None` si la validación falla.
+
+### Atributos de `LicenseKey`
+| Atributo | Tipo |
+|---|---|
+| `product_id`, `id`, `key`, `notes` | datos básicos |
+| `created`, `expires`, `sign_date` | datetimes UTC |
+| `period`, `max_no_of_machines`, `max_offline_days` | enteros |
+| `F1`..`F8`, `block`, `trial_activation` | flags |
+| `activated_machines` | List[ActivatedMachine] |
+| `data_objects` | List[DataObject] |
+| `customer` | Customer o None |
+| `offline_mode` | str (FloatingLease/FloatingManual/Locked) |
+
+### `license_key.is_on_right_machine(machine_code)`
+Verifica que el machine code esté en `activatedMachines`.
+
+### `license_key.has_not_expired()`
+Verifica que `expires > now`.
+
+### `license_key.has_feature(n)`
+Atajo para `getattr(license_key, f'F{n}')`.
+
+## Comparación con SDK Cryptolens
+
+| | Cryptolens SDK | qustomlicensing |
+|---|---|---|
+| Activate online | ✅ | ❌ (usa requests directamente) |
+| Validar .skm/.dat offline | ✅ | ✅ |
+| `Helpers.GetMachineCode` | ✅ | ✅ (compatible) |
+| `LicenseKey.load_from_string` | ✅ | ✅ (compatible) |
+| Tamaño | ~2 MB con deps | ~50 KB |
+| Dependencias | `pycryptodome`, `requests` | solo `cryptography` |
+
+## Licencia
+
+Apache-2.0. Basado en código del SDK de Cryptolens (también Apache-2.0).

devkanan-0.2.0/devkanan.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+devkanan/__init__.py
+devkanan/helpers.py
+devkanan/key.py
+devkanan/license_key.py
+devkanan.egg-info/PKG-INFO
+devkanan.egg-info/SOURCES.txt
+devkanan.egg-info/dependency_links.txt
+devkanan.egg-info/requires.txt
+devkanan.egg-info/top_level.txt

devkanan-0.2.0/devkanan.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

devkanan-0.2.0/devkanan.egg-info/requires.txt

@@ -0,0 +1,2 @@
+cryptography>=41.0.0
+requests>=2.28.0

devkanan-0.2.0/devkanan.egg-info/top_level.txt

@@ -0,0 +1 @@
+devkanan

devkanan-0.2.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "devkanan"
+version = "0.2.0"
+description = "Cliente Python para DevKanan — validación local + API online de licencias firmadas RSA"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "Apache-2.0" }
+authors = [
+    { name = "Vilchis", email = "vilchislalo98@gmail.com" }
+]
+keywords = ["license", "licensing", "rsa", "drm", "devkanan", "kanan"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "cryptography>=41.0.0",
+    "requests>=2.28.0",
+]
+
+[project.urls]
+Homepage = "https://devkanan.dev"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["devkanan*"]

devkanan-0.2.0/setup.cfg

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