onewayswp 0.1.0__py3-none-any.whl

onewayswp/__init__.py

@@ -0,0 +1,36 @@
+from .admin import Admin
+from .client import Client
+from .info import info
+from .exceptions import (
+    OnewaySWPError,
+    InvalidTokenError,
+    ExpiredError,
+    ClockRollbackError,
+    SecurityError,
+    InvalidKeyError,
+    CorruptedFileError,
+    InsufficientCreditError,
+    FileLockedError,
+    PlatformNotSupportedError,
+    CoreLoadError,
+    NoActiveSessionError,
+)
+
+__version__ = "0.1.0"
+__all__ = [
+    "Admin",
+    "Client",
+    "info",
+    "OnewaySWPError",
+    "InvalidTokenError",
+    "ExpiredError",
+    "ClockRollbackError",
+    "SecurityError",
+    "InvalidKeyError",
+    "CorruptedFileError",
+    "InsufficientCreditError",
+    "FileLockedError",
+    "PlatformNotSupportedError",
+    "CoreLoadError",
+    "NoActiveSessionError",
+]

onewayswp/_core.py

@@ -0,0 +1,220 @@
+import ctypes
+import json
+import platform
+import time
+from pathlib import Path
+from ctypes import c_char_p, c_void_p, c_int64
+
+from .exceptions import (
+    PlatformNotSupportedError,
+    CoreLoadError,
+    FileLockedError,
+)
+
+
+SUPPORTED_PLATFORMS = {
+    ("windows", "x64"): "onewayswp_core.dll",
+    ("windows", "arm64"): "onewayswp_core.dll",
+    ("windows", "x86"): "onewayswp_core.dll",
+    ("linux", "x64"): "libonewayswp_core.so",
+    ("linux", "arm64"): "libonewayswp_core.so",
+    ("linux", "armv7"): "libonewayswp_core.so",
+    ("macos", "x64"): "libonewayswp_core.dylib",
+    ("macos", "arm64"): "libonewayswp_core.dylib",
+    ("android", "arm64"): "libonewayswp_core.so",
+    ("android", "armv7"): "libonewayswp_core.so",
+    ("android", "x64"): "libonewayswp_core.so",
+    ("android", "x86"): "libonewayswp_core.so",
+}
+
+
+def detect_platform() -> tuple:
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+
+    if system == "windows":
+        os_name = "windows"
+    elif system == "darwin":
+        os_name = "macos"
+    elif system == "linux":
+        if "android" in platform.platform().lower():
+            os_name = "android"
+        else:
+            os_name = "linux"
+    else:
+        os_name = system
+
+    if machine in ("x86_64", "amd64"):
+        arch = "x64"
+    elif machine in ("aarch64", "arm64"):
+        arch = "arm64"
+    elif machine.startswith("armv7") or machine == "armv7l":
+        arch = "armv7"
+    elif machine in ("i386", "i686", "x86"):
+        arch = "x86"
+    else:
+        arch = machine
+
+    return os_name, arch
+
+
+def find_library() -> str:
+    os_name, arch = detect_platform()
+    key = (os_name, arch)
+
+    if key not in SUPPORTED_PLATFORMS:
+        supported = ", ".join(f"{o}-{a}" for o, a in sorted(SUPPORTED_PLATFORMS))
+        raise PlatformNotSupportedError(
+            f"Platform '{os_name}-{arch}' is not supported. Supported: {supported}"
+        )
+
+    lib_name = SUPPORTED_PLATFORMS[key]
+    base = Path(__file__).parent / "lib"
+    specific = base / f"{os_name}-{arch}" / lib_name
+
+    if not specific.exists():
+        raise CoreLoadError(
+            f"Binary not found for {os_name}-{arch}. Expected at: {specific}"
+        )
+
+    return str(specific)
+
+
+class CoreLib:
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._load()
+        return cls._instance
+
+    def _load(self) -> None:
+        lib_path = find_library()
+
+        try:
+            loader = ctypes.WinDLL if platform.system() == "Windows" else ctypes.CDLL
+            self.lib = loader(lib_path)
+        except OSError as e:
+            raise CoreLoadError(f"Failed to load core library: {e}")
+
+        self.lib.owswp_version.restype = c_void_p
+        self.lib.owswp_version.argtypes = []
+
+        self.lib.owswp_info.restype = c_void_p
+        self.lib.owswp_info.argtypes = []
+
+        self.lib.owswp_generate_key_pair.restype = c_void_p
+        self.lib.owswp_generate_key_pair.argtypes = []
+
+        self.lib.owswp_validate_key_pair.restype = c_void_p
+        self.lib.owswp_validate_key_pair.argtypes = [c_char_p, c_char_p]
+
+        self.lib.owswp_create_license.restype = c_void_p
+        self.lib.owswp_create_license.argtypes = [c_char_p, c_char_p, c_char_p]
+
+        self.lib.owswp_validate_key.restype = c_void_p
+        self.lib.owswp_validate_key.argtypes = [c_char_p, c_char_p, c_char_p]
+
+        self.lib.owswp_inspect_key.restype = c_void_p
+        self.lib.owswp_inspect_key.argtypes = [c_char_p, c_char_p]
+
+        self.lib.owswp_protection_verify.restype = c_void_p
+        self.lib.owswp_protection_verify.argtypes = [c_char_p, c_char_p]
+
+        self.lib.owswp_decrement_credit.restype = c_void_p
+        self.lib.owswp_decrement_credit.argtypes = [c_char_p, c_char_p, c_int64]
+
+        self.lib.owswp_start_session.restype = c_void_p
+        self.lib.owswp_start_session.argtypes = [c_char_p, c_char_p]
+
+        self.lib.owswp_stop_session.restype = c_void_p
+        self.lib.owswp_stop_session.argtypes = [c_char_p, c_char_p]
+
+        self.lib.owswp_export_state.restype = c_void_p
+        self.lib.owswp_export_state.argtypes = [c_char_p, c_char_p]
+
+        self.lib.owswp_import_state.restype = c_void_p
+        self.lib.owswp_import_state.argtypes = [c_char_p, c_char_p, c_char_p]
+
+        self.lib.owswp_free_string.restype = None
+        self.lib.owswp_free_string.argtypes = [c_void_p]
+
+    def _call(self, func, *args) -> dict:
+        encoded = [a.encode("utf-8") if isinstance(a, str) else a for a in args]
+        ptr = func(*encoded)
+
+        if not ptr:
+            raise CoreLoadError("Core returned null pointer")
+
+        try:
+            raw = ctypes.cast(ptr, c_char_p).value
+            if raw is None:
+                raise CoreLoadError("Core returned empty response")
+            return json.loads(raw.decode("utf-8"))
+        except json.JSONDecodeError as e:
+            raise CoreLoadError(f"Invalid JSON from core: {e}")
+        finally:
+            self.lib.owswp_free_string(ptr)
+
+    def version(self) -> dict:
+        return self._call(self.lib.owswp_version)
+
+    def info(self) -> dict:
+        return self._call(self.lib.owswp_info)
+
+    def generate_key_pair(self) -> dict:
+        return self._call(self.lib.owswp_generate_key_pair)
+
+    def validate_key_pair(self, secret: str, public: str) -> dict:
+        return self._call(self.lib.owswp_validate_key_pair, secret, public)
+
+    def create_license(self, secret: str, license_type: str, payload_json: str) -> dict:
+        return self._call(self.lib.owswp_create_license, secret, license_type, payload_json)
+
+    def validate_key(self, token: str, public: str, swpb_path: str) -> dict:
+        return self._call(self.lib.owswp_validate_key, token, public, swpb_path)
+
+    def inspect_key(self, token: str, public: str) -> dict:
+        return self._call(self.lib.owswp_inspect_key, token, public)
+
+    def protection_verify(self, public: str, swpb_path: str) -> dict:
+        return self._call(self.lib.owswp_protection_verify, public, swpb_path)
+
+    def decrement_credit(self, public: str, swpb_path: str, amount: int) -> dict:
+        return self._call(self.lib.owswp_decrement_credit, public, swpb_path, amount)
+
+    def start_session(self, public: str, swpb_path: str) -> dict:
+        return self._call(self.lib.owswp_start_session, public, swpb_path)
+
+    def stop_session(self, public: str, swpb_path: str) -> dict:
+        return self._call(self.lib.owswp_stop_session, public, swpb_path)
+
+    def export_state(self, public: str, swpb_path: str) -> dict:
+        return self._call(self.lib.owswp_export_state, public, swpb_path)
+
+    def import_state(self, public: str, swpb_path: str, data: str) -> dict:
+        return self._call(self.lib.owswp_import_state, public, swpb_path, data)
+
+
+_core_instance = None
+
+
+def get_core() -> CoreLib:
+    global _core_instance
+    if _core_instance is None:
+        _core_instance = CoreLib()
+    return _core_instance
+
+
+def retry_on_locked(func, *args, retries: int = 3, delay: float = 0.1, **kwargs):
+    last_error = None
+    for attempt in range(retries):
+        try:
+            return func(*args, **kwargs)
+        except FileLockedError as e:
+            last_error = e
+            time.sleep(delay * (2 ** attempt))
+    if last_error:
+        raise last_error
+    raise FileLockedError("File locked")

