Signing
ScaiVault holds private keys you never see and signs bytes with them on request. You send the bytes, ScaiVault returns the signature, and the private key never leaves the service.
Use it when your application builds its own signed objects — tokens, COSE messages, revocation lists, release manifests — and you want the key held in one audited place instead of in each service's memory. For X.509 certificates, use PKI instead: it builds and signs the certificate for you.
What's in it#
- Signing keys, addressed by path (
sign/acme/release-manifest). One key per path per tenant. - Three suites: Ed25519, ECDSA P-384 and the post-quantum ML-DSA-65.
- Versions: rotating a key adds a version; signatures from older versions keep verifying.
- Access control: scopes, an optional per-role path allow-list, and an optional rate limit per key.
- An audit trail of every signature and every lifecycle change.
Suites#
A key's suite is fixed when you create it.
| Suite | Algorithm | Public key | Signature | Notes |
|---|---|---|---|---|
s3-ed25519 |
Ed25519 | 32 bytes, raw | 64 bytes | Default |
s2-ecdsa-p384 |
ECDSA P-384 with SHA-384 | SubjectPublicKeyInfo, DER | DER, about 103 bytes | Can also sign a precomputed 48-byte SHA-384 digest |
s4-mldsa65 |
ML-DSA-65 (FIPS 204) | 1,952 bytes, raw | 3,309 bytes | Post-quantum |
ScaiVault implements the FIPS 204 algorithm for ML-DSA-65. The cryptographic module is not FIPS 140-3 validated.
Keys never leave#
- Keys are generated inside ScaiVault.
- No endpoint and no scope returns a private key — not to administrators either. There is no export, and no import.
- At rest, each private key is encrypted under its partner's master key, which the deployment's root-key backend protects.
- Destroying a key deletes the private part of every version. Public keys are kept, so signatures made earlier still verify.
Because nothing can be exported, a key cannot be copied to a second system. If you need the same key in two places, keep calling the one ScaiVault that holds it.
Lifecycle#
| State | Signs | Verifies | Reached by |
|---|---|---|---|
active |
Yes | Yes | Create, enable |
disabled |
No | Yes | Disable |
destroyed |
No | Yes | Destroy — permanent |
Rotation works on an active key. It creates a new version and makes it the signer; earlier versions stay available for verification. A verify call without a version checks every version, newest first, and reports which one matched in matched_version. Pass version to accept only one.
Who can use a key#
Each operation needs a scope:
| Scope | Allows |
|---|---|
sign:create |
Create keys |
sign:use |
Sign and batch-sign |
sign:read |
List keys, fetch public keys, verify |
sign:manage |
Rotate, disable, enable |
sign:destroy |
Destroy — a separate grant because it can't be undone |
Scopes alone reach every key in the tenant. To pin a credential to its own keys, give its role a sign_path_prefixes constraint: the credential can then create, use, see and manage only keys at or under those paths. Matching is per path segment, so sign/acme covers sign/acme/release-manifest but not sign/acmex. A request outside the prefix gets 403 access_denied. To keep one key inside a prefix away from a credential, add it to sign_path_excludes; an exclusion always wins. The recommended setup is one service account per signing component, each pinned to its own prefix — see Restrict a service account to its own keys.
A key can also carry a rate limit, rate_limit_per_min, set when you create it. A batch counts one unit per message. Signing has no default limit; without rate_limit_per_min only the key's tenant and scopes gate it.
Audit#
Every signature is logged with the caller, the time, the SHA-256 of the message, the key, the version and the suite (action sign.sign). These records are written in the background so they don't slow signing; a process crash can lose the most recent ones. Lifecycle changes — sign.key.create, sign.key.rotate, sign.key.disable, sign.key.enable, sign.key.destroy — are written in the same transaction as the change, so a change never happens without its record. Both appear in the audit log with resource type signing_key.
Performance#
On a 4-vCPU host, one signature takes under 12 ms at p99 for every suite, including ML-DSA-65. A single batch call signs about 5,900 Ed25519 or 600 ML-DSA-65 messages per second.
What's next#
- Signing guide — create a key, sign, verify, rotate, restrict access
- Signing reference — every endpoint and error code
- SDKs: Python, JavaScript, .NET, Rust