authforge-sdk 1.0.2__tar.gz → 1.0.4__tar.gz

{authforge_sdk-1.0.2/authforge_sdk.egg-info → authforge_sdk-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: authforge-sdk
-Version: 1.0.2
+Version: 1.0.4
 Summary: Official Python SDK for AuthForge — credit-based license key authentication with Ed25519-verified responses.
 Author: AuthForge
 License: MIT
@@ -94,7 +94,7 @@ client = AuthForgeClient(
 
 ## Billing
 
-- **1 `login()` call = 1 credit** (one `/auth/validate` debit).
+- **1 `login()` or `validate_license()` call = 1 credit** (one `/auth/validate` debit each).
 - **10 heartbeats on the same license = 1 credit** (billed every 10th successful heartbeat).
 
 A desktop app running 6h/day at a 15-minute interval burns ~3–4 credits/day. A server app running 24/7 at a 1-minute interval burns ~145 credits/day — pick the interval based on how fast you need revocations to propagate (they always land on the **next** heartbeat).
@@ -104,6 +104,7 @@ A desktop app running 6h/day at a 15-minute interval burns ~3–4 credits/day. A
 | Method | Returns | Description |
 |---|---|---|
 | `login(license_key)` | `bool` | Validates key and stores signed session (`sessionToken`, `expiresIn`, `appVariables`, `licenseVariables`) |
+| `validate_license(license_key)` | `ValidateLicenseResult` | Same `/auth/validate` + signatures as `login`; does not store session or start heartbeats; returns a dict with `valid` / `code` and **never** calls `on_failure` or `os._exit` |
 | `self_ban(...)` | `dict` | Requests `/auth/selfban` to blacklist HWID/IP and optionally revoke (session-authenticated only) |
 | `logout()` | `None` | Stops heartbeat and clears all session/auth state |
 | `is_authenticated()` | `bool` | True when an active authenticated session exists |
@@ -121,6 +122,8 @@ A desktop app running 6h/day at a 15-minute interval burns ~3–4 credits/day. A
 
 If authentication fails (login rejected, heartbeat fails, signature mismatch, etc.), the SDK calls your `on_failure` callback if one is provided. If no callback is set, **the SDK calls `os._exit(1)` to terminate the process.** This is intentional — it prevents your app from running without a valid license.
 
+**`validate_license()`** does not trigger `on_failure` or `os._exit` — check `result["valid"]` and `result["code"]`.
+
 Recognized server errors:
 `invalid_app`, `invalid_key`, `expired`, `revoked`, `hwid_mismatch`, `no_credits`, `blocked`, `rate_limited`, `replay_detected`, `app_disabled`, `session_expired`, `revoke_requires_session`, `bad_request`
 

{authforge_sdk-1.0.2 → authforge_sdk-1.0.4}/README.md

@@ -67,7 +67,7 @@ client = AuthForgeClient(
 
 ## Billing
 
-- **1 `login()` call = 1 credit** (one `/auth/validate` debit).
+- **1 `login()` or `validate_license()` call = 1 credit** (one `/auth/validate` debit each).
 - **10 heartbeats on the same license = 1 credit** (billed every 10th successful heartbeat).
 
 A desktop app running 6h/day at a 15-minute interval burns ~3–4 credits/day. A server app running 24/7 at a 1-minute interval burns ~145 credits/day — pick the interval based on how fast you need revocations to propagate (they always land on the **next** heartbeat).
@@ -77,6 +77,7 @@ A desktop app running 6h/day at a 15-minute interval burns ~3–4 credits/day. A
 | Method | Returns | Description |
 |---|---|---|
 | `login(license_key)` | `bool` | Validates key and stores signed session (`sessionToken`, `expiresIn`, `appVariables`, `licenseVariables`) |
+| `validate_license(license_key)` | `ValidateLicenseResult` | Same `/auth/validate` + signatures as `login`; does not store session or start heartbeats; returns a dict with `valid` / `code` and **never** calls `on_failure` or `os._exit` |
 | `self_ban(...)` | `dict` | Requests `/auth/selfban` to blacklist HWID/IP and optionally revoke (session-authenticated only) |
 | `logout()` | `None` | Stops heartbeat and clears all session/auth state |
 | `is_authenticated()` | `bool` | True when an active authenticated session exists |
@@ -94,6 +95,8 @@ A desktop app running 6h/day at a 15-minute interval burns ~3–4 credits/day. A
 
 If authentication fails (login rejected, heartbeat fails, signature mismatch, etc.), the SDK calls your `on_failure` callback if one is provided. If no callback is set, **the SDK calls `os._exit(1)` to terminate the process.** This is intentional — it prevents your app from running without a valid license.
 
+**`validate_license()`** does not trigger `on_failure` or `os._exit` — check `result["valid"]` and `result["code"]`.
+
 Recognized server errors:
 `invalid_app`, `invalid_key`, `expired`, `revoked`, `hwid_mismatch`, `no_credits`, `blocked`, `rate_limited`, `replay_detected`, `app_disabled`, `session_expired`, `revoke_requires_session`, `bad_request`
 

{authforge_sdk-1.0.2 → authforge_sdk-1.0.4}/authforge.py

@@ -11,14 +11,36 @@ import time
 import urllib.error
 import urllib.request
 import uuid
-from typing import Any, Callable, Dict, Optional
+from typing import Any, Callable, Dict, Iterable, List, Literal, Optional, Sequence, TypedDict, Union
 from cryptography.exceptions import InvalidSignature
 from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
 
 
+PublicKeyArg = Union[str, Sequence[str]]
+
+
 DEFAULT_API_BASE_URL = "https://auth.authforge.cc"
 RATE_LIMIT_RETRY_DELAYS = (2, 5)
 NETWORK_RETRY_DELAY = 2
+class ValidateLicenseSuccess(TypedDict):
+    valid: Literal[True]
+    session_token: str
+    expires_in: int
+    session_data: Dict[str, Any]
+    app_variables: Optional[Dict[str, Any]]
+    license_variables: Optional[Dict[str, Any]]
+    key_id: Optional[str]
+
+
+class ValidateLicenseFailure(TypedDict):
+    valid: Literal[False]
+    code: str
+    error: str
+
+
+ValidateLicenseResult = Union[ValidateLicenseSuccess, ValidateLicenseFailure]
+
+
 KNOWN_SERVER_ERRORS = {
     "invalid_app",
     "invalid_key",
@@ -43,7 +65,7 @@ class AuthForgeClient:
         self,
         app_id: str,
         app_secret: str,
-        public_key: str,
+        public_key: PublicKeyArg,
         heartbeat_mode: str,
         heartbeat_interval: int = 900,
         api_base_url: str = DEFAULT_API_BASE_URL,
@@ -56,8 +78,11 @@ class AuthForgeClient:
             raise ValueError("app_id must be a non-empty string")
         if not app_secret or not isinstance(app_secret, str):
             raise ValueError("app_secret must be a non-empty string")
-        if not public_key or not isinstance(public_key, str):
-            raise ValueError("public_key must be a non-empty base64 string")
+        public_key_list = self._normalize_public_key_list(public_key)
+        if not public_key_list:
+            raise ValueError(
+                "public_key must be a non-empty base64 string or list of base64 strings"
+            )
         mode = (heartbeat_mode or "").upper()
         if mode not in {"LOCAL", "SERVER"}:
             raise ValueError("heartbeat_mode must be LOCAL or SERVER")
@@ -66,7 +91,11 @@ class AuthForgeClient:
 
         self.app_id = app_id
         self.app_secret = app_secret
-        self.public_key = public_key
+        # `public_key` is the historical public attribute. We now hold the
+        # full trust list to support key rotation, but expose the first entry
+        # as `public_key` for callers that read it directly.
+        self.public_keys: List[str] = public_key_list
+        self.public_key = public_key_list[0]
         self.heartbeat_mode = mode
         self.heartbeat_interval = int(heartbeat_interval)
         self.api_base_url = api_base_url.rstrip("/")
@@ -95,7 +124,9 @@ class AuthForgeClient:
         self._license_variables: Optional[Dict[str, Any]] = None
         self._authenticated = False
         self._hwid = self._resolve_hwid(hwid_override)
-        self._ed25519_public_key = self._load_public_key(public_key)
+        self._ed25519_public_keys: List[Ed25519PublicKey] = [
+            self._load_public_key(k) for k in public_key_list
+        ]
 
     def login(self, license_key: str) -> bool:
         if not license_key or not isinstance(license_key, str):
@@ -109,6 +140,36 @@ class AuthForgeClient:
             self._fail("login_failed", exc)
             return False
 
+    def validate_license(self, license_key: str) -> ValidateLicenseResult:
+        """Validate like :meth:`login` (same /auth/validate + signatures) without storing
+        session state or starting the heartbeat thread."""
+        if not license_key or not isinstance(license_key, str):
+            raise ValueError("license_key must be a non-empty string")
+        try:
+            body: Dict[str, Any] = {
+                "appId": self.app_id,
+                "appSecret": self.app_secret,
+                "licenseKey": license_key,
+                "hwid": self._hwid,
+                "nonce": self._generate_nonce(),
+            }
+            if self.ttl_seconds is not None:
+                body["ttlSeconds"] = self.ttl_seconds
+            response_obj = self._post_json("/auth/validate", body, skip_failure_hook=True)
+            expected_nonce = str(body.get("nonce", "")).strip()
+            parsed = self._parse_validate_success(response_obj, expected_nonce)
+            return {
+                "valid": True,
+                "session_token": parsed["session_token"],
+                "expires_in": parsed["expires_in"],
+                "session_data": parsed["session_data"],
+                "app_variables": parsed["app_variables"],
+                "license_variables": parsed["license_variables"],
+                "key_id": parsed["key_id"],
+            }
+        except Exception as exc:
+            return {"valid": False, "code": str(exc), "error": str(exc)}
+
     def self_ban(
         self,
         *,
@@ -250,13 +311,9 @@ class AuthForgeClient:
             context="validate",
         )
 
-    def _apply_signed_response(
-        self,
-        response_obj: Dict[str, Any],
-        expected_nonce: str,
-        license_key: Optional[str],
-        context: str,
-    ) -> None:
+    def _parse_validate_success(
+        self, response_obj: Dict[str, Any], expected_nonce: str
+    ) -> Dict[str, Any]:
         status = response_obj.get("status")
         if not self._is_success_status(status):
             error_code = self._extract_server_error(response_obj)
@@ -288,21 +345,46 @@ class AuthForgeClient:
         if expires_in is None:
             raise ValueError("missing_expiresIn")
 
+        return {
+            "session_token": session_token,
+            "expires_in": int(expires_in),
+            "session_data": dict(payload_json),
+            "app_variables": self._extract_optional_map(payload_json.get("appVariables")),
+            "license_variables": self._extract_optional_map(
+                payload_json.get("licenseVariables")
+            ),
+            "key_id": key_id if isinstance(key_id, str) else None,
+            "raw_payload_b64": raw_payload_b64,
+            "signature": signature,
+        }
+
+    def _apply_signed_response(
+        self,
+        response_obj: Dict[str, Any],
+        expected_nonce: str,
+        license_key: Optional[str],
+        context: str,
+    ) -> None:
+        parsed = self._parse_validate_success(response_obj, expected_nonce)
+        _ = context
+
         with self._lock:
             if license_key is not None:
                 self._license_key = license_key
-            self._session_token = session_token
-            self._session_expires_in = int(expires_in)
+            self._session_token = parsed["session_token"]
+            self._session_expires_in = int(parsed["expires_in"])
             self._last_nonce = expected_nonce
-            self._raw_payload_b64 = raw_payload_b64
-            self._signature = signature
-            self._key_id = key_id
-            self._session_data = dict(payload_json)
-            self._app_variables = self._extract_optional_map(payload_json.get("appVariables"))
-            self._license_variables = self._extract_optional_map(payload_json.get("licenseVariables"))
+            self._raw_payload_b64 = parsed["raw_payload_b64"]
+            self._signature = parsed["signature"]
+            self._key_id = parsed["key_id"]
+            self._session_data = dict(parsed["session_data"])
+            self._app_variables = parsed["app_variables"]
+            self._license_variables = parsed["license_variables"]
             self._authenticated = True
 
-    def _post_json(self, path: str, data: Dict[str, Any]) -> Dict[str, Any]:
+    def _post_json(
+        self, path: str, data: Dict[str, Any], *, skip_failure_hook: bool = False
+    ) -> Dict[str, Any]:
         url = f"{self.api_base_url}{path}"
         body = dict(data)
         rate_attempt = 0
@@ -342,7 +424,8 @@ class AuthForgeClient:
                         network_attempt += 1
                         time.sleep(NETWORK_RETRY_DELAY)
                         continue
-                    self._fail("network_error", exc)
+                    if not skip_failure_hook:
+                        self._fail("network_error", exc)
                     raise RuntimeError(f"url_error: {exc}") from exc
 
             is_rate_limited = (
@@ -483,13 +566,42 @@ class AuthForgeClient:
             )
         except Exception as exc:
             raise ValueError("invalid_signature_encoding") from exc
-        try:
-            self._ed25519_public_key.verify(
-                signature_bytes,
-                raw_payload_b64.encode("utf-8"),
-            )
-        except InvalidSignature as exc:
-            raise ValueError("signature_mismatch") from exc
+        # During a key rotation the SDK may be pinned to the previous key
+        # while a new server-side key signs responses (or vice-versa). Trust
+        # any key in the configured list.
+        payload_bytes = raw_payload_b64.encode("utf-8")
+        for key in self._ed25519_public_keys:
+            try:
+                key.verify(signature_bytes, payload_bytes)
+                return
+            except InvalidSignature:
+                continue
+        raise ValueError("signature_mismatch")
+
+    @staticmethod
+    def _normalize_public_key_list(value: PublicKeyArg) -> List[str]:
+        """Coerce the public_key constructor arg to a list of base64 strings.
+
+        Accepts:
+          - "abc..."                     single-key historical contract
+          - ["abc...", "def..."]         current first, previous after
+          - "abc...,def..."              env-var convenience form
+        """
+        keys: List[str] = []
+        candidates: Iterable[Any]
+        if isinstance(value, str):
+            candidates = value.split(",") if "," in value else [value]
+        elif isinstance(value, Sequence):
+            candidates = value
+        else:
+            return []
+        for entry in candidates:
+            if not isinstance(entry, str):
+                continue
+            trimmed = entry.strip()
+            if trimmed:
+                keys.append(trimmed)
+        return keys
 
     def _generate_nonce(self) -> str:
         return secrets.token_hex(16)

{authforge_sdk-1.0.2 → authforge_sdk-1.0.4/authforge_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: authforge-sdk
-Version: 1.0.2
+Version: 1.0.4
 Summary: Official Python SDK for AuthForge — credit-based license key authentication with Ed25519-verified responses.
 Author: AuthForge
 License: MIT
@@ -94,7 +94,7 @@ client = AuthForgeClient(
 
 ## Billing
 
-- **1 `login()` call = 1 credit** (one `/auth/validate` debit).
+- **1 `login()` or `validate_license()` call = 1 credit** (one `/auth/validate` debit each).
 - **10 heartbeats on the same license = 1 credit** (billed every 10th successful heartbeat).
 
 A desktop app running 6h/day at a 15-minute interval burns ~3–4 credits/day. A server app running 24/7 at a 1-minute interval burns ~145 credits/day — pick the interval based on how fast you need revocations to propagate (they always land on the **next** heartbeat).
@@ -104,6 +104,7 @@ A desktop app running 6h/day at a 15-minute interval burns ~3–4 credits/day. A
 | Method | Returns | Description |
 |---|---|---|
 | `login(license_key)` | `bool` | Validates key and stores signed session (`sessionToken`, `expiresIn`, `appVariables`, `licenseVariables`) |
+| `validate_license(license_key)` | `ValidateLicenseResult` | Same `/auth/validate` + signatures as `login`; does not store session or start heartbeats; returns a dict with `valid` / `code` and **never** calls `on_failure` or `os._exit` |
 | `self_ban(...)` | `dict` | Requests `/auth/selfban` to blacklist HWID/IP and optionally revoke (session-authenticated only) |
 | `logout()` | `None` | Stops heartbeat and clears all session/auth state |
 | `is_authenticated()` | `bool` | True when an active authenticated session exists |
@@ -121,6 +122,8 @@ A desktop app running 6h/day at a 15-minute interval burns ~3–4 credits/day. A
 
 If authentication fails (login rejected, heartbeat fails, signature mismatch, etc.), the SDK calls your `on_failure` callback if one is provided. If no callback is set, **the SDK calls `os._exit(1)` to terminate the process.** This is intentional — it prevents your app from running without a valid license.
 
+**`validate_license()`** does not trigger `on_failure` or `os._exit` — check `result["valid"]` and `result["code"]`.
+
 Recognized server errors:
 `invalid_app`, `invalid_key`, `expired`, `revoked`, `hwid_mismatch`, `no_credits`, `blocked`, `rate_limited`, `replay_detected`, `app_disabled`, `session_expired`, `revoke_requires_session`, `bad_request`
 

{authforge_sdk-1.0.2 → authforge_sdk-1.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "authforge-sdk"
-version = "1.0.2"
+version = "1.0.4"
 description = "Official Python SDK for AuthForge — credit-based license key authentication with Ed25519-verified responses."
 readme = "README.md"
 requires-python = ">=3.9"