Loading the invitation…
Sign in with the password you set from the platform's email. A window opens for it.
What the platform needs to set your organization up, as its admin enters it for your license.
Every key you hold for this onboarding is protected by one passphrase.
For each, the page either makes it, saves it to your downloads
encrypted with that passphrase, and uses it at once; or loads a key
file you already have. To make one on the command line instead, with
the same passphrase:
openssl genpkey -algorithm ed25519 -aes-256-cbc -out
<file>.pem.
Your keys and the passphrase never leave this window: the keys are made and used here, and saved only to your own files, encrypted with the passphrase. The platform receives only their public keys, and the signatures they make.
This page creates your parties' signing keys at your custodian, by
calling its API as the service account
org-onboarding with the
permission onboarding, which allows it to create keys. It
signs in to the custodian with a key of its own that we'll create now,
and will share its public part with the custodian.
org-onboarding with that
public key (shown above once the key is made or loaded; for a key
made on the command line:
openssl pkey -in
file -pubout) and the permission onboarding. Leave its OIDC
issuer, identity and external ID empty. Once created, DFNS shows its
token once, copy it and paste into the input field below.
The account's key, token and credential ID never reach the platform: this window sends them only to your custodian, encrypted (HTTPS), to make the signing keys and ask for their signatures, and forgets the token when you close it.
Fireblocks' API cannot be called from a web page,Your TSB is called with a credential, and perhaps a client
certificate, that a web page should not hold,
so your parties' keys are made from a terminal of yours instead: you
paste the commands below into it, and paste back what they print. They
use curl, openssl (3 or later; on macOS,
brew install openssl@3, as its own is LibreSSL) and
jq, in bash or zsh (macOS, Linux, or WSL on Windows).
org-onboarding with the
role Non-Signing Admin (or another that can create vault accounts
and initiate transactions). Let the console generate its key pair:
it downloads the private key as
fireblocks_secret.key.
Move it to a folder of yours, where your parties' keys will be too.
Then copy its API user ID here:
securosys-onboarding.token; or its API keys in
securosys-key-management.key and
securosys-key-operation.key. If your TSB asks for a
client certificate, export
SECUROSYS_TSB_MTLS_P12_FILE and
SECUROSYS_TSB_MTLS_P12_PASSWORD in the terminal first.
Give the onboarding API user's ID first.
fb: one call to Fireblocks' API, as the
onboarding API user, with the short-lived token Fireblocks
asks of each call, signed with
fireblocks_secret.key.
tsb: one call to your TSB's API, with the
credential from your folder (the token, or the API key of the
call's role), given to curl on its standard
input, never on its command line.
custodian_key finds or makes a party's signing
key: the key of a vault account named after the party: a TSB Ed25519 key, made non-destroyable, labelled as the
gateway looks it up (its public key), its label kept in
<party>.securosys for a rerun; custodian_sign has it sign a hash, and waits
for any approvals.
party_keys, used next: makes (or reads) each
party's namespace key, finds or makes its signing key, and
prints both public keys.
party_sign, used at the review: signs each
party's two transactions with its namespace key, has your
custodian sign its hosting with its signing key, and prints
the signatures.
party_passphrase asks for the
namespace keys' passphrase, party_ns_sign signs a
hash with a namespace key, party_openssl checks
for OpenSSL 3, and the rest encode.
Each sets nothing else in your shell but the variables at the top; the passphrase is kept by none of them.
<party>.pem,
encrypted with a passphrase it asks for (of 12 characters or more; a
key there already is read with it), finds or makes its signing key
at your custodian, and prints both public keys:
Your custodian credential and the namespace keys stay in your folder: your terminal calls your custodian with the one, and signs the parties' transactions with the others, and sends the calls straight to your custodian, encrypted (HTTPS). Neither this page nor the platform sees them or the passphrase, or what your custodian answers beyond what you paste back: where each signing key is, and the public keys.
Each party has a namespace key, which signs the two onboarding
transactions that create it and its hosting. The command above makes
each one in your folder, <party>.pem, encrypted with
the passphrase it asks for, and the command at the next step signs with
it there. Neither this page nor the platform
ever has it: they get its public key, and its signatures. Back the files
up offline, with their passphrase: they alone can change a party later,
its signing key or where it is hosted.
Each party has a namespace key, which signs the two onboarding
transactions that create it and its hosting. The page makes each key
in your browser, saves it to your downloads encrypted with the
passphrase, and uses it at once; or loads a key file you already have.
To make one on the command line instead, with the same passphrase:
openssl genpkey -algorithm ed25519 -aes-256-cbc -out
<file>.pem.
Make or load a namespace key for each of your parties. It signs, here, the Canton transactions that create the party, which the platform's onboarding service then puts to its node. The key never leaves this page and is never sent to the platform: it is saved only to your own files, encrypted with the passphrase. Back it up: it alone can change the party later, its signing key or where it is hosted.
What each party's two onboarding transactions say, checked in this window before anything is signed. Each party's namespace key signs both of its transactions; its signing key at your custodian signs the hosting too, under your custodian's approval policy.
In the same terminal and folder, paste this. For each party, it signs its two transactions with its namespace key (asking for the passphrase), asks your custodian to sign the hosting with its signing key, waits while your approvers approve it, if your custodian's policy asks them to (a Fireblocks Sandbox signs at once), and prints the signatures:
The page checks each signature against its party's keys before anything is sent.
Your parties are hosted on the platform's node. Your users can sign in at , and transact once the platform offers your organization its license.
Back up your namespace key files and their passphrase offline. You need them only to change a party's keys or where it is hosted; nobody else has them.