ONEWAYSWP

Offline One-Way License Framework

Secure · Offline · Portable · Self-Contained

OnewaySWP is a Python library for building one-way license verification systems without requiring a server.

Licenses are generated on the admin side, distributed to clients, and verified entirely offline.

The framework internally handles license generation, cryptographic signing, protected local state, and verification. Client applications only require a public key to validate licenses.

No internet connection. No license server. No backend infrastructure.

OnewaySWP is designed for developers who want a practical licensing solution that stays portable, self-contained, and independent.

✦ Features

	Feature	Description
◉	Offline Verification	No internet connection or license server required
◉	Auto-Detection	Automatically detects the current OS and architecture
◉	Cross-Platform	Supports Windows, Linux, macOS, and Android
◉	Multi-Mode	Supports Date, Credit, and Duration license types
◉	Session-Based Duration	Duration licenses measured during active sessions
◉	Credit System	Credit-based licenses with automatic decrement
◉	Cryptographic Protection	License integrity and tamper detection
◉	Protected Local Storage	Local license state protected with internal protection mechanisms
◉	Clock Rollback Protection	Detects system clock manipulation
◉	Multi-License Support	Multiple independent license states per application
◉	Session Context Manager	Automatic start/stop for duration licenses
◉	State Export & Import	Move license state between environments
◉	Retry on File Lock	Automatic retry when state file is locked

Installation

Install directly from PyPI:

pip install onewayswp

Command	Purpose
`pip`	Python package installer
`install`	Installs a package
`onewayswp`	OnewaySWP package

Quick Start

01 — Admin Setup

Create an admin instance and generate the key pair.

from onewayswp import Admin

# Create admin instance
admin = Admin()

# Load existing key pair.
# If it does not exist yet, it will be generated automatically.
admin.load_keys(auto_generate=True)

# Display keys
print("Secret:", admin.secret_key)
print("Public:", admin.public_key)

Recommended: Always use load_keys(auto_generate=True) on the admin side.

Manual key generation via generate_keys() should only be used when you intentionally want to replace the existing key pair. Replacing the key pair will invalidate all previously issued licenses.

Important: The secret key is used to sign licenses and must remain private. The public key is distributed to client applications for verification.

02 — Create a License

Load the existing keys and create a license.

from onewayswp import Admin

admin = Admin()

# Load existing keys
admin.load_keys(auto_generate=False)

# Create a license
result = admin.create_license(
    type="date",
    expires="2027-12-31",
    additional_data={
        "client_name": "username123"
    }
)

print(result["token"])

03 — Client Verification

The client application only needs the public key.

from onewayswp import Client

# Create client instance
client = Client("data/license.swpb")

# Load public key
client.open_key("~/.owswp/public.key")

# Check whether a license is already active
if not client.is_active():

    token = input("Enter key: ")

    # Validate license
    result = client.validate_key(token)

    if not result["status"]:
        print(result["message"])
        exit(1)

# Verify protection state
protection = client.protection_verify()

if protection["status"]:
    print("Application running...")
else:
    print(protection["message"])

Basic Flow

┌─────────────────────┐
│        ADMIN        │
├─────────────────────┤
│ Load Key Pair   │
│         ↓           │
│ Create License      │
│         ↓           │
│ Distribute Token    │
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│       CLIENT        │
├─────────────────────┤
│ Public Key          │
│         ↓           │
│ Validate Token      │
│         ↓           │
│ Verify Local State  │
└─────────────────────┘

License Types

OnewaySWP provides three license modes.

Date License

A license that expires on a specific date.

result = admin.create_license(
    type="date",
    expires="2027-12-31"
)

Parameter	Description
`type`	`"date"`
`expires`	Expiration date in `YYYY-MM-DD` format

Returns information such as:

token
type
expired
expires_at

Credit License

A license containing a credit balance that decreases when used.

result = admin.create_license(
    type="credit",
    credits=100
)

Parameter	Description
`type`	`"credit"`
`credits`	Initial credit amount

Returns information such as:

token
type
credit_value

Duration License

A license valid for a fixed amount of active usage time.

result = admin.create_license(
    type="duration",
    hours=2
)

Parameter	Description
`type`	`"duration"`
`hours`	Duration in hours
`duration_seconds`	Alternative duration in seconds

Returns information such as:

token
type
duration_hours

API Reference

Admin

