What ships

Inside noct.wtf

Seventeen things, deliberately. Each one exists because something hand-rolled used to sit in its place — and each one is a call, not a project.

01 — Keys

Minting and licensing

Everything that decides who gets a key, what it unlocks, and how long it lives.

Batch key generation

Mint one key or ten thousand in a single call. Prefix, length, character set, and duration are set per batch, and the panel hands the list back ready to paste into a store listing.

Batch size
1 – 10,000
Character set
custom
Export
CSV · TXT · JSON

Device binding

A key locks to the first machine that verifies it and refuses every other. Fingerprints are hashed in the client, so the panel never sees the raw identifiers — and one click releases the key for a new machine.

Fingerprint
hashed client-side
Rebind
owner only
Refusal
stable reason code

Duration and expiry

Fixed days, lifetime, or a window that starts on first activation instead of purchase. Expiry fires a webhook before it lands, so your app can warn the user instead of dying mid-session.

Modes
fixed · lifetime · first-use
Warning hook
72 h before
Grace
configurable

Seats and concurrency

One key can carry several seats. Set how many machines may hold it at once, cap concurrent sessions, and release a seat the moment a user signs out cleanly.

Seats
1 – N
Concurrent cap
per key
Release
on clean logout

02 — Binding

Hardware and anti-abuse

The part that makes a copied key worthless and a patched client useless.

Hardware locking

The first redemption binds the key to a composite device fingerprint — CPU, board, disk serial, volume ID, MAC set, and OS install ID folded into one hash. A key carried to a second machine is refused before the app window finishes painting.

Signals folded
6+
Digest
SHA-256
Bind point
first redeem

Anti HWID spoofing

Spoofing a serial does not escape the binding — it breaks it. The fingerprint is signed server-side at bind time, so a swapped component produces a token that no longer matches the one on record. There is no spoofed value that verifies, only a mismatch that revokes.

Spoof result
self-revoke
Drift check
every heartbeat
Record
signed server-side

HWID resets

A user swaps a motherboard and needs their seat back. They can self-serve a reset up to a quota you set, or you clear it from the panel. Either path logs who did it, from where, and when.

Self-serve quota
per key
Cooldown
24 h
Audit
actor · IP · time

Anti reverse engineering

There is no local branch that returns true. Every grant is minted on the server, signed, and expires in sixty seconds, so patching the client only changes which request gets refused.

Verdict
server-minted
Signature
Ed25519
Lifetime
60 s

Tamper response

Replayed tokens are rejected by nonce, responses can be certificate-pinned, and the native clients can be told to watch for an attached debugger. Anything unexpected fails closed — the app gets a refusal, never a stale yes.

Replay guard
nonce
Pinning
opt-in
Failure mode
closed

03 — Control

Sessions and operations

What you can do to a running client, and what you can see while it runs.

Session control

Kill a live session from the dashboard and the client is signed out on its next heartbeat. The interval is yours to set, from fifteen seconds up, so revocation lands as fast as your app can tolerate.

Heartbeat
15 – 300 s
Force sign-out
next beat
Per-device revoke
yes

Signed webhooks

activation, reset, ban, and expiry each fire an HMAC-signed POST to a URL you own. Retries back off for six hours before the event is parked, so a five-minute outage does not lose an activation.

Signature
HMAC-SHA256
Retry window
6 h
Events
4

Live metrics

Verifications, refusals, resets, and active sessions per application, refreshed on a ten-second tick. No sampling, no warehouse, no export step before you can read a number.

Refresh
10 s
Scope
per app
History
90 days

Audit log

Every key minted, reset, banned, or edited is a row with the actor, the source IP, and the before-and-after state. When a customer swears they never shared their key, the log answers for you.

Fields
actor · IP · diff
Retention
90 days
Export
JSON

04 — Build

Developer surface

The parts you integrate against, and the walls between one app and the next.

Per-app isolation

Every application gets its own secret, key namespace, user pool, and webhook endpoint. A leaked secret burns one application, never the account holding the rest.

Applications
unlimited
Secrets
per app
Namespace
isolated

Sub-user accounts

Each application can carry its own user table — username, password hash, expiry, and device binding. Sell seats inside your app without standing up a second backend for logins.

Users per key
unlimited
Hash
argon2id
Fields
name · expiry · device

REST API

Everything the panel does is an endpoint, so you can script the whole thing. Bearer auth, idempotency keys on writes, and a documented error shape that does not change between versions.

Auth
bearer
Rate limit
600 / min
Idempotency
on writes

Offline grace

A key can validate offline for a window you choose, usually twenty-four to seventy-two hours. After that the client has to reach the API once to renew — a network hiccup slows a check, it never bricks a paying user.

Window
24 – 72 h
Renew
on reconnect
After window
fails closed

05 — Compared

Against rolling your own

The same job, done by hand, at three in the morning.

Key deliveryHand —hand-written SQL and a CSVnoct —one call, any batch size
HWID bindingHand —a hash you maintain yourselfnoct —6+ signals, signed server-side
Spoofed hardwareHand —silently acceptednoct —binding breaks, key revokes
Revoke a clientHand —wait for the user to restartnoct —next heartbeat, under a minute
Patched binaryHand —local check, flipped in an editornoct —no local verdict to flip
Offline behaviourHand —unbounded, or bricksnoct —bounded window, then renews
Panel and metricsHand —another app to buildnoct —ships with the account
A leaked secretHand —the whole productnoct —one application

Client libraries

Fifteen first-party targets, one shape of call. If your language is not here, the endpoint is a plain HTTPS POST and the docs spell out the request body.