Install and configure X2 KMS

X2 KMS is a separately operated, sealed key-management service for X2 encrypted workloads. Complete this guide when every required X2 node is authorized, verified against one compatible keyspace, and the pending provider is active.

Choose one route

The production service with the Admin UI is the primary route. Selected values update only validated, copy-ready commands.

Operating system
Architecture
Deployment
Manage X2 with
Selected route Loading selection…
Published release Loading release…
01

Choose the deployment before initializing

Record the API address used by X2 nodes, the local operator URL, state paths, certificate names, and custodians. The KMS API and Raft peer address are different interfaces.

KMS API host and portUsed by X2 nodes and covered by the API certificate SAN.
Operator URLUsed from the protected administration session; it may be loopback.
KMS member ID and peer addressUnique to each Raft member and never reused as an X2 node name.
X2 node nameThe storage node being connected to X2 KMS.
  • Choose single server or cluster now
  • Use protected encrypted-state storage
  • Assign three or more unseal custodians
  • Confirm API reachability from every X2 node
  • Keep API and peer TLS material separate
  • Install X2 Node and X2 KMS from the same published release
Upgrade X2 KMS before the X2 nodes: current provider verification and key migration require the encrypt-data-key workload operation and its API endpoint. An older X2 KMS may accept the client identity but cannot satisfy the current verification contract. Upgrade every KMS member that can serve an X2 node, preserve its encrypted state and TLS identity, unseal it, and confirm KMS health before upgrading or verifying X2 nodes.
Configure the first member before initialization: initialize exactly one cluster member. Additional members can be added later as non-voters, receive the encrypted keyspace while sealed, and unseal with the original recovery shares. Follow Deploy an X2 KMS cluster; do not initialize a joining member independently.
Single-server route: continue directly to installation. A restart reseals the service and requires custodians to unseal it again.
02

Install the production service and check the sealed state

Use the artifact published for the selected OS and architecture. Verify its SHA-256 digest and detached signature from the immutable release manifest before installation; this guide does not invent unsupported OS or resource minimums.

Loading release catalog…
Loading release catalog…
Loading release catalog…

Install the native service

Run onEach KMS host
ShellBashPowerShellBash on macOS
PrivilegeAdministrator / root
Expected resultService starts initialized=false, sealed=true
sudo ./x2-kms service install \
  --address "0.0.0.0:{{plain:KMS_API_PORT}}" \
  --host {{arg:KMS_API_HOST}}
.\x2-kms.exe service install `
  --address "0.0.0.0:{{plain:KMS_API_PORT}}" `
  --host {{arg:KMS_API_HOST}}
sudo ./x2-kms service install \
  --address "0.0.0.0:{{plain:KMS_API_PORT}}" \
  --host {{arg:KMS_API_HOST}}

Review /etc/x2-kms/kms.yaml on Linux, C:\ProgramData\X2KMS\kms.yaml on Windows, or /usr/local/etc/x2-kms/kms.yaml on macOS. The installer retains existing configuration, TLS material, and encrypted state during an update.

Check process health and KMS state

Run onKMS host or protected operator workstation
State changeNone
Expected resultReachable process; KMS still uninitialized and sealed
sudo curl --fail \
  --cacert /var/lib/x2-kms/tls/kms-server.crt \
  {{arg:KMS_OPERATOR_URL}}/health
sudo env X2_KMS_SERVER_CERT=/var/lib/x2-kms/tls/kms-server.crt \
  /usr/lib/x2/x2-kms operator status --address {{arg:KMS_OPERATOR_URL}}
$ServerCertificate = 'C:\ProgramData\X2KMS\tls\kms-server.crt'
$OperatorUrl = {{arg:KMS_OPERATOR_URL}}
curl.exe --fail --cacert $ServerCertificate "$OperatorUrl/health"
$env:X2_KMS_SERVER_CERT = $ServerCertificate
& 'C:\Program Files\X2\x2-kms.exe' operator status --address $OperatorUrl
sudo curl --fail \
  --cacert /usr/local/var/lib/x2-kms/tls/kms-server.crt \
  {{arg:KMS_OPERATOR_URL}}/health
sudo env X2_KMS_SERVER_CERT=/usr/local/var/lib/x2-kms/tls/kms-server.crt \
  /usr/local/lib/x2/x2-kms operator status --address {{arg:KMS_OPERATOR_URL}}