onewayswp/admin.py

@@ -0,0 +1,187 @@
+import json
+from pathlib import Path
+from typing import Optional, Tuple
+
+from ._core import get_core, detect_platform
+from .exceptions import (
+    OnewaySWPError,
+    SecurityError,
+    InvalidKeyError,
+    raise_from_response,
+)
+
+
+SECRET_FILE = "secret.key"
+PUBLIC_FILE = "public.key"
+DEFAULT_DIR = Path.home() / ".owswp"
+
+
+class Admin:
+    def __init__(self, key_dir: Optional[str] = None) -> None:
+        self.key_dir: Path = Path(key_dir).expanduser() if key_dir else DEFAULT_DIR
+        self.secret_key: Optional[str] = None
+        self.public_key: Optional[str] = None
+        self._core = get_core()
+
+    def keys_exist(self, key_dir: Optional[str] = None) -> bool:
+        check_dir = Path(key_dir).expanduser() if key_dir else self.key_dir
+        secret_path = check_dir / SECRET_FILE
+        public_path = check_dir / PUBLIC_FILE
+        return secret_path.exists() and public_path.exists()
+
+    def generate_keys(
+        self,
+        auto_save: bool = True,
+        file_path: Optional[str] = None,
+    ) -> Tuple[str, str]:
+        response = self._core.generate_key_pair()
+        if not response.get("status"):
+            raise_from_response(response)
+
+        self.secret_key = response.get("secret_key")
+        self.public_key = response.get("public_key")
+
+        if auto_save:
+            save_dir = Path(file_path).expanduser() if file_path else self.key_dir
+            self.save_keys(target_dir=str(save_dir))
+
+        return self.secret_key, self.public_key
+
+    def save_keys(self, target_dir: Optional[str] = None) -> None:
+        if not self.secret_key or not self.public_key:
+            raise OnewaySWPError("No keys to save. Call generate_keys() first.")
+
+        save_dir = Path(target_dir).expanduser() if target_dir else self.key_dir
+        save_dir.mkdir(parents=True, exist_ok=True)
+
+        secret_path = save_dir / SECRET_FILE
+        public_path = save_dir / PUBLIC_FILE
+
+        secret_path.write_text(self.secret_key)
+        public_path.write_text(self.public_key)
+
+        try:
+            secret_path.chmod(0o600)
+        except (OSError, NotImplementedError):
+            pass
+
+    def load_keys(
+        self,
+        key_dir: Optional[str] = None,
+        validate: bool = True,
+        auto_generate: bool = False,
+    ) -> Tuple[str, str]:
+        load_dir = Path(key_dir).expanduser() if key_dir else self.key_dir
+        secret_path = load_dir / SECRET_FILE
+        public_path = load_dir / PUBLIC_FILE
+
+        if not secret_path.exists() or not public_path.exists():
+            if auto_generate:
+                self.key_dir = load_dir
+                self.generate_keys(auto_save=True, file_path=str(load_dir))
+                if validate:
+                    self.validate_keys()
+                return self.secret_key, self.public_key
+            raise InvalidKeyError(f"Key files not found in {load_dir}")
+
+        self.secret_key = secret_path.read_text().strip()
+        self.public_key = public_path.read_text().strip()
+
+        if validate:
+            self.validate_keys()
+
+        return self.secret_key, self.public_key
+
+    def set_keys(
+        self,
+        secret_key: str,
+        public_key: str,
+        validate: bool = True,
+    ) -> None:
+        if not secret_key or not public_key:
+            raise InvalidKeyError("Both secret_key and public_key required")
+
+        self.secret_key = secret_key.strip()
+        self.public_key = public_key.strip()
+
+        if validate:
+            self.validate_keys()
+
+    def validate_keys(self) -> bool:
+        if not self.secret_key or not self.public_key:
+            raise InvalidKeyError("Keys not loaded")
+
+        response = self._core.validate_key_pair(self.secret_key, self.public_key)
+        if not response.get("status"):
+            raise SecurityError(
+                response.get("message", "Key mismatch"),
+                code=response.get("code"),
+            )
+        return True
+
+    def create_license(
+        self,
+        type: str = "date",
+        expires: Optional[str] = None,
+        credits: Optional[int] = None,
+        duration_seconds: Optional[int] = None,
+        hours: Optional[float] = None,
+        additional_data: Optional[dict] = None,
+    ) -> dict:
+        if not self.secret_key:
+            raise OnewaySWPError(
+                "Secret key not loaded. Call load_keys() or generate_keys()."
+            )
+
+        if type not in ("date", "credit", "duration"):
+            raise OnewaySWPError(
+                f"Invalid type '{type}'. Must be: date, credit, duration"
+            )
+
+        if type == "date" and not expires:
+            raise OnewaySWPError("type='date' requires 'expires' (YYYY-MM-DD)")
+
+        if type == "credit" and credits is None:
+            raise OnewaySWPError("type='credit' requires 'credits'")
+
+        if type == "duration" and duration_seconds is None and hours is None:
+            raise OnewaySWPError(
+                "type='duration' requires 'duration_seconds' or 'hours'"
+            )
+
+        payload: dict = {}
+        if expires:
+            payload["expires"] = expires
+        if credits is not None:
+            payload["credits"] = credits
+        if duration_seconds is not None:
+            payload["duration_seconds"] = duration_seconds
+        elif hours is not None:
+            payload["duration_seconds"] = int(hours * 3600)
+        if additional_data:
+            payload["additional_data"] = additional_data
+
+        response = self._core.create_license(
+            self.secret_key,
+            type,
+            json.dumps(payload),
+        )
+
+        if not response.get("status"):
+            raise_from_response(response)
+
+        return response
+
+    def regenerate_keys(self, key_dir: Optional[str] = None) -> Tuple[str, str]:
+        target_dir = Path(key_dir).expanduser() if key_dir else self.key_dir
+        return self.generate_keys(auto_save=True, file_path=str(target_dir))
+
+    def platform(self) -> dict:
+        os_name, arch = detect_platform()
+        return {"os": os_name, "arch": arch}
+
+    def version(self) -> str:
+        response = self._core.version()
+        if not response.get("status"):
+            raise_from_response(response)
+        return response.get("version", "")