Method	Parameters	Returns	Description
`__init__`	`key_dir: str = None`	`Admin`	Create admin instance
`keys_exist`	`key_dir: str = None`	`bool`	Check if key files exist
`generate_keys`	`auto_save: bool = True, file_path: str = None`	`tuple`	Generate key pair
`save_keys`	`target_dir: str = None`	`None`	Save keys to disk
`load_keys`	`key_dir: str = None, validate: bool = True, auto_generate: bool = False`	`tuple`	Load keys
`set_keys`	`secret_key: str, public_key: str, validate: bool = True`	`None`	Set keys manually
`validate_keys`	`none`	`bool`	Verify key pair
`create_license`	`type, expires, credits, duration_seconds, hours, additional_data`	`dict`	Create license token
`regenerate_keys`	`key_dir: str = None`	`tuple`	Generate new key pair
`platform`	`none`	`dict`	Get OS and architecture
`version`	`none`	`str`	Get library version

Client

Method	Parameters	Returns	Description
`__init__`	`data_path: str = None, extra_paths: List[str] = None`	`Client`	Create client instance
`open_key`	`path: str`	`None`	Load public key
`set_public_key`	`key: str`	`None`	Set public key
`is_active`	`none`	`bool`	Check active license
`validate_key`	`token: str`	`dict`	Validate license
`inspect_key`	`token: str`	`dict`	Inspect token without activation
`protection_verify`	`none`	`dict`	Verify local protection state
`use_credit`	`amount: int = 1`	`dict`	Decrement credits
`session`	`none`	`context`	Duration session context
`export_state`	`none`	`dict`	Export license state
`import_state`	`data: dict or str`	`dict`	Import license state
`status`	`none`	`dict`	Get last status
`state_path`	`none`	`str`	Get state file path
`reset`	`none`	`None`	Delete local state
`version`	`none`	`str`	Get library version

Info Object

The info object provides library information and supports both attribute-style and dictionary-style access.

Method	Description
`__getattr__`	Access field as attribute
`__getitem__`	Access field by key
`__contains__`	Check whether field exists
`__iter__`	Iterate over field names
`keys()`	Get field names
`values()`	Get field values
`items()`	Get field/value pairs
`get()`	Get field with default
`to_dict()`	Convert to dictionary

Response Format

Validation and operation methods use a consistent dictionary-based response format.

Success

{
    "status": True,
    "code": "SUCCESS",
    "message": "License valid and activated",
    "type": "credit",
    "credit_value": 100,
    "remaining_credits": 100,
    "created_at": "2026-10-03 12:00:00",
    "last_time": "2026-10-03 12:05:00",
    "additional_data": {
        "hardware_id": "1234567890"
    }
}

Failure

{
    "status": False,
    "code": "EXPIRED",
    "message": "Token expired"
}

Failure responses contain:

status
code
message

Data Dictionary

Common Fields

Field	Type	Description
`status`	`bool`	True when operation succeeds
`code`	`str`	Status or error code
`message`	`str`	Human-readable message
`type`	`str`	`date`, `credit`, or `duration`

Date License

Field	Type	Description
`expired`	`str`	Expiration date
`expires_at`	`int`	Unix expiration timestamp
`remaining_days`	`int`	Remaining days

Credit License

Field	Type	Description
`credit_value`	`int`	Initial credit
`remaining_credits`	`int`	Remaining credit
`used`	`int`	Credit used in last operation

Duration License

Field	Type	Description
`duration_hours`	`float`	Total duration
`duration_seconds`	`int`	Total duration in seconds
`remaining_hours`	`float`	Remaining duration
`remaining_seconds`	`int`	Remaining seconds
`elapsed_seconds`	`int`	Elapsed session time
`started_at`	`str`	Session start
`stopped_at`	`str`	Session stop

Session

Field	Type	Description
`created_at`	`str`	License creation timestamp
`last_time`	`str`	Last verification timestamp

Error Codes

Code	Description
`SUCCESS`	Operation completed successfully
`INVALID_SIGNATURE`	Token signature is invalid
`INVALID_MAGIC`	File format is invalid
`INVALID_KEY_FORMAT`	Key format is invalid
`UNSUPPORTED_VERSION`	File version is not supported
`KEY_MISMATCH`	Key pair does not match
`SECURITY_ERROR`	Security violation detected
`EXPIRED`	Token has expired
`CLOCK_ROLLBACK_DETECTED`	System clock rollback detected
`CORRUPTED_FILE`	File is corrupted
`INSUFFICIENT_CREDITS`	Credit balance is insufficient
`FILE_LOCKED`	File is locked by another process
`IO_ERROR`	Input/output error
`CRYPTO_ERROR`	Cryptographic error
`SERIALIZATION_ERROR`	Serialization error
`FFI_ERROR`	Foreign function interface error
`NO_STATE_FILE`	State file does not exist