Process reachable→Initialized + sealed→Unsealed + ready
03

Finish service configuration before initialization

Confirm the API listener, API certificate SAN, encrypted storage path, log path, and local operator trust. Keep the server private key on the KMS host. X2 nodes receive only the public issuing CA bundle or pinned server certificate.

The generated service configuration is the complete single-server baseline. See the minimal configuration reference for field names; treat fragments as additions to that file rather than replacement documents.

Configure Raft before initializing the first member

The first member needs a unique cluster.node_id, reachable peer address, member-specific API and peer certificate/private key, and empty local state paths. Restart the service after saving those settings and confirm members status reports the configured node ID and peer address before initializing that member once.

Later members use their own IDs, addresses, certificates, and empty state paths. They share the peer CA, recovery shares, encrypted Raft keyspace, and final workload authorization. Record KMS_MEMBER_ID, KMS_PEER_HOST, and KMS_PEER_PORT separately from the operator URL and X2 node name.

TLS proxy boundary: an ordinary HTTPS-terminating reverse proxy does not automatically preserve the X2 client certificate identity. Use direct end-to-end TLS or a topology explicitly supported for the selected release; otherwise withhold the proxy from the production route.
04

Initialize once, then unseal locally

Destructive boundary: run initialization exactly once for a new deployment. Joiners must never be initialized independently. Move the root token and five shares immediately into separate protected custody.
Run onFirst KMS member only
PrivilegeProtected KMS operator
Expected resultOne root token, five shares, initialized=true, sealed=true
sudo env X2_KMS_SERVER_CERT=/var/lib/x2-kms/tls/kms-server.crt \
  /usr/lib/x2/x2-kms operator init --address {{arg:KMS_OPERATOR_URL}}
$env:X2_KMS_SERVER_CERT = 'C:\ProgramData\X2KMS\tls\kms-server.crt'
& 'C:\Program Files\X2\x2-kms.exe' operator init --address {{arg:KMS_OPERATOR_URL}}
sudo env X2_KMS_SERVER_CERT=/usr/local/var/lib/x2-kms/tls/kms-server.crt \
  /usr/local/lib/x2/x2-kms operator init --address {{arg:KMS_OPERATOR_URL}}

Submit three different shares without shell history

Run onLocally for each initialized member
ShellBashPowerShell 7.1+Bash on macOS
Expected resultsealed=false and readiness succeeds
read -rsp 'Unseal share: ' SHARE; echo
printf '%s' "$SHARE" | sudo env X2_KMS_SERVER_CERT=/var/lib/x2-kms/tls/kms-server.crt \
  /usr/lib/x2/x2-kms operator unseal --address {{arg:KMS_OPERATOR_URL}} --key -
unset SHARE
# Repeat with two different shares.
$env:X2_KMS_SERVER_CERT = 'C:\ProgramData\X2KMS\tls\kms-server.crt'
Read-Host 'Unseal share' -MaskInput |
  & 'C:\Program Files\X2\x2-kms.exe' operator unseal --address {{arg:KMS_OPERATOR_URL}} --key -
# Repeat with two different shares.
read -rsp 'Unseal share: ' SHARE; echo
printf '%s' "$SHARE" | sudo env X2_KMS_SERVER_CERT=/usr/local/var/lib/x2-kms/tls/kms-server.crt \
  /usr/local/lib/x2/x2-kms operator unseal --address {{arg:KMS_OPERATOR_URL}} --key -
unset SHARE
# Repeat with two different shares.

Prompt masking limits accidental display and history capture; it is not a universal secret-isolation guarantee. Never place shares in the Admin UI, X2 configuration, service definitions, or automation logs.

05

Configure every X2 node connection

In System Configuration → Encryption & KMS, create a pending X2 KMS rollout. For each node, select Configure connection, then enter the API endpoint, shared workload identifier, and public server trust that validates that endpoint.

  1. Save connection settings for the selected node; X2 prepares everything else automatically.
  2. Use Apply these connection settings to all nodes only when endpoint, workload, and trust are intentionally identical.
  3. For different endpoints or issuers, configure each node with a trust bundle covering its own endpoint.
  4. Confirm every required node reports Prepared before continuing.
Endpoint, workload, and trust are public per-node connection settings. The client private key remains on its X2 node. Missing or incorrect trust is a setup prerequisite, not a late verification task.