onewayswp/client.py

@@ -0,0 +1,245 @@
+from pathlib import Path
+from typing import Optional, List
+
+from ._core import get_core, retry_on_locked
+from .exceptions import (
+    OnewaySWPError,
+    SecurityError,
+    InvalidKeyError,
+    InvalidTokenError,
+    raise_from_response,
+)
+
+
+class Client:
+    def __init__(
+        self,
+        data_path: Optional[str] = None,
+        extra_paths: Optional[List[str]] = None,
+    ) -> None:
+        self.data_path: Path = (
+            Path(data_path).expanduser()
+            if data_path
+            else Path.cwd() / "license.swpb"
+        )
+        self.extra_paths: List[Path] = (
+            [Path(p).expanduser() for p in extra_paths] if extra_paths else []
+        )
+        self.public_key: Optional[str] = None
+        self._last_status: Optional[dict] = None
+        self._core = get_core()
+
+    def open_key(self, path: str) -> None:
+        p = Path(path).expanduser()
+
+        if p.is_dir():
+            p = p / "public.key"
+
+        if not p.exists():
+            raise InvalidKeyError(f"Key file not found: {p}")
+
+        content = p.read_text().strip()
+        self.set_public_key(content)
+
+    def set_public_key(self, key: str) -> None:
+        if not key:
+            raise InvalidKeyError("Public key is empty")
+
+        key = key.strip()
+
+        if key.startswith("OWSWP-sec-"):
+            raise SecurityError(
+                "Security error: you provided a secret key. "
+                "Client must use public key only."
+            )
+
+        if not key.startswith("OWSWP-pub-"):
+            raise InvalidKeyError(
+                "Invalid key format. Must start with 'OWSWP-pub-'"
+            )
+
+        self.public_key = key
+
+    def is_active(self) -> bool:
+        if not self.public_key:
+            return False
+
+        if not self.data_path.exists():
+            return False
+
+        try:
+            result = self.protection_verify()
+            return result.get("status", False)
+        except Exception:
+            return False
+
+    def validate_key(self, token: str) -> dict:
+        if not self.public_key:
+            raise InvalidKeyError(
+                "Public key not set. Call open_key() or set_public_key()."
+            )
+
+        if not token or not isinstance(token, str):
+            raise OnewaySWPError("Token is required and must be a string")
+
+        token = token.strip()
+
+        if not token.startswith("OWSWP-"):
+            raise InvalidTokenError(
+                "Invalid token format. Must start with 'OWSWP-'"
+            )
+
+        try:
+            self.data_path.parent.mkdir(parents=True, exist_ok=True)
+        except OSError as e:
+            raise OnewaySWPError(f"Cannot create directory: {e}")
+
+        response = retry_on_locked(
+            self._core.validate_key,
+            token,
+            self.public_key,
+            str(self.data_path),
+        )
+        self._last_status = response
+        return response
+
+    def inspect_key(self, token: str) -> dict:
+        if not self.public_key:
+            raise InvalidKeyError("Public key not set.")
+
+        if not token or not isinstance(token, str):
+            raise OnewaySWPError("Token is required and must be a string")
+
+        response = self._core.inspect_key(token.strip(), self.public_key)
+        return response
+
+    def protection_verify(self) -> dict:
+        if not self.public_key:
+            raise InvalidKeyError("Public key not set.")
+
+        if not self.data_path.exists():
+            return {
+                "status": False,
+                "code": "NO_STATE_FILE",
+                "message": f"State file not found: {self.data_path}",
+            }
+
+        response = retry_on_locked(
+            self._core.protection_verify,
+            self.public_key,
+            str(self.data_path),
+        )
+        self._last_status = response
+        return response
+
+    def use_credit(self, amount: int = 1) -> dict:
+        if not self.public_key:
+            raise InvalidKeyError("Public key not set.")
+
+        if not self.data_path.exists():
+            raise OnewaySWPError("State file not found. Validate key first.")
+
+        if amount <= 0:
+            raise OnewaySWPError("Amount must be greater than zero")
+
+        response = retry_on_locked(
+            self._core.decrement_credit,
+            self.public_key,
+            str(self.data_path),
+            amount,
+        )
+        self._last_status = response
+        return response
+
+    def session(self):
+        return _SessionContext(self)
+
+    def _start_session(self) -> dict:
+        if not self.public_key:
+            raise InvalidKeyError("Public key not set.")
+        if not self.data_path.exists():
+            raise OnewaySWPError("State file not found. Validate key first.")
+        return self._core.start_session(self.public_key, str(self.data_path))
+
+    def _stop_session(self) -> dict:
+        if not self.public_key:
+            raise InvalidKeyError("Public key not set.")
+        if not self.data_path.exists():
+            raise OnewaySWPError("State file not found. Validate key first.")
+        return self._core.stop_session(self.public_key, str(self.data_path))
+
+    def export_state(self) -> dict:
+        if not self.public_key:
+            raise InvalidKeyError("Public key not set.")
+        if not self.data_path.exists():
+            raise OnewaySWPError("State file not found.")
+        return self._core.export_state(self.public_key, str(self.data_path))
+
+    def import_state(self, data) -> dict:
+        if not self.public_key:
+            raise InvalidKeyError("Public key not set.")
+
+        try:
+            self.data_path.parent.mkdir(parents=True, exist_ok=True)
+        except OSError as e:
+            raise OnewaySWPError(f"Cannot create directory: {e}")
+
+        if isinstance(data, dict):
+            import json as _json
+            data = _json.dumps(data)
+
+        response = self._core.import_state(
+            self.public_key,
+            str(self.data_path),
+            data,
+        )
+        self._last_status = response
+        return response
+
+    def status(self) -> dict:
+        if self._last_status:
+            return self._last_status
+
+        if not self.data_path.exists():
+            return {
+                "status": False,
+                "code": "NO_STATE_FILE",
+                "message": "No status available",
+            }
+
+        return self.protection_verify()
+
+    def state_path(self) -> str:
+        return str(self.data_path)
+
+    def reset(self) -> None:
+        if self.data_path.exists():
+            self.data_path.unlink()
+        self._last_status = None
+
+    def version(self) -> str:
+        response = self._core.version()
+        if not response.get("status"):
+            raise_from_response(response)
+        return response.get("version", "")
+
+
+class _SessionContext:
+    def __init__(self, client: Client) -> None:
+        self.client = client
+        self._started = False
+
+    def __enter__(self) -> Client:
+        result = self.client._start_session()
+        if not result.get("status"):
+            raise_from_response(result)
+        self._started = True
+        return self.client
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> bool:
+        if self._started:
+            try:
+                self.client._stop_session()
+            except Exception:
+                pass
+        return False