zerodev-kora 1.0.0__py3-none-any.whl

kora/__init__.py

@@ -0,0 +1,8 @@
+from .client import Client
+from .signature import Signature
+from .machine import Machine
+from .heartbeat import Heartbeat
+from .offline import Offline
+from .types import ValidationResponse
+
+__all__ = ["Client", "Signature", "Machine", "Heartbeat", "Offline", "ValidationResponse"]

kora/client.py

@@ -0,0 +1,98 @@
+import json
+from typing import Optional, Dict, Any
+import requests
+
+from .signature import Signature
+from .machine import Machine
+from .heartbeat import Heartbeat
+from .offline import Offline
+from .types import ValidationResponse
+
+class Client:
+    def __init__(
+        self,
+        url: str,
+        product: str,
+        key: Optional[str] = None,
+        public_key: Optional[str] = None,
+        signature_header: str = "x-kora-signature",
+        heartbeat_interval_sec: float = 0.0,
+        machine_id: Optional[str] = None
+    ):
+        self.url = url.rstrip("/")
+        self.product = product
+        self.key = key
+        self.public_key = public_key
+        self.signature_header = signature_header
+        self.heartbeat_interval_sec = heartbeat_interval_sec
+        self.machine_id = machine_id
+        self.signature_handler = Signature()
+        self.machine_handler = Machine()
+        self.offline_handler = Offline()
+        self.heartbeat_runner = None
+        self.session_token = None
+
+    def token(self) -> Optional[str]:
+        return self.session_token
+
+    def hwid(self) -> str:
+        if self.machine_id:
+            return self.machine_id
+        return self.machine_handler.hwid()
+
+    def offline(self) -> Offline:
+        return self.offline_handler
+
+    def validate(self, custom_key: Optional[str] = None, extra: Optional[Dict[str, Any]] = None) -> ValidationResponse:
+        target_key = custom_key if custom_key else self.key
+        if not target_key:
+            raise ValueError("License key is required")
+
+        payload = {
+            "license_key": target_key,
+            "product_name": self.product,
+            "hwid": self.hwid(),
+            "identifier": self.hwid()
+        }
+        if self.session_token:
+            payload["session_id"] = self.session_token
+        if extra:
+            payload.update(extra)
+
+        target_url = f"{self.url}/licenses/validate"
+        response = requests.post(target_url, json=payload, headers={"Accept": "application/json"}, timeout=15)
+        text = response.text
+
+        if self.public_key:
+            sig = response.headers.get(self.signature_header)
+            if not sig or not self.signature_handler.verify(text, sig, self.public_key):
+                raise ValueError("Response signature verification failed")
+
+        data = response.json()
+        session_info = data.get("session")
+        session_token = session_info.get("token") if isinstance(session_info, dict) else None
+        if session_token:
+            self.session_token = session_token
+            if self.heartbeat_interval_sec > 0 and self.heartbeat_runner is None:
+                self.heartbeat_runner = Heartbeat(self.heartbeat_interval_sec, lambda: self.validate(target_key))
+                self.heartbeat_runner.start()
+
+        return ValidationResponse(
+            valid=data.get("valid", False),
+            message=data.get("message", ""),
+            product=data.get("product"),
+            user=data.get("user"),
+            status=data.get("status"),
+            expires_at=data.get("expires_at"),
+            addons=data.get("addons"),
+            nonce=data.get("nonce"),
+            timestamp=data.get("timestamp"),
+            variables=data.get("variables"),
+            user_variables=data.get("user_variables"),
+            session_token=session_token
+        )
+
+    def stop(self) -> None:
+        if self.heartbeat_runner is not None:
+            self.heartbeat_runner.stop()
+            self.heartbeat_runner = None

kora/heartbeat.py

@@ -0,0 +1,29 @@
+import threading
+from typing import Callable
+
+class Heartbeat:
+    def __init__(self, interval_sec: float, ping: Callable[[], None]):
+        self.interval_sec = interval_sec
+        self.ping = ping
+        self.stop_event = threading.Event()
+        self.thread = None
+
+    def start(self) -> None:
+        if self.thread is not None and self.thread.is_alive():
+            return
+        self.stop_event.clear()
+        self.thread = threading.Thread(target=self._run, daemon=True)
+        self.thread.start()
+
+    def _run(self) -> None:
+        while not self.stop_event.wait(self.interval_sec):
+            try:
+                self.ping()
+            except Exception:
+                pass
+
+    def stop(self) -> None:
+        if self.thread is None:
+            return
+        self.stop_event.set()
+        self.thread = None

kora/machine.py

@@ -0,0 +1,16 @@
+import uuid
+import platform
+import hashlib
+
+class Machine:
+    def mac(self) -> str:
+        mac_int = uuid.getnode()
+        return ":".join(f"{(mac_int >> ele) & 0xff:02x}" for ele in range(40, -1, -8))
+
+    def hwid(self) -> str:
+        h = hashlib.sha256()
+        h.update(platform.system().encode("utf-8"))
+        h.update(platform.machine().encode("utf-8"))
+        h.update(platform.node().encode("utf-8"))
+        h.update(self.mac().encode("utf-8"))
+        return h.hexdigest()