The static route is restart-required and must be completed separately on every X2 node. Continue with Configure X2 without the Admin UI; do not mix static configuration and a runtime-managed rollout on the same node.

06

Authorize X2 node access

After every required connection is saved, the X2 Admin UI displays one authorization command for the entire X2 cluster. Node access material is generated and stored automatically.

Set X2_KMS_ADDR and X2_KMS_SERVER_CERT in the operator session. The copied block securely prompts for X2_KMS_TOKEN, runs on any unsealed KMS member, and removes the token from the session afterward:

Illustrative shape — use the exact command generated by X2 after selecting the KMS host operating system

read -rsp 'KMS root token: ' X2_KMS_TOKEN; echo
export X2_KMS_TOKEN
/usr/lib/x2/x2-kms workloads authorize --workload-id "workload-name" --client-key "sha256:one-64-character-lowercase-hex-digest-per-node"
unset X2_KMS_TOKEN
$env:X2_KMS_TOKEN = Read-Host 'KMS root token' -MaskInput
& 'C:\Program Files\X2\x2-kms.exe' workloads authorize --workload-id "workload-name" --client-key "sha256:one-64-character-lowercase-hex-digest-per-node"
Remove-Item Env:X2_KMS_TOKEN
read -rs 'X2_KMS_TOKEN?KMS root token: '; echo
export X2_KMS_TOKEN
/usr/local/lib/x2/x2-kms workloads authorize --workload-id "workload-name" --client-key "sha256:one-64-character-lowercase-hex-digest-per-node"
unset X2_KMS_TOKEN

The command detects the Raft leader, authorizes every node idempotently, creates the standard workload keys when needed, grants the required generate, decrypt, and encrypt-data-key operations, and commits the encrypted authorization through consensus. The root token remains in the operator shell and never enters X2 Node or the Admin UI.

Run onAny unsealed KMS member
State changeReplicated workload authorization
Expected resultAuthorized through KMS consensus
No KMS YAML edit, service restart, or unseal cycle is required for this authorization change.
07

Verify every node, activate, and prove data access

Confirm authorization replication first: after the command succeeds, confirm local replicas report caught_up=true, then verify X2 nodes using their configured co-located or remote KMS endpoints.
  1. Return to System Configuration → Encryption & KMS.
  2. Verify each required X2 node, then run cluster verification.
  3. Confirm TLS, client authorization, logical-key access, and cross-node keyspace attestation pass.
  4. Activate the pending provider only when every required node is ready.

Runtime activation is a separate operation from static node configuration. This route does not prescribe an X2 Node restart; follow the activation result and release-specific instructions rather than the static restart procedure.

Restart each statically configured X2 node only after its local files, ownership, endpoint, trust, workload ID, and local access material are complete. Confirm KMI is enabled in node health before testing data access.

Operational acceptance Write a new encrypted object through one X2 node. Read it through another required node. Confirm old encrypted data still reads. Record versions, endpoints, custodians, verification time, and rollback generation.
Keep previous provider generations and KMS keys while any existing object depends on them. Successful activation does not make old keys safe to retire.

Deploy an X2 KMS cluster

Start with one initialized voter and add members later without creating a second keyspace. A joining member first enters as a non-voter, receives the encrypted store while sealed, and uses the original recovery shares. Promotion waits for Raft catch-up and returns only after the member is a voter.

ValueMeaningExample
KMS_API_HOSTHostname used by X2 nodes and covered by API certificate SANkms.example.com
KMS_API_PORTKMS API port18200
KMS_OPERATOR_URLURL used from this protected operator sessionhttps://127.0.0.1:18200
KMS_MEMBER_IDUnique joining Raft member IDkms-2
KMS_PEER_HOSTReachable hostname of that joining memberkms-2.example.com
KMS_PEER_PORTJoining member Raft port18201
X2_NODE_NAMEStorage node being connected to X2 KMSstorage-1
One local KMS instance per X2 storage node

Each X2 node may use its co-located KMS API endpoint, such as https://127.0.0.1:18200. The KMS peer address must still be uniquely reachable by the other KMS members. Local unsealed replicas serve steady-state signing, data-key, decrypt, and read operations from the shared keyspace. Send membership, new-key creation, and rotation administration to the current KMS leader.

