Enterprise Airgap Security in a 2MB Rust Binary
Thales-level protection without the dongles. No 500MB driver packages, no hardware inventory, no USB port conflicts. Open source client for security audits.
0+
teams switched
0+
licenses validated
99.99%
uptime SLA
<50ms
avg response
Trusted by teams in manufacturing, government, and healthcare
Modern alternative to legacy licensing
Compare Licenz to Thales Sentinel and Wibu CodeMeter
Built for high-security environments
From factory floors to classified networks
Industrial & Manufacturing
Air-gapped PLCs, SCADA systems, and CNC machines. No USB dongles on the factory floor.
Learn moreGovTech & Defense
Open source client for security audits. Self-hosted deployment for classified networks.
Learn moreMedTech & Healthcare
HIPAA-ready. Tamper-proof licenses for medical devices and diagnostic equipment.
Learn moreEnterprise-grade features
Security and simplicity, not security or simplicity
Airgap-First Design
Not an offline mode bolted onto an online system. Built from the ground up for disconnected environments.
Modern Cryptography
RSA-SHA256 and Ed25519 signatures. AES-256-GCM encryption. Pluggable crypto for future-proofing.
Hardware Binding
Lock licenses to specific machines. MAC, disk ID, hostname with weighted scoring and drift tolerance.
Open Source Verification
MIT-licensed client. Security teams can audit every line. No black boxes in your infrastructure.
Sneakernet Workflow
File-based activation for completely disconnected systems. Generate request, transfer, install response.
Time-Tampering Protection
Monotonic clock tracking with encrypted state. Detect and prevent clock rollback attacks.
Simple integration. Enterprise security.
Add license validation in minutes, not weeks
use licenz::{LicenseVerifier, License};
fn main() -> Result<(), Box<dyn std::error::Error>> {
// Your public key (safe to embed in binary)
let public_key = include_str!("public_key.pem");
// Create verifier with hardware binding
let verifier = LicenseVerifier::new(public_key)?
.with_hardware_binding();
// Validate the license (works completely offline)
let license = License::from_file("license.key")?;
match verifier.verify(&license) {
Ok(claims) => {
println!("License valid for: {}", claims.licensee);
if claims.features.contains("enterprise") {
enable_enterprise_features();
}
}
Err(e) => {
eprintln!("License invalid: {}", e);
std::process::exit(1);
}
}
Ok(())
}Ready for modern enterprise licensing?
Thales-level security. Developer-first simplicity. Transparent pricing.