kora/offline.py

@@ -0,0 +1,27 @@
+import json
+import time
+from typing import Optional, Dict, Any
+from .signature import Signature
+
+class Offline:
+    def __init__(self):
+        self.signature = Signature()
+
+    def verify(self, content: str, public_key_pem: str) -> Optional[Dict[str, Any]]:
+        try:
+            data = json.loads(content)
+            if "signature" not in data or "expires_at" not in data:
+                return None
+            sig = data["signature"]
+            copy_data = dict(data)
+            del copy_data["signature"]
+            serialized = json.dumps(copy_data, separators=(",", ":"), sort_keys=True)
+            if not self.signature.verify(serialized, sig, public_key_pem):
+                return None
+            now_ms = int(time.time() * 1000)
+            allowed_until = data["expires_at"] + data.get("grace_period_ms", 0)
+            if now_ms > allowed_until:
+                return None
+            return data
+        except Exception:
+            return None

kora/signature.py

@@ -0,0 +1,13 @@
+import base64
+from cryptography.hazmat.primitives.serialization import load_pem_public_key
+from cryptography.exceptions import InvalidSignature
+
+class Signature:
+    def verify(self, body: str, signature_base64: str, public_key_pem: str) -> bool:
+        try:
+            key = load_pem_public_key(public_key_pem.encode("utf-8"))
+            signature = base64.b64decode(signature_base64)
+            key.verify(signature, body.encode("utf-8"))
+            return True
+        except (InvalidSignature, Exception):
+            return False

kora/types.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+from typing import Optional, Dict, Any, List
+
+@dataclass
+class ValidationResponse:
+    valid: bool
+    message: str
+    product: Optional[str] = None
+    user: Optional[str] = None
+    status: Optional[str] = None
+    expires_at: Optional[str] = None
+    addons: Optional[List[str]] = None
+    nonce: Optional[str] = None
+    timestamp: Optional[int] = None
+    variables: Optional[Dict[str, Any]] = None
+    user_variables: Optional[Dict[str, Any]] = None
+    session_token: Optional[str] = None

zerodev_kora-1.0.0.dist-info/METADATA

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: zerodev-kora
+Version: 1.0.0
+Summary: Official Python SDK for Kora licensing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=41.0.0
+Requires-Dist: requests>=2.31.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+
+# zerodev-kora
+
+Official Python SDK for Kora licensing.
+
+## Installation
+
+```bash
+pip install zerodev-kora
+```
+
+## Usage
+
+```python
+from kora import KoraClient
+
+client = KoraClient(
+    server_url="https://api.yourdomain.com",
+    product="MySoftware",
+    public_key="-----BEGIN PUBLIC KEY-----\n..."
+)
+
+result = client.validate("XXXXX-XXXXX-XXXXX-XXXXX")
+if result.valid:
+    print(f"License valid for: {result.user}")
+else:
+    print(f"Validation failed: {result.message}")
+```
+
+## Offline Verification
+
+```python
+offline = client.verify_offline(signed_offline_token)
+if offline.valid:
+    print("Offline license is valid!")
+```

zerodev_kora-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+kora/__init__.py,sha256=QHaQJasFkOIUyBJXGNCf-2wHZz0T4e1BcgcE_6BRKTQ,281
+kora/client.py,sha256=RQiOoMzIxcTGnVNoh4ccfBdA0aczttY_L9ZFpb_7LvI,3521
+kora/heartbeat.py,sha256=xnEk0QVRwqIqmX5EdmEvShO7N_APoHDkdNPnn217tEY,834
+kora/machine.py,sha256=oenKnRfUmBCt7Ud8m1VOmuI0MhD4YP5tp37YG34l7g0,491
+kora/offline.py,sha256=9ex-G5i6YwFL_3m8xkkjjDtpdKS4O6JO69JhSn59s1w,972
+kora/signature.py,sha256=ztUf_7ZKrUMkCjgAMJ5HjmyuQ8vkrpo-pIsTu6fnXfc,540
+kora/types.py,sha256=-QhVXlCif3pxgeM-MoTiSTBYo4gSmJml1_83J5Tx6go,531
+zerodev_kora-1.0.0.dist-info/METADATA,sha256=tw06xzr2ulP1y79iQyJQrPKapZxqxGAZb6Lk0HvuAzI,933
+zerodev_kora-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+zerodev_kora-1.0.0.dist-info/top_level.txt,sha256=6ce2HiMBAqXR9oVFQg2DdRVGDHWahWin31Nrxwj7yjE,5
+zerodev_kora-1.0.0.dist-info/RECORD,,

zerodev_kora-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

zerodev_kora-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+kora