Use an odd voter count across independent failure domains. Additional co-located KMS instances may remain non-voters; promote only the members selected for the voting set.

1. Configure and initialize the first member

In that member's kms.yaml, configure its unique cluster.node_id, its routable cluster.address (the Raft listen and advertised address), an empty Raft storage directory, its peer certificate/private key, and the shared peer CA. Start the service with that configuration, confirm members status reports the intended node ID and peer address, then run step 4 exactly once on this first member.

2. Start a joining member without initializing it

Install X2 KMS on the new host and configure the same fields with that member's own ID, peer address, certificates, encrypted store path, and empty Raft directory. Copy the same peer CA and workload authorization. Start the service and confirm initialized=false. Never run operator init on this member.

3. Add the joining member on the current leader

Run onCurrent KMS leader
State changeAdds one non-voter
Expected resultstate=non-voter
read -rsp 'Root token: ' X2_KMS_TOKEN; echo; export X2_KMS_TOKEN
export X2_KMS_SERVER_CERT=/var/lib/x2-kms/tls/kms-server.crt
/usr/lib/x2/x2-kms members add --address {{arg:KMS_OPERATOR_URL}} \
  --node-id {{arg:KMS_MEMBER_ID}} \
  --peer-address "{{plain:KMS_PEER_HOST}}:{{plain:KMS_PEER_PORT}}"
unset X2_KMS_TOKEN
$env:X2_KMS_TOKEN = Read-Host 'Root token' -MaskInput
$env:X2_KMS_SERVER_CERT = 'C:\ProgramData\X2KMS\tls\kms-server.crt'
& 'C:\Program Files\X2\x2-kms.exe' members add --address {{arg:KMS_OPERATOR_URL}} `
  --node-id {{arg:KMS_MEMBER_ID}} `
  --peer-address "{{plain:KMS_PEER_HOST}}:{{plain:KMS_PEER_PORT}}"
Remove-Item Env:X2_KMS_TOKEN
read -rsp 'Root token: ' X2_KMS_TOKEN; echo; export X2_KMS_TOKEN
export X2_KMS_SERVER_CERT=/usr/local/var/lib/x2-kms/tls/kms-server.crt
/usr/local/lib/x2/x2-kms members add --address {{arg:KMS_OPERATOR_URL}} \
  --node-id {{arg:KMS_MEMBER_ID}} \
  --peer-address "{{plain:KMS_PEER_HOST}}:{{plain:KMS_PEER_PORT}}"
unset X2_KMS_TOKEN

4. Confirm encrypted-state catch-up on the joiner

Run members status against the joiner's local API. Continue when its node ID is correct, state is Follower, suffrage is Nonvoter, initialized=true, sealed=true, caught_up=true, and promotion_ready=true. The reported applied_index must be at least commit_index.

sudo env X2_KMS_SERVER_CERT=/var/lib/x2-kms/tls/kms-server.crt \
  /usr/lib/x2/x2-kms members status --address https://127.0.0.1:{{plain:KMS_API_PORT}}
$env:X2_KMS_SERVER_CERT = 'C:\ProgramData\X2KMS\tls\kms-server.crt'
& 'C:\Program Files\X2\x2-kms.exe' members status --address https://127.0.0.1:{{plain:KMS_API_PORT}}
sudo env X2_KMS_SERVER_CERT=/usr/local/var/lib/x2-kms/tls/kms-server.crt \
  /usr/local/lib/x2/x2-kms members status --address https://127.0.0.1:{{plain:KMS_API_PORT}}

Unseal the joiner locally with three distinct original shares. It must not receive new shares and must not be initialized independently.

5. Optionally promote the member

Skip this step when the co-located instance should remain a non-voting local replica. To add it to the selected odd voting set, run promotion on the leader. The command stages the member, waits for Raft catch-up, and succeeds only after members list reports Voter.

