QuantumLock

Enterprise License Management with Quantum-Enhanced Security

QuantumLock is a comprehensive software licensing solution that combines RSA-4096 cryptographic signatures with optional quantum-enhanced security features.

Features

• 🔐 Cryptographic License Signing - RSA-4096 with SHA-256
• ⚛️ Quantum-Enhanced Security - Optional quantum fingerprinting (Qiskit)
• 🌐 REST API - SaaS license management platform
• 💻 CLI Tool - Command-line license generation and validation
• 🔄 Floating Licenses - Concurrent seat management with Redis
• 📦 SDK - Embeddable validation library

Installation

# SDK + CLI: puts `quantumlock` and `ql` on PATH
pip install quantumlock

# Everything a client machine can run: quantum entropy (Qiskit, QCOS Runtime
# via softqcos-sdk) and ML-DSA / FIPS 204 signatures (liboqs-python)
pip install "quantumlock[full]"

The published wheel is the client (SDK, CLI, offline verifier). The REST API and the floating license server are not in it; they run as SoftQuantus services or from this repository (see Docker below). quantumlock[cli] still resolves, but the CLI is part of the base install since 2.1.5.

liboqs-python is only the binding: ML-DSA also needs the native liboqs shared library, and QuantumLock never downloads or builds it behind your back. Provision it once, explicitly:

python -c "import oqs"     # liboqs-python clones and builds liboqs into ~/_oqs
                           # (needs git, cmake and a C compiler)
# or point at an existing shared build (lib/liboqs.so or lib/liboqs.dylib):
export OQS_INSTALL_PATH=/opt/liboqs

Homebrew's liboqs is a static library and does not satisfy the binding. Until the shared library is there, quantumlock doctor says so and ML-DSA signing and verification are reported unavailable; nothing exits.

Quick Start

CLI

quantumlock doctor                     # local readiness: crypto, PQC, entropy
quantumlock configure                  # store your QuantumLock API key locally

# Issue a license through the QuantumLock API, then check it
quantumlock generate --customer acme@example.com --features pro,export \
  --days 365 --output license.json
quantumlock validate <license_key> --file license.json

# Offline verification of a QCOS evidence record (no API key needed)
quantumlock trust-bundle --help
quantumlock verify --help

quantumlock --help lists every command (keys, trust-root, inventory, v2, ...).

SDK

from quantumlock.sdk import LicenseValidator

validator = LicenseValidator("license.json")
if validator.validate():
    print(validator.get_license_info())
    print("pro" if validator.has_feature("pro") else "basic")

API Server (source checkout only; not in the PyPI wheel)

# Using Docker
docker-compose up -d api

# Or directly, from a clone of this repository
pip install -e ".[api,pqc]"
uvicorn quantumlock.api:create_app --factory --host 0.0.0.0 --port 8000

Architecture

quantumlock/
├── src/quantumlock/       # Main package
│   ├── core/              # Shared models, crypto, config
│   ├── api/               # REST API (FastAPI)
│   ├── cli/               # CLI tool (Typer)
│   ├── sdk/               # Embeddable SDK
│   └── server/            # Floating license server
├── lib/                   # Shared libraries
│   ├── authority.py       # RSA signing/validation
│   └── quantum_protocol.py # Quantum features
└── tests/                 # Test suite

Docker

# API server
docker build --target api -t quantumlock-api .

# CLI tool
docker build --target cli -t quantumlock-cli .

# License server
docker build --target server -t quantumlock-server .

Deployment

Unified Deployment Script

The project includes a master deployment script that handles everything from zero:

# Full deployment (API + SDK + CLI)
./scripts/deploy_all.sh

# Staging environment
./scripts/deploy_all.sh --env staging

# Preview without executing
./scripts/deploy_all.sh --dry-run

# Skip components
./scripts/deploy_all.sh --skip-api      # Only SDK/CLI
./scripts/deploy_all.sh --skip-sdk      # Only API + CLI
./scripts/deploy_all.sh --skip-cli      # Only API + SDK

Deployment Phases

1. Bootstrap - Generate RSA-4096 keys and bootstrap license for API
2. Build API - Nuitka compilation in Docker (Linux-compatible binaries)
3. Deploy API - Push to Azure Container Apps
4. Generate Licenses - Create SDK/CLI licenses via running API
5. Build SDK/CLI - Nuitka with embedded licenses and public keys
6. Deploy SDK/CLI - Push to Azure/Registry

Scripts

Script	Purpose
scripts/deploy_all.sh	Master script - does everything
scripts/build_docker.sh	Nuitka build via Docker
scripts/build_nuitka.py	Core Nuitka compilation
automation/3-deploy-protected-apis.sh	Azure deployment (alternative)

License Protection

• Binaries compiled with Nuitka have embedded license + public key
• Bootstrap license for API uses self-signed key pair
• SDK/CLI licenses generated via QuantumLock API (dogfooding)
• RSA-4096 signatures prevent tampering

Environment Variables

Variable	Default	Description
QUANTUMLOCK_DATABASE_URL	sqlite:///quantumlock.db	Database connection
QUANTUMLOCK_SECRET_KEY	(required)	JWT signing key
QUANTUMLOCK_REDIS_URL	redis://localhost:6379	Redis for server
QUANTUMLOCK_DEBUG	false	Enable debug mode

License

Proprietary Software - Copyright © 2025 SoftQuantus innovative OÜ

This software is proprietary and confidential. Use of this software is governed by the End User License Agreement (EULA) and Terms of Service.

Legal Documents

Document	Link
EULA	docs/legal/EULA.md
Terms of Service	docs/legal/TERMS_OF_SERVICE.md
Privacy Policy	docs/legal/PRIVACY_POLICY.md
License	LICENSE

Company Information

SoftQuantus innovative OÜ

• Registry Code: 17048927
• VAT: EE102767458
• Address: Veskiposti tn 2-1002, Tallinn, 10138, Estonia

Contact

Purpose	Contact
Website	https://softquantus.com
Portal	https://platform.softquantus.com
Support	support@softquantus.com
Legal	legal@softquantus.com
Phone	+33 628315815

---

QuantumLock™ is a trademark of SoftQuantus innovative OÜ.