Examples

Generate Keys

from onewayswp import Admin

admin = Admin(key_dir="./keys")

secret, public = admin.generate_keys(
    auto_save=True
)

print("Secret Key:", secret)
print("Public Key:", public)

Load Existing Keys

from onewayswp import Admin

admin = Admin()

secret, public = admin.load_keys(
    validate=True,
    auto_generate=False
)

print("Keys loaded successfully")

Load Keys with Auto-Generate

from onewayswp import Admin

admin = Admin()

secret, public = admin.load_keys(
    auto_generate=True
)

print("Keys ready")
print("Public:", public)

Create Date License

from onewayswp import Admin

admin = Admin()
admin.load_keys()

result = admin.create_license(
    type="date",
    expires="2027-12-31",
    additional_data={
        "client_name": "user12345",
        "plan": "pro"
    }
)

token = result["token"]

print("Token:", token)
print("Expires:", result["expired"])
print("Expires at:", result["expires_at"])

Create Credit License

from onewayswp import Admin

admin = Admin()
admin.load_keys()

result = admin.create_license(
    type="credit",
    credits=100,
    additional_data={
        "client_name": "user12345"
    }
)

print("Token:", result["token"])
print("Credits:", result["credit_value"])

Create Duration License

from onewayswp import Admin

admin = Admin()
admin.load_keys()

result = admin.create_license(
    type="duration",
    hours=2,
    additional_data={
        "client_name": "user12345"
    }
)

print("Token:", result["token"])
print("Duration:", result["duration_hours"], "hours")

Alternative using seconds:

result = admin.create_license(
    type="duration",
    duration_seconds=3600
)

print(
    "Duration:",
    result["duration_hours"],
    "hours"
)

Set Keys Manually

from onewayswp import Admin

admin = Admin()

admin.set_keys(
    secret_key="OWSWP-sec-...",
    public_key="OWSWP-pub-...",
    validate=True
)

print("Keys set")

Regenerate Keys

from onewayswp import Admin

admin = Admin()
admin.load_keys()

new_secret, new_public = admin.regenerate_keys()

print("New secret:", new_secret)
print("New public:", new_public)

Regenerating the key pair will cause previously issued tokens to become invalid.

Platform Information

from onewayswp import Admin

admin = Admin()

info = admin.platform()

print("OS:", info["os"])
print("Arch:", info["arch"])

Client Validation

from onewayswp import Client

client = Client(
    "data/license.swpb"
)

client.set_public_key(
    "OWSWP-pub-..."
)

if client.is_active():

    print("License already active")

else:

    token = input("Enter key: ")

    result = client.validate_key(token)

    if result["status"]:

        print("License activated")
        print("Type:", result["type"])

    else:

        print("Failed:", result["message"])

Use Credits

from onewayswp import Client

client = Client(
    "data/license.swpb"
)

client.open_key(
    "~/.owswp/public.key"
)

result = client.validate_key(
    "OWSWP-..."
)

if not result["status"]:
    print("Invalid license")
    exit(1)

result = client.use_credit(5)

if result["status"]:

    print("Used 5 credits")
    print(
        "Remaining:",
        result["remaining_credits"]
    )

else:

    print("Failed:", result["message"])

Duration Session

Duration licenses can measure usage during an active session.

from onewayswp import Client
import time

client = Client(
    "data/license.swpb"
)

client.open_key(
    "~/.owswp/public.key"
)

result = client.validate_key(
    "OWSWP-..."
)

if not result["status"]:
    print("Invalid license")
    exit(1)

with client.session():

    print("Application running...")

    time.sleep(10)

protection = client.protection_verify()

print(
    "Remaining:",
    protection["remaining_hours"],
    "hours"
)

Inspect License Without Activating

from onewayswp import Client

client = Client(
    "data/license.swpb"
)

client.set_public_key(
    "OWSWP-pub-..."
)

result = client.inspect_key(
    "OWSWP-..."
)

if result["status"]:

    print("Type:", result["type"])
    print("Is expired:", result["is_expired"])

    if result["type"] == "date":

        print(
            "Expires:",
            result["expired"]
        )

        print(
            "Remaining days:",
            result["remaining_days"]
        )

    elif result["type"] == "credit":

        print(
            "Credits:",
            result["credit_value"]
        )

    elif result["type"] == "duration":

        print(
            "Duration hours:",
            result["duration_hours"]
        )

Export & Import State

Export state:

from onewayswp import Client

client1 = Client(
    "data/license1.swpb"
)

client1.open_key(
    "~/.owswp/public.key"
)

exported = client1.export_state()

print(
    "Exported data:",
    exported["data"][:50],
    "..."
)

print(
    "Public key:",
    exported["public_key"]
)

Import state:

client2 = Client(
    "data/license2.swpb"
)

client2.set_public_key(
    exported["public_key"]
)

result = client2.import_state(
    exported
)

if result["status"]:

    print(
        "State imported successfully"
    )

Reset Client State

from onewayswp import Client

client = Client(
    "data/license.swpb"
)

client.set_public_key(
    "OWSWP-pub-..."
)

client.reset()

print("State reset")

After resetting, the next validation will require a new token.

Library Information

from onewayswp import info

print(info)

print("Author:", info.author)
print("Version:", info.oneway_version)
print("GitHub:", info.swp_github)

Dictionary-style access:

print("Author:", info["author"])

Convert to dictionary:

data = info.to_dict()

for key, value in data.items():
    print(f"{key}: {value}")

Error Handling

from onewayswp import (
    Client,
    OnewaySWPError,
    InvalidTokenError,
    ExpiredError,
    SecurityError,
)

client = Client(
    "data/license.swbp"
)

client.set_public_key(
    "OWSWP-pub-..."
)

try:

    result = client.validate_key(
        "OWSWP-..."
    )

    if not result["status"]:

        code = result["code"]
        message = result["message"]

        print(
            f"Error [{code}]: {message}"
        )

except InvalidTokenError as e:

    print(
        f"Invalid token: {e}"
    )

except ExpiredError as e:

    print(
        f"Token expired: {e}"
    )

except SecurityError as e:

    print(
        f"Security error: {e}"
    )

except OnewaySWPError as e:

    print(
        f"Error: {e}"
    )

Security Notes

OnewaySWP is designed to help developers create one-way license verification systems for applications that cannot rely on a server.

It is a licensing framework, not a replacement for application-level security.

The library applies internal cryptographic protection to help preserve license integrity, protect local license state, and detect unauthorized modification.

However, the overall security of an application still depends on how the framework is integrated by the developer.

Any bypass, modification, or direct interaction with the application code is outside the scope of this library.

Keep Your Secret Key Private

The secret key is used to sign licenses.

Never distribute it with client applications.

If the secret key is exposed, another party may be able to generate valid licenses.

Protect Your Key Pair

Store the secret key and public key safely.

Losing the key pair may prevent future licenses from being verified against previously issued tokens.

Public Key Distribution

Client applications only require the public key to validate licenses.

The secret key should remain on the administrative side.

Protect Local State

Treat the .swpb state file as protected application data.

Manual modification may invalidate the license state.

Integration Matters

OnewaySWP is a tool.

The way it is integrated into an application determines how effectively it contributes to the application's licensing protection.

Compatibility

OnewaySWP is designed for cross-platform usage:

Windows
Linux
macOS
Android

Platform and architecture information can be detected automatically:

from onewayswp import Admin

admin = Admin()

info = admin.platform()

print(info["os"])
print(info["arch"])

Project Information


Project	OnewaySWP
Description	Offline One-Way License Framework
Version	`0.1.0`
Author	Juan Hulu
Organization	SilentWolfProject
License	MIT

Star growth

Repository activity

Embed badge

README

ONEWAYSWP

Offline One-Way License Framework

Jump To

✦ Features

Installation

Quick Start

01 — Admin Setup

02 — Create a License

03 — Client Verification

Basic Flow

License Types

Date License

Credit License

Duration License

API Reference

Admin

Client

Info Object

Response Format

Success

Failure

Data Dictionary

Common Fields

Date License

Credit License

Duration License

Session

Error Codes

Examples

Generate Keys

Load Existing Keys

Load Keys with Auto-Generate

Create Date License

Create Credit License

Create Duration License

Set Keys Manually

Regenerate Keys

Platform Information

Client Validation

Use Credits

Duration Session

Inspect License Without Activating

Export & Import State

Reset Client State

Library Information

Error Handling

Security Notes

Keep Your Secret Key Private

Protect Your Key Pair

Public Key Distribution

Protect Local State

Integration Matters

Compatibility

Project Information

Links

ONEWAYSWP