read -rsp 'Root token: ' X2_KMS_TOKEN; echo; export X2_KMS_TOKEN
export X2_KMS_SERVER_CERT=/var/lib/x2-kms/tls/kms-server.crt
/usr/lib/x2/x2-kms members promote --address {{arg:KMS_OPERATOR_URL}} --node-id {{arg:KMS_MEMBER_ID}}
/usr/lib/x2/x2-kms members list --address {{arg:KMS_OPERATOR_URL}}
unset X2_KMS_TOKEN
$env:X2_KMS_TOKEN = Read-Host 'Root token' -MaskInput
$env:X2_KMS_SERVER_CERT = 'C:\ProgramData\X2KMS\tls\kms-server.crt'
& 'C:\Program Files\X2\x2-kms.exe' members promote --address {{arg:KMS_OPERATOR_URL}} --node-id {{arg:KMS_MEMBER_ID}}
& 'C:\Program Files\X2\x2-kms.exe' members list --address {{arg:KMS_OPERATOR_URL}}
Remove-Item Env:X2_KMS_TOKEN
read -rsp 'Root token: ' X2_KMS_TOKEN; echo; export X2_KMS_TOKEN
export X2_KMS_SERVER_CERT=/usr/local/var/lib/x2-kms/tls/kms-server.crt
/usr/local/lib/x2/x2-kms members promote --address {{arg:KMS_OPERATOR_URL}} --node-id {{arg:KMS_MEMBER_ID}}
/usr/local/lib/x2/x2-kms members list --address {{arg:KMS_OPERATOR_URL}}
unset X2_KMS_TOKEN
Adding a member to an existing X2 KMS cluster is supported; converting an independently initialized standalone KMS into a member is not. Remove only empty, independently initialized test state and restart the join procedure—never overwrite a production encrypted store or Raft directory.

Evaluate X2 KMS locally

This disposable loopback route is separate from production. It runs one foreground HTTP service, uses local paths, and must not be exposed to another host.

Run onDisposable local workstation
ShellBashPowerShellBash on macOS
PrivilegeOrdinary local user
Expected resultForeground loopback service; no TLS
mkdir -p "$PWD/x2-kms-data"
./x2-kms server --address "127.0.0.1:{{plain:KMS_API_PORT}}" \
  --storage "$PWD/x2-kms-data/store.json.enc"
