Traditional security defends what attackers can already see. LayerV inverts the model: your infrastructure doesn't exist on the network until identity is verified. There's nothing to find, nothing to probe, nothing to attack.
Discover → Connect → Authenticate → Defend. Your infrastructure sits on the internet with open ports, public DNS, visible to every scanner. Firewalls, WAFs, and VPNs try to protect what's already exposed. Attackers get unlimited free reconnaissance.
Authenticate → Connect → Access. Infrastructure is cryptographically invisible by default. No ports, no DNS response, no TCP handshake. Only after identity is verified does a path to the resource come into existence — scoped to one user, one device, one session.
User authenticates with your existing identity provider — Okta, Azure AD, Google. No new credentials, no friction. This happens before any network connection to the protected resource.
Post-auth, your backend calls LayerV's API to mint a QURL — a single-use, time-bound, device-locked credential. LayerV opens a pinhole for this specific user only.
User follows the QURL in any browser. No agent, no plugin, no client to install. The resource materializes for this session only. To everyone else, it remains invisible.
Session ends. QURL expires. Pinhole closes. Resource returns to invisible state. Full audit trail with cryptographically-bound identity for compliance.
A QURL (Quantum URL — say “curl”) is not a login link. It’s a temporary wormhole. A single-use, time-bound access credential that brings a service into existence for one user and collapses when the session ends. Without a QURL, the target doesn’t exist on the network. You can’t attack what isn’t there.
Service is cryptographically unreachable. No open ports, no DNS resolution, no visible endpoints. Scanners find nothing.
Identity verified. Wormhole opens. Short-lived, private access session where the service temporarily exists for this user only.
Access path removed. QURL consumed and destroyed. Service returns to invisible state. Audit trail preserved.
QURLs don’t log users in. They temporarily bring services into existence.
No application rewrite required. LayerV sits in front of what you already run.
# Mint a QURL after user authenticates with your IdP curl -X POST https://api.qurl.link/v1/qurl \ -H "Authorization: Bearer $AUTH0_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "target_url": "https://admin.yourapp.com/dashboard", "expires_in": "1h", "one_time_use": true, "access_policy": { "geo_allowlist": ["US", "CA"] }, "description": "Admin dashboard session" }' # Response { "data": { "resource_id": "r_K8xQp9H2sJ9", "qurl_link": "https://qurl.link/at_abc123def456", "qurl_site": "https://r_K8xQp9H2sJ9.qurl.site", "expires_at": "2025-01-15T11:30:00Z" }, "meta": { "request_id": "req_abc123" } }
import { LayerV } from '@layerv/sdk'; const client = new LayerV(); // Uses AUTH0 token from env // After Okta/Azure AD callback succeeds: app.post('/auth/callback', async (req, res) => { const user = await verifyIdpToken(req.body.token); // Mint a QURL — resource becomes reachable const { data } = await client.qurl.create({ target_url: 'https://admin.yourapp.com/dashboard', expires_in: '1h', one_time_use: true, access_policy: { geo_allowlist: ['US', 'CA'] }, description: `Session for ${user.email}` }); // Redirect user through the access link res.redirect(data.qurl_link); });
import layerv from flask import redirect, request client = layerv.Client() # Uses AUTH0 token from env # After IdP authentication callback: @app.route("/auth/callback", methods=["POST"]) def auth_callback(): user = verify_idp_token(request.form["token"]) # Mint a QURL — resource materializes resp = client.qurl.create( target_url="https://admin.yourapp.com/dashboard", expires_in="1h", one_time_use=True, access_policy={"geo_allowlist": ["US", "CA"]}, description=f"Session for {user.email}" ) # Redirect through the access link return redirect(resp.data.qurl_link)
Full API Reference → Webhooks · Batch create · Access policies · Quota management
Results from nmap scan against a protected resource.
$ nmap -sS target.example.com PORT STATE SERVICE 22/tcp open ssh 443/tcp open https 3389/tcp open ms-wbt-server 5432/tcp open postgresql 8080/tcp open http-proxy Nmap done: 1 IP address (1 host up) scanned in 2.41s
$ nmap -sS -Pn -p- target.example.com All 65535 scanned ports are in ignored states. Not shown: 65535 filtered tcp ports (no-response) Nmap done: 1 IP address (1 host up) scanned in 1312.48s
Your internal architecture stays intact. The front door becomes invisible. Keycloak, Istio, service meshes, load balancers — all remain, but move behind the dark perimeter.
Public DNS entries → Eliminated
Static application URLs → Ephemeral QURLs
Open ports & endpoints → All dark
Auth redirect flow → Pre-auth
Client software → None (browser only)
Identity provider (federated)
Service mesh (Istio / Envoy)
Load balancers (internal routing)
User databases & logging
Internal account provisioning
DNS enumeration — No records
Port scanning — No ports
DDoS against auth infra — Unreachable
Credential stuffing — No login endpoint
Pre-auth exploitation — Nothing connectable
Your internal architecture stays intact. The front door becomes invisible.
Every existing solution operates after your infrastructure is already visible. LayerV adds the missing layer.
| VPN | ZTNA | Firewall | LayerV | |
|---|---|---|---|---|
| Encrypts traffic | ✓ | ✓ | ✗ | ✓ |
| Identity-based access | ✗ | ✓ | ✗ | ✓ |
| Blocks malicious traffic | ✗ | ✓ | ✓ | ✓ |
| Hides infrastructure from scans | ✗ | ✗ | ✗ | ✓ |
| Prevents reconnaissance | ✗ | ✗ | ✗ | ✓ |
| Zero exposed attack surface | ✗ | ✗ | ✗ | ✓ |
| No client/agent required | ✗ | ✗ | ✓ | ✓ |
Your IdP handles who gets access. LayerV handles who can see.
LayerV is in the trust chain. We’re built from the ground up to be there.
Only the coordination layer is publicly reachable — the piece that mints QURLs and brokers connections. Purpose-built to be exposed, hardened for that job, with a tiny attack surface compared to a typical web app.
The NHP knock mechanism uses UDP, not TCP. No handshake to exploit, no SYN floods, no connection state to exhaust. Invalid packets are silently dropped. There’s nothing to grab onto.
All communication secured using the Noise Protocol framework — the same foundation used by Signal and WireGuard. Mutual authentication happens cryptographically before any meaningful data is exchanged.
LayerV doesn’t store passwords or authenticate users directly — that’s your IdP. Even if LayerV were compromised, attackers couldn’t mint valid QURLs without authenticating through your identity system.
No public directory of LayerV customers. Attackers scanning the internet can’t identify which companies use NHP or which resources are protected. They can’t target what they can’t identify.
LayerV’s internal infrastructure is NHP-protected. The management plane, the control systems — none of it is visible to the public internet. Built on OpenNHP, the open standard developed with the Cloud Security Alliance.
LayerV captures and logs original source IPs. But more importantly, every connection carries cryptographic identity attribution that exceeds what IP logging alone provides.
{
"type": "qurl.accessed",
"owner_id": "auth0|user123",
"timestamp": "2025-01-08T10:35:00Z",
"data": {
"resource_id": "r_K8xQp9H2sJ9",
"access_token_id": "at_xyz789",
"src_ip": "192.168.1.100", // Original source IP captured
"user_agent": "Mozilla/5.0...",
"geo": "US", // Geo-resolved from source IP
"identity": "[email protected]" // Cryptographically verified
}
}
IP + verified identity + session context = attribution that stands up in court.
From zero-change integration to full infrastructure invisibility. Keep your existing IdP, keep your existing tools.
The fastest path. Generate temporary access credentials via REST API — no infrastructure changes required. Works with any web application.
Deep integration for applications with granular control over authentication flows. Node.js, TypeScript, Browser, React Native.
Zero-trust networking for cloud workloads. Drop-in protection for EKS, ECS, and EC2 without code changes.
Self-hosted on your infrastructure. Full control, air-gapped environments, regulatory compliance. Complete ownership of the stack.
Pick the resource that keeps you up at night. Prove it works in 30 days.