authguard-sdk 1.0.0__py3-none-any.whl

authguard_sdk/__init__.py

@@ -0,0 +1,14 @@
+"""AuthGuard client SDK for Python.
+
+Example:
+    from authguard_sdk import AuthGuard, AuthGuardError
+
+    app = AuthGuard(app_id="...", version="1.0", public_key="...")
+    app.init()
+    app.license("XXXX-XXXX-XXXX-XXXX")
+"""
+
+from .client import AuthGuard, AuthGuardError, get_hwid
+
+__all__ = ["AuthGuard", "AuthGuardError", "get_hwid"]
+__version__ = "1.0.0"

authguard_sdk/client.py

@@ -0,0 +1,103 @@
+"""AuthGuard client SDK for Python."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import platform
+import secrets
+import subprocess
+import time
+import uuid
+from typing import Any
+
+import requests
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+
+
+class AuthGuardError(Exception):
+    def __init__(self, message: str, response: dict[str, Any] | None = None) -> None:
+        super().__init__(message)
+        self.response: dict[str, Any] = response or {}
+
+
+def get_hwid() -> str:
+    raw = ""
+    try:
+        if platform.system() == "Windows":
+            import winreg
+
+            with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Microsoft\Cryptography", 0, winreg.KEY_READ | winreg.KEY_WOW64_64KEY) as k:
+                raw = winreg.QueryValueEx(k, "MachineGuid")[0]
+        elif platform.system() == "Darwin":
+            out = subprocess.check_output(["ioreg", "-rd1", "-c", "IOPlatformExpertDevice"], text=True)
+            raw = next(line.split('"')[-2] for line in out.splitlines() if "IOPlatformUUID" in line)
+        else:
+            with open("/etc/machine-id") as f:
+                raw = f.read().strip()
+    except Exception:
+        raw = str(uuid.getnode())
+    return hashlib.sha256(raw.encode()).hexdigest()
+
+
+class AuthGuard:
+    # Some hosts' firewalls block the default python-requests user agent, so send our own.
+    HEADERS = {"User-Agent": "AuthGuard-SDK/1.0"}
+
+    def __init__(self, app_id: str, version: str, public_key: str, url: str = "https://authguard.dk/api/client") -> None:
+        self.app_id = app_id
+        self.version = version
+        self.url = url
+        self.hwid = get_hwid()
+        self.session_id: str | None = None
+        self.info: dict[str, Any] = {}
+        self._key = Ed25519PublicKey.from_public_bytes(bytes.fromhex(public_key))
+
+    def _request(self, type_: str, **fields: Any) -> dict[str, Any]:
+        nonce = secrets.token_hex(16)
+        body = {"type": type_, "app_id": self.app_id, "nonce": nonce, **fields}
+        if self.session_id and type_ != "init":
+            body["sessionid"] = self.session_id
+        try:
+            r = requests.post(self.url, json=body, headers=self.HEADERS, timeout=15)
+            outer = r.json()
+            payload, signature = outer["payload"], outer["signature"]
+        except (requests.RequestException, ValueError, KeyError, TypeError) as e:
+            raise AuthGuardError(f"Could not reach the license server ({e.__class__.__name__})")
+        try:
+            self._key.verify(bytes.fromhex(signature), payload.encode())
+        except (InvalidSignature, ValueError):
+            raise AuthGuardError("Invalid server signature")
+        data = json.loads(payload)
+        if data.get("nonce") != nonce or abs(time.time() - data.get("timestamp", 0)) > 300:
+            raise AuthGuardError("Invalid server response")
+        if not data.get("success"):
+            raise AuthGuardError(data.get("message", "Request failed"), data)
+        return data
+
+    def init(self) -> None:
+        data = self._request("init", version=self.version, hwid=self.hwid)
+        self.session_id = data["sessionid"]
+
+    def license(self, key: str) -> dict[str, Any]:
+        self.info = self._request("license", key=key.strip(), hwid=self.hwid)["info"]
+        return self.info
+
+    def register(self, username: str, password: str, key: str) -> dict[str, Any]:
+        self.info = self._request("register", username=username, password=password, key=key.strip(), hwid=self.hwid)["info"]
+        return self.info
+
+    def login(self, username: str, password: str) -> dict[str, Any]:
+        self.info = self._request("login", username=username, password=password, hwid=self.hwid)["info"]
+        return self.info
+
+    def var(self, name: str) -> str:
+        return self._request("var", name=name)["value"]
+
+    def check(self) -> bool:
+        try:
+            self._request("check")
+            return True
+        except AuthGuardError:
+            return False

authguard_sdk-1.0.0.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.5
+Name: authguard-sdk
+Version: 1.0.0
+Summary: Client SDK for AuthGuard, a software licensing platform with Ed25519-signed responses
+Project-URL: Homepage, https://authguard.dk
+Project-URL: Documentation, https://authguard.dk/docs.php
+Author: AuthGuard
+License-Expression: MIT
+License-File: LICENSE
+Keywords: authguard,ed25519,keyauth,license-key,licensing
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: cryptography<47,>=43
+Requires-Dist: requests<3,>=2.32
+Description-Content-Type: text/markdown
+
+# AuthGuard Python SDK
+
+Client SDK for [AuthGuard](https://authguard.dk), a software licensing platform.
+It talks to a single signed endpoint and verifies every reply with Ed25519, so a
+tampered or replayed response is rejected before your code sees it.
+
+## Install
+
+```bash
+pip install authguard-sdk
+```
+
+## Usage
+
+Copy the app ID and public key from **Dashboard -> your app -> Settings**.
+
+```python
+import sys
+
+from authguard_sdk import AuthGuard, AuthGuardError
+
+app = AuthGuard(
+    app_id="YOUR_APP_ID",
+    version="1.0",
+    public_key="YOUR_PUBLIC_KEY",
+)
+
+try:
+    app.init()
+    app.license("XXXX-XXXX-XXXX-XXXX")
+except AuthGuardError as e:
+    if e.response.get("update_required"):
+        print("Update required. Download:", e.response.get("download_url"))
+    else:
+        print("Error:", e)
+    sys.exit(1)
+
+print("Access granted. Expires:", app.info.get("expires_at") or "never")
+```
+
+## API
+
+`AuthGuard(app_id, version, public_key, url="https://authguard.dk/api/client")`
+
+| Method | Purpose |
+| --- | --- |
+| `init()` | Open a session. Must be called first. Raises if the app is disabled or the version is out of date. |
+| `license(key)` | Authenticate with a licence key. Returns the `info` dict. |
+| `login(username, password)` | Authenticate an app user. Returns the `info` dict. |
+| `register(username, password, key)` | Create an app user from a licence key. Returns the `info` dict. |
+| `var(name)` | Read a server-side variable defined in the dashboard. |
+| `check()` | Re-validate the session later on. Returns `True` or `False`. |
+
+After a successful `license`, `login` or `register`, `app.info` holds the
+subscription details (`expires_at`, `username`, `hwid`, ...).
+
+Every failure raises `AuthGuardError`. Its `.response` attribute carries the
+server's decoded payload when there was one, which is how you detect
+`update_required` and read `download_url`.
+
+## Security notes
+
+- Responses are Ed25519-signed over the exact payload bytes; the signature is
+  verified before the payload is parsed.
+- Each request carries a random nonce that must be echoed back, and replies more
+  than five minutes from the local clock are rejected.
+- The app ID and public key are identifiers, not secrets. It is fine for them to
+  sit in your source.
+- The SDK sends a `User-Agent` of `AuthGuard-SDK/1.0`. Do not change it: some
+  hosting firewalls block the default `python-requests` user agent.
+
+Full documentation: <https://authguard.dk/docs.php>

authguard_sdk-1.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+authguard_sdk/__init__.py,sha256=zqWO1N__QQRib5VPANTPWyHAP3emMQJ00xei8qSw1sI,361
+authguard_sdk/client.py,sha256=sr0trDhuGZMLTAdsSSs4AltjdkFshfDkygU3HBSoeao,4072
+authguard_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+authguard_sdk-1.0.0.dist-info/METADATA,sha256=Nsn9pzNd6isyEywPskJEBRbVx8njGk0aojLVImBRLPc,3323
+authguard_sdk-1.0.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+authguard_sdk-1.0.0.dist-info/licenses/LICENSE,sha256=PYm9h5OLshu43fGAJA9lQ-Vjx8sIcoTADdWTpHbsMIg,1066
+authguard_sdk-1.0.0.dist-info/RECORD,,

authguard_sdk-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

authguard_sdk-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AuthGuard
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.