$DataRoot = Join-Path (Get-Location) 'x2-kms-data'
New-Item -ItemType Directory -Force $DataRoot | Out-Null
.\x2-kms.exe server --address "127.0.0.1:{{plain:KMS_API_PORT}}" `
  --storage "$DataRoot\store.json.enc"
mkdir -p "$PWD/x2-kms-data"
./x2-kms server --address "127.0.0.1:{{plain:KMS_API_PORT}}" \
  --storage "$PWD/x2-kms-data/store.json.enc"

In another terminal, check http://127.0.0.1:<selected-port>/health, initialize once, and use the masked share procedure from step 4 with the HTTP loopback address and no server-certificate variable. Delete this disposable state only when it contains no data required by any X2 object.

Configure X2 without the Admin UI

Static, restart-required configuration

Run on each X2 node. Obtain the matching X2 KMS CLI from the selected release, copy only public server trust to that node, and write client material into its protected secrets path. Set ownership to the service account created by that node's native installation; the account name is platform and release dependent, so this guide does not invent one.

sudo /usr/lib/x2/x2-kms workloads generate-identity \
  --name {{arg:X2_NODE_NAME}} \
  --out-dir /data/x2/metadata/.x2/state/secrets \
  --kms-endpoint "https://{{plain:KMS_API_HOST}}:{{plain:KMS_API_PORT}}" \
  --server-certificate {{arg:NEW_KMS_SERVER_CERT}}
& 'C:\Program Files\X2\x2-kms.exe' workloads generate-identity `
  --name {{arg:X2_NODE_NAME}} `
  --out-dir 'D:\x2\metadata\.x2\state\secrets' `
  --kms-endpoint "https://{{plain:KMS_API_HOST}}:{{plain:KMS_API_PORT}}" `
  --server-certificate {{arg:NEW_KMS_SERVER_CERT}}
sudo /usr/local/lib/x2/x2-kms workloads generate-identity \
  --name {{arg:X2_NODE_NAME}} \
  --out-dir /Volumes/X2Metadata/.x2/state/secrets \
  --kms-endpoint "https://{{plain:KMS_API_HOST}}:{{plain:KMS_API_PORT}}" \
  --server-certificate {{arg:NEW_KMS_SERVER_CERT}}

Run the printed workloads authorize command on any unsealed KMS member. It preserves existing identities, replicates the authorization, and requires no restart. Then configure this X2 node:

sudo /usr/lib/x2/x2-node configure \
  --kmi-enabled --kmi-provider x2-kms \
  --x2-kms-endpoint "https://{{plain:KMS_API_HOST}}:{{plain:KMS_API_PORT}}" \
  --x2-kms-workload-id {{arg:WORKLOAD_ID}} \
  --x2-kms-server-cert {{arg:NEW_KMS_SERVER_CERT}} \
  --x2-kms-client-cert {{arg:NEW_KMS_CLIENT_CERT}} \
  --x2-kms-client-key {{arg:NEW_KMS_CLIENT_KEY}}
sudo systemctl restart x2-node
& 'C:\Program Files\X2\x2-node.exe' configure `
  --kmi-enabled --kmi-provider x2-kms `
  --x2-kms-endpoint "https://{{plain:KMS_API_HOST}}:{{plain:KMS_API_PORT}}" `
  --x2-kms-workload-id {{arg:WORKLOAD_ID}} `
  --x2-kms-server-cert {{arg:NEW_KMS_SERVER_CERT}} `
  --x2-kms-client-cert {{arg:NEW_KMS_CLIENT_CERT}} `
  --x2-kms-client-key {{arg:NEW_KMS_CLIENT_KEY}}
Restart-Service X2Node
sudo /usr/local/lib/x2/x2-node configure \
  --kmi-enabled --kmi-provider x2-kms \
  --x2-kms-endpoint "https://{{plain:KMS_API_HOST}}:{{plain:KMS_API_PORT}}" \
  --x2-kms-workload-id {{arg:WORKLOAD_ID}} \
  --x2-kms-server-cert {{arg:NEW_KMS_SERVER_CERT}} \
  --x2-kms-client-cert {{arg:NEW_KMS_CLIENT_CERT}} \
  --x2-kms-client-key {{arg:NEW_KMS_CLIENT_KEY}}

XC runtime rollout

The short XC snippet previously shown here was incomplete: it omitted the versioned provider JSON schema, authentication, rollout-ID capture, consensus workload authorization, and verification handoff. It is therefore withheld from copy-ready instructions until a complete, release-tested procedure is published.

Operate and recover X2 KMS

Restart and unseal

A restart reseals that member. Restore process health, submit three different shares locally, confirm readiness, and then verify X2 access. Never automate shares through X2 Node or the Admin UI.

Backup and restore

No portable backup/restore CLI is established here. Preserve storage-consistent encrypted state and complete Raft data where applicable, with custody material stored separately. Test restore on isolated hosts with the same release before relying on it.

Certificate and identity rotation

Overlap old and new public trust before changing the server certificate. Add a replacement node SPKI before switching that node and retain the old SPKI until the replacement verifies.

Upgrade and member replacement

Upgrade every serving X2 KMS member to the X2 release being installed before upgrading X2 nodes. Preserve encrypted state, Raft state, TLS material, workload identities, and unseal custody. Record member and KMS health before and after each change; do not initialize a replacement over existing state or guess at promotion criteria.

Troubleshoot by state boundary

Process unreachable

Check the service, selected API port, DNS, firewall, and reachability from the affected X2 node—not only from the browser.

Initialized but sealed

Submit three distinct shares locally. Do not regenerate identities or initialize again.

TLS or hostname failure

Match the endpoint host to the certificate SAN and configure the correct issuing chain or pinned public certificate.

Unauthorized SPKI

Run the generated workloads authorize command again and confirm that the member reports consensus authorization for every node SPKI.

Credential connected but operations denied

Confirm X2 KMS is from the same published release as X2 Node and that the workload authorization includes encrypt-data-key. This is authorization failure after successful client authentication.

Verification passes on one node only

Compare per-node endpoint and trust, replicated workload authorization, follower catch-up, and logical-key compatibility.

Old data cannot decrypt

Restore access to the provider generation and keys that encrypted it. Do not retire old keys as part of activation cleanup.

TerminologyNames used consistently throughout this guide
KMS memberOne server process in an X2 KMS deployment.
X2 nodeOne storage node that keeps its own KMS client identity.
WorkloadThe shared authorization item containing node SPKIs and exact key grants.
SPKIThe public-key fingerprint used to authorize a node identity; it is not a private key.
Provider generationA versioned X2 provider configuration retained for data and rollback compatibility.
UnsealSubmit the custody threshold after initialization or restart so KMS can use protected state.