@cubist-labs/cubesigner-sdk 0.1.50 → 0.1.77

package/README.md

@@ -113,7 +113,8 @@ transaction. For that, we need a key of type `Secp256k1.Evm`.
 const secpKey = await org.createKey(cs.Secp256k1.Evm);
 assert((await secpKey.owner()) == me.user_id);
 assert(await secpKey.enabled());
-console.log(`Created '${await secpKey.type()}' key ${secpKey.id}`);
+assert(await secpKey.type(), cs.Secp256k1.Evm);
+console.log(`Created '${cs.Secp256k1.Evm}' key ${secpKey.id}`);
 ```
 
 ### Create a `Role` and a `SignerSession`
@@ -351,12 +352,29 @@ export the underlying token:
 const oidcToken = await cubesigner.sessionMgr!.token();
 ```
 
-and then exchange it for either a _signer_ session (i.e., an instance
-of `SignerSession`, required by all signing endpoints, e.g.,
-`signEvm`)
+Before we can use the OIDC token for authentication, we must add an org policy
+to allow the particular issuer/audience pair from the token.
 
 ```typescript
-const oidcSession = new cs.SignerSession(await cubesigner.oidcAuth(oidcToken, org.id, ["sign:*"]));
+const oldOrgPolicy = await org.policy();
+const oidcPayload = JSON.parse(atob(oidcToken.split(".")[1].replace(/-/g, "+").replace(/_/g, "/")));
+const oidcAuthSourcesPolicy = {
+  OidcAuthSources: {
+    [oidcPayload.iss]: [oidcPayload.aud],
+  },
+};
+console.log("Setting org policy", oidcAuthSourcesPolicy);
+await org.setPolicy([oidcAuthSourcesPolicy]);
+```
+
+Finally, exchange the OIDC token for either a _signer_ session (i.e., an instance
+of `SignerSession`, required by all signing endpoints, e.g., `signEvm`)
+
+```typescript
+const oidcSession = new cs.SignerSession(
+  // we'll use this session for both signing and approving MFA request, hence the following scopes
+  await cubesigner.oidcAuth(oidcToken, org.id, ["manage:mfa", "sign:*"]),
+);
 ```
 
 or a _management_ session (i.e., and instance of `CubeSigner`,
@@ -382,26 +400,56 @@ doesn't matter if that user is native to CubeSigner or a third-party
 OIDC user. For that purpose, in this section we are going to use the
 previously created `oidcCubeSigner` instance.
 
-To set up TOTP, we call the `resetTotp` method which creates a new
-TOTP configuration for the users (overwriting the previous one, if
-any) and returns a [TOTP
-url](https://github.com/google/google-authenticator/wiki/Key-Uri-Format).
+To set up TOTP, we first call the `resetTotpStart` method to initiate a
+TOTP reset procedure.
 
 ```typescript
 console.log(`Setting up TOTP for user ${me.email}`);
-const totpResp = await oidcCubeSigner.resetTotp();
-assert(totpResp.totp_url);
+let totpResetResp = await oidcCubeSigner.resetTotpStart();
 ```
 
+If the user has already configured TOTP (or any other form of MFA),
+this response will require multi factor authentication. In that case,
+for example, call `approveTotp` and provide the code for the existing
+TOTP to proceed:
+
+```typescript
+import { authenticator } from "otplib"; // npm install otplib@12.0.1
+
+let totpSecret = process.env["CS_USER_TOTP_SECRET"]!;
+if (totpResetResp.requiresMfa()) {
+  console.log("Resetting TOTP requires MFA");
+  const code = authenticator.generate(totpSecret);
+  totpResetResp = await totpResetResp.approveTotp(oidcSession, code);
+  assert(!totpResetResp.requiresMfa());
+  console.log("MFA approved using existing TOTP");
+}
+```
+
+The response contains a TOTP challenge, i.e., a new TOTP
+configuration in the form of the standard
+[TOTP url](https://github.com/google/google-authenticator/wiki/Key-Uri-Format).
 From that url, we can generate a QR code to present to the user, or
 create an authenticator for automated testing.
 
 ```typescript
-import { authenticator } from "otplib"; // npm install otplib@12.0.1
+const totpChallenge = totpResetResp.data();
+assert(totpChallenge.totpUrl);
+```
 
-const totpSecret = new URL(totpResp.totp_url).searchParams.get("secret");
+To complete the challenge, we must call `resetTotpComplete` and
+provide the TOTP code matching the TOTP configuration from the challenge:
+
+```typescript norun
+totpSecret = new URL(totpChallenge.totp_url).searchParams.get("secret");
 assert(totpSecret);
+await totpChallenge.answer(authenticator.generate(totpSecret));
+```
+
+After TOTP is configured, we can double check that our authenticator
+is generating the correct code by calling `verifyTotp`
 
+```typescript
 console.log(`Verifying current TOTP code`);
 let code = authenticator.generate(totpSecret);
 await oidcCubeSigner.verifyTotp(code);
@@ -461,6 +509,11 @@ we created.
 console.log("Cleaning up");
 await session.sessionMgr.revoke();
 await role.delete();
+
+// restore the old policy for the sake of repeatability of this example
+// (normally you'd set your org policies once and leave them be)
+console.log("Restoring org policy", oldOrgPolicy);
+await org.setPolicy(oldOrgPolicy);
 ```
 
 As of now, deleting keys is not supported.

package/dist/src/ethers/index.js

@@ -148,12 +148,17 @@ _Signer_address = new WeakMap(), _Signer_key = new WeakMap(), _Signer_signerSess
 async function _Signer_handleMfa(res) {
     while (res.requiresMfa()) {
         await new Promise((resolve) => setTimeout(resolve, __classPrivateFieldGet(this, _Signer_mfaPollIntervalMs, "f")));
-        const mfaInfo = await __classPrivateFieldGet(this, _Signer_signerSession, "f").getMfaInfo(__classPrivateFieldGet(this, _Signer_managementSession, "f"), res.mfaId());
+        const mfaId = res.mfaId();
+        const mfaInfo = await __classPrivateFieldGet(this, _Signer_signerSession, "f").getMfaInfo(__classPrivateFieldGet(this, _Signer_managementSession, "f"), mfaId);
         __classPrivateFieldGet(this, _Signer_onMfaPoll, "f").call(this, mfaInfo);
         if (mfaInfo.receipt) {
-            res = await res.signWithMfaApproval(mfaInfo);
+            res = await res.signWithMfaApproval({
+                mfaId,
+                mfaOrgId: __classPrivateFieldGet(this, _Signer_signerSession, "f").orgId,
+                mfaConf: mfaInfo.receipt.confirmation,
+            });
         }
     }
     return res.data();
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/ethers/index.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  JsonRpcApiProvider,\n  TypedDataDomain,\n  TypedDataEncoder,\n  TypedDataField,\n  ethers,\n  getBytes,\n  toBeHex,\n} from \"ethers\";\nimport {\n  BlobSignRequest,\n  EvmSignRequest,\n  MfaRequestInfo,\n  SignerSession,\n  SignResponse,\n} from \"../signer_session\";\nimport { KeyInfo } from \"../key\";\nimport { CubeSigner } from \"..\";\n\n/** Options for the signer */\ninterface SignerOptions {\n  /** Optional provider to use */\n  provider?: null | ethers.Provider;\n  /**\n   * The function to call when MFA information is retrieved. If this callback\n   * throws, no transaction is broadcast.\n   */\n  onMfaPoll?: (arg0: MfaRequestInfo) => void;\n  /**\n   * The amount of time (in milliseconds) to wait between checks for MFA\n   * updates. Default is 1000ms\n   */\n  mfaPollIntervalMs?: number;\n  /** Optional management session. Used to check for MFA updates */\n  managementSession?: CubeSigner;\n}\n\n/**\n * A ethers.js Signer using CubeSigner\n */\nexport class Signer extends ethers.AbstractSigner {\n  /** The address of the account */\n  readonly #address: string;\n\n  /** The key to use for signing */\n  #key?: KeyInfo;\n\n  /** The underlying session */\n  readonly #signerSession: SignerSession;\n\n  /**\n   * The function to call when MFA information is retrieved. If this callback\n   * throws, no transaction is broadcast.\n   */\n  readonly #onMfaPoll: (arg0: MfaRequestInfo) => void;\n\n  /** The amount of time to wait between checks for MFA updates */\n  readonly #mfaPollIntervalMs: number;\n\n  /** Optional management session, used for MFA flows */\n  readonly #managementSession?: CubeSigner;\n\n  /** Create new Signer instance\n   * @param {KeyInfo | string} address The key or the eth address of the account to use.\n   * @param {SignerSession} signerSession The underlying Signer session.\n   * @param {SignerOptions} options The options to use for the Signer instance\n   */\n  constructor(address: KeyInfo | string, signerSession: SignerSession, options?: SignerOptions) {\n    super(options?.provider);\n    if (typeof address === \"string\") {\n      this.#address = address;\n    } else {\n      this.#address = address.materialId;\n      this.#key = address as KeyInfo;\n    }\n    this.#signerSession = signerSession;\n    this.#onMfaPoll = options?.onMfaPoll ?? ((/* _mfaInfo: MfaRequestInfo */) => {}); // eslint-disable-line @typescript-eslint/no-empty-function\n    this.#mfaPollIntervalMs = options?.mfaPollIntervalMs ?? 1000;\n    this.#managementSession = options?.managementSession;\n  }\n\n  /** Resolves to the signer address. */\n  async getAddress(): Promise<string> {\n    return this.#address;\n  }\n\n  /**\n   *  Returns the signer connected to %%provider%%.\n   *  @param {null | ethers.Provider} provider The optional provider instance to use.\n   *  @return {Signer} The signer connected to signer.\n   */\n  connect(provider: null | ethers.Provider): Signer {\n    return new Signer(this.#address, this.#signerSession, { provider });\n  }\n\n  /**\n   * Signs a transaction. This populates the transaction type to `0x02` (EIP-1559) unless set. This method will block if the key requires MFA approval.\n   * @param {ethers.TransactionRequest} tx The transaction to sign.\n   * @return {Promise<string>} Hex-encoded RLP encoding of the transaction and its signature.\n   */\n  async signTransaction(tx: ethers.TransactionRequest): Promise<string> {\n    // get the chain id from the network or tx\n    let chainId = tx.chainId;\n    if (chainId === undefined) {\n      const network = await this.provider?.getNetwork();\n      chainId = network?.chainId?.toString() ?? \"1\";\n    }\n\n    // Convert the transaction into a JSON-RPC transaction\n    const rpcTx =\n      this.provider instanceof JsonRpcApiProvider\n        ? this.provider.getRpcTransaction(tx)\n        : // We can just call the getRpcTransaction with a\n          // null receiver since it doesn't actually use it\n          // (and really should be declared static).\n          JsonRpcApiProvider.prototype.getRpcTransaction.call(null, tx);\n    rpcTx.type = toBeHex(tx.type ?? 0x02, 1); // we expect 0x0[0-2]\n\n    const req = <EvmSignRequest>{\n      chain_id: Number(chainId),\n      tx: rpcTx,\n    };\n\n    const res = await this.#signerSession.signEvm(this.#address, req);\n    const data = await this.#handleMfa(res);\n    return data.rlp_signed_tx;\n  }\n\n  /** Signs arbitrary messages. This uses ethers.js's [hashMessage](https://docs.ethers.org/v6/api/hashing/#hashMessage)\n   * to compute the EIP-191 digest and signs this digest using {@link Key#signBlob}.\n   * The key (for this session) must have the `\"AllowRawBlobSigning\"` policy attached.\n   * @param {string | Uint8Array} message The message to sign.\n   * @return {Promise<string>} The signature.\n   */\n  async signMessage(message: string | Uint8Array): Promise<string> {\n    const digest = ethers.hashMessage(message);\n    return this.signBlob(digest);\n  }\n\n  /** Signs EIP-712 typed data. This uses ethers.js's\n   * [TypedDataEncoder.hash](https://docs.ethers.org/v6/api/hashing/#TypedDataEncoder_hash)\n   * to compute the EIP-712 digest and signs this digest using {@link Key#signBlob}.\n   * The key (for this session) must have the `\"AllowRawBlobSigning\"` policy attached.\n   * @param {TypedDataDomain} domain The domain of the typed data.\n   * @param {Record<string, Array<TypedDataField>>} types The types of the typed data.\n   * @param {Record<string, any>} value The value of the typed data.\n   * @return {Promise<string>} The signature.\n   */\n  async signTypedData(\n    domain: TypedDataDomain,\n    types: Record<string, Array<TypedDataField>>,\n    value: Record<string, any>, // eslint-disable-line @typescript-eslint/no-explicit-any\n  ): Promise<string> {\n    const digest = TypedDataEncoder.hash(domain, types, value);\n    return this.signBlob(digest);\n  }\n\n  /** Sign arbitrary digest. This uses {@link Key#signBlob}.\n   * @param {string} digest The digest to sign.\n   * @return {Promise<string>} The signature.\n   */\n  private async signBlob(digest: string): Promise<string> {\n    const blobReq = <BlobSignRequest>{\n      message_base64: Buffer.from(getBytes(digest)).toString(\"base64\"),\n    };\n    // Get the key corresponding to this address\n    if (this.#key === undefined) {\n      const key = (await this.#signerSession.keys()).find((k) => k.material_id === this.#address);\n      if (key === undefined) {\n        throw new Error(`Cannot access key '${this.#address}'`);\n      }\n      this.#key = key;\n    }\n\n    const res = await this.#signerSession.signBlob(this.#key.key_id, blobReq);\n    const data = await this.#handleMfa(res);\n    return data.signature;\n  }\n\n  /**\n   * If the sign request requires MFA, this method waits for approvals\n   *\n   * @param {SignResponse<U>} res The response of a sign request\n   * @return {Promise<U>} The sign data after MFA approvals\n   */\n  async #handleMfa<U>(res: SignResponse<U>): Promise<U> {\n    while (res.requiresMfa()) {\n      await new Promise((resolve) => setTimeout(resolve, this.#mfaPollIntervalMs));\n\n      const mfaInfo = await this.#signerSession.getMfaInfo(this.#managementSession!, res.mfaId());\n      this.#onMfaPoll(mfaInfo);\n      if (mfaInfo.receipt) {\n        res = await res.signWithMfaApproval(mfaInfo);\n      }\n    }\n    return res.data();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/ethers/index.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  JsonRpcApiProvider,\n  TypedDataDomain,\n  TypedDataEncoder,\n  TypedDataField,\n  ethers,\n  getBytes,\n  toBeHex,\n} from \"ethers\";\nimport {\n  BlobSignRequest,\n  EvmSignRequest,\n  MfaRequestInfo,\n  SignerSession,\n  SignResponse,\n} from \"../signer_session\";\nimport { KeyInfo } from \"../key\";\nimport { CubeSigner } from \"..\";\n\n/** Options for the signer */\ninterface SignerOptions {\n  /** Optional provider to use */\n  provider?: null | ethers.Provider;\n  /**\n   * The function to call when MFA information is retrieved. If this callback\n   * throws, no transaction is broadcast.\n   */\n  onMfaPoll?: (arg0: MfaRequestInfo) => void;\n  /**\n   * The amount of time (in milliseconds) to wait between checks for MFA\n   * updates. Default is 1000ms\n   */\n  mfaPollIntervalMs?: number;\n  /** Optional management session. Used to check for MFA updates */\n  managementSession?: CubeSigner;\n}\n\n/**\n * A ethers.js Signer using CubeSigner\n */\nexport class Signer extends ethers.AbstractSigner {\n  /** The address of the account */\n  readonly #address: string;\n\n  /** The key to use for signing */\n  #key?: KeyInfo;\n\n  /** The underlying session */\n  readonly #signerSession: SignerSession;\n\n  /**\n   * The function to call when MFA information is retrieved. If this callback\n   * throws, no transaction is broadcast.\n   */\n  readonly #onMfaPoll: (arg0: MfaRequestInfo) => void;\n\n  /** The amount of time to wait between checks for MFA updates */\n  readonly #mfaPollIntervalMs: number;\n\n  /** Optional management session, used for MFA flows */\n  readonly #managementSession?: CubeSigner;\n\n  /** Create new Signer instance\n   * @param {KeyInfo | string} address The key or the eth address of the account to use.\n   * @param {SignerSession} signerSession The underlying Signer session.\n   * @param {SignerOptions} options The options to use for the Signer instance\n   */\n  constructor(address: KeyInfo | string, signerSession: SignerSession, options?: SignerOptions) {\n    super(options?.provider);\n    if (typeof address === \"string\") {\n      this.#address = address;\n    } else {\n      this.#address = address.materialId;\n      this.#key = address as KeyInfo;\n    }\n    this.#signerSession = signerSession;\n    this.#onMfaPoll = options?.onMfaPoll ?? ((/* _mfaInfo: MfaRequestInfo */) => {}); // eslint-disable-line @typescript-eslint/no-empty-function\n    this.#mfaPollIntervalMs = options?.mfaPollIntervalMs ?? 1000;\n    this.#managementSession = options?.managementSession;\n  }\n\n  /** Resolves to the signer address. */\n  async getAddress(): Promise<string> {\n    return this.#address;\n  }\n\n  /**\n   *  Returns the signer connected to %%provider%%.\n   *  @param {null | ethers.Provider} provider The optional provider instance to use.\n   *  @return {Signer} The signer connected to signer.\n   */\n  connect(provider: null | ethers.Provider): Signer {\n    return new Signer(this.#address, this.#signerSession, { provider });\n  }\n\n  /**\n   * Signs a transaction. This populates the transaction type to `0x02` (EIP-1559) unless set. This method will block if the key requires MFA approval.\n   * @param {ethers.TransactionRequest} tx The transaction to sign.\n   * @return {Promise<string>} Hex-encoded RLP encoding of the transaction and its signature.\n   */\n  async signTransaction(tx: ethers.TransactionRequest): Promise<string> {\n    // get the chain id from the network or tx\n    let chainId = tx.chainId;\n    if (chainId === undefined) {\n      const network = await this.provider?.getNetwork();\n      chainId = network?.chainId?.toString() ?? \"1\";\n    }\n\n    // Convert the transaction into a JSON-RPC transaction\n    const rpcTx =\n      this.provider instanceof JsonRpcApiProvider\n        ? this.provider.getRpcTransaction(tx)\n        : // We can just call the getRpcTransaction with a\n          // null receiver since it doesn't actually use it\n          // (and really should be declared static).\n          JsonRpcApiProvider.prototype.getRpcTransaction.call(null, tx);\n    rpcTx.type = toBeHex(tx.type ?? 0x02, 1); // we expect 0x0[0-2]\n\n    const req = <EvmSignRequest>{\n      chain_id: Number(chainId),\n      tx: rpcTx,\n    };\n\n    const res = await this.#signerSession.signEvm(this.#address, req);\n    const data = await this.#handleMfa(res);\n    return data.rlp_signed_tx;\n  }\n\n  /** Signs arbitrary messages. This uses ethers.js's [hashMessage](https://docs.ethers.org/v6/api/hashing/#hashMessage)\n   * to compute the EIP-191 digest and signs this digest using {@link Key#signBlob}.\n   * The key (for this session) must have the `\"AllowRawBlobSigning\"` policy attached.\n   * @param {string | Uint8Array} message The message to sign.\n   * @return {Promise<string>} The signature.\n   */\n  async signMessage(message: string | Uint8Array): Promise<string> {\n    const digest = ethers.hashMessage(message);\n    return this.signBlob(digest);\n  }\n\n  /** Signs EIP-712 typed data. This uses ethers.js's\n   * [TypedDataEncoder.hash](https://docs.ethers.org/v6/api/hashing/#TypedDataEncoder_hash)\n   * to compute the EIP-712 digest and signs this digest using {@link Key#signBlob}.\n   * The key (for this session) must have the `\"AllowRawBlobSigning\"` policy attached.\n   * @param {TypedDataDomain} domain The domain of the typed data.\n   * @param {Record<string, Array<TypedDataField>>} types The types of the typed data.\n   * @param {Record<string, any>} value The value of the typed data.\n   * @return {Promise<string>} The signature.\n   */\n  async signTypedData(\n    domain: TypedDataDomain,\n    types: Record<string, Array<TypedDataField>>,\n    value: Record<string, any>, // eslint-disable-line @typescript-eslint/no-explicit-any\n  ): Promise<string> {\n    const digest = TypedDataEncoder.hash(domain, types, value);\n    return this.signBlob(digest);\n  }\n\n  /** Sign arbitrary digest. This uses {@link Key#signBlob}.\n   * @param {string} digest The digest to sign.\n   * @return {Promise<string>} The signature.\n   */\n  private async signBlob(digest: string): Promise<string> {\n    const blobReq = <BlobSignRequest>{\n      message_base64: Buffer.from(getBytes(digest)).toString(\"base64\"),\n    };\n    // Get the key corresponding to this address\n    if (this.#key === undefined) {\n      const key = (await this.#signerSession.keys()).find((k) => k.material_id === this.#address);\n      if (key === undefined) {\n        throw new Error(`Cannot access key '${this.#address}'`);\n      }\n      this.#key = key;\n    }\n\n    const res = await this.#signerSession.signBlob(this.#key.key_id, blobReq);\n    const data = await this.#handleMfa(res);\n    return data.signature;\n  }\n\n  /**\n   * If the sign request requires MFA, this method waits for approvals\n   *\n   * @param {SignResponse<U>} res The response of a sign request\n   * @return {Promise<U>} The sign data after MFA approvals\n   */\n  async #handleMfa<U>(res: SignResponse<U>): Promise<U> {\n    while (res.requiresMfa()) {\n      await new Promise((resolve) => setTimeout(resolve, this.#mfaPollIntervalMs));\n\n      const mfaId = res.mfaId();\n      const mfaInfo = await this.#signerSession.getMfaInfo(this.#managementSession!, mfaId);\n      this.#onMfaPoll(mfaInfo);\n      if (mfaInfo.receipt) {\n        res = await res.signWithMfaApproval({\n          mfaId,\n          mfaOrgId: this.#signerSession.orgId,\n          mfaConf: mfaInfo.receipt.confirmation,\n        });\n      }\n    }\n    return res.data();\n  }\n}\n"]}

package/dist/src/fido.d.ts

@@ -0,0 +1,76 @@
+import { CubeSigner, MfaRequestInfo, SignerSession } from ".";
+import { components } from "./schema";
+export type ApiAddFidoChallenge = components["responses"]["FidoCreateChallengeResponse"]["content"]["application/json"];
+export type ApiMfaFidoChallenge = components["responses"]["FidoAssertChallenge"]["content"]["application/json"];
+export type PublicKeyCredentialCreationOptions = components["schemas"]["PublicKeyCredentialCreationOptions"];
+export type PublicKeyCredentialRequestOptions = components["schemas"]["PublicKeyCredentialRequestOptions"];
+export type PublicKeyCredentialParameters = components["schemas"]["PublicKeyCredentialParameters"];
+export type PublicKeyCredentialDescriptor = components["schemas"]["PublicKeyCredentialDescriptor"];
+export type AuthenticatorSelectionCriteria = components["schemas"]["AuthenticatorSelectionCriteria"];
+export type PublicKeyCredentialUserEntity = components["schemas"]["PublicKeyCredentialUserEntity"];
+export type PublicKeyCredential = components["schemas"]["PublicKeyCredential"];
+/**
+ * Returned after creating a request to add a new FIDO device.
+ * Provides some helper methods for answering this challenge.
+ */
+export declare class AddFidoChallenge {
+    #private;
+    readonly challengeId: string;
+    readonly options: any;
+    /**
+     * Constructor
+     * @param {CubeSigner} cs CubeSigner instance used to request to add a FIDO device
+     * @param {ApiAddFidoChallenge} challenge The challenge returned by the remote end.
+     */
+    constructor(cs: CubeSigner, challenge: ApiAddFidoChallenge);
+    /**
+     * Answers this challenge by using the `CredentialsContainer` API to create a credential
+     * based on the the public key credential creation options from this challenge.
+     */
+    createCredentialAndAnswer(): Promise<void>;
+    /**
+     * Answers this challenge using a given credential `cred`;
+     * the credential should be obtained by calling
+     *
+     * ```
+     * const cred = await navigator.credentials.create({ publicKey: this.options });
+     * ```
+     *
+     * @param {any} cred Credential created by calling the `CredentialContainer`'s `create` method
+     *                   based on the public key creation options from this challenge.
+     */
+    answer(cred: any): Promise<void>;
+}
+/**
+ * Returned after initiating MFA approval using FIDO.
+ * Provides some helper methods for answering this challenge.
+ */
+export declare class MfaFidoChallenge {
+    #private;
+    readonly mfaId: string;
+    readonly challengeId: string;
+    readonly options: any;
+    /**
+     * @param {SignerSession} ss The session used to initiate MFA approval using FIDO
+     * @param {string} mfaId The MFA request id.
+     * @param {ApiMfaFidoChallenge} challenge The challenge returned by the remote end
+     */
+    constructor(ss: SignerSession, mfaId: string, challenge: ApiMfaFidoChallenge);
+    /**
+     * Answers this challenge by using the `CredentialsContainer` API to get a credential
+     * based on the the public key credential request options from this challenge.
+     */
+    createCredentialAndAnswer(): Promise<MfaRequestInfo>;
+    /**
+     * Answers this challenge using a given credential `cred`.
+     * To obtain this credential, for example, call
+     *
+     * ```
+     * const cred = await navigator.credentials.get({ publicKey: this.options });
+     * ```
+     *
+     * @param {any} cred Credential created by calling the `CredentialContainer`'s `get` method
+     *                   based on the public key credential request options from this challenge.
+     */
+    answer(cred: any): Promise<MfaRequestInfo>;
+}

package/dist/src/fido.js

@@ -0,0 +1,148 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AddFidoChallenge_cs, _MfaFidoChallenge_ss;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MfaFidoChallenge = exports.AddFidoChallenge = void 0;
+const util_1 = require("./util");
+/**
+ * Returned after creating a request to add a new FIDO device.
+ * Provides some helper methods for answering this challenge.
+ */
+class AddFidoChallenge {
+    /**
+     * Constructor
+     * @param {CubeSigner} cs CubeSigner instance used to request to add a FIDO device
+     * @param {ApiAddFidoChallenge} challenge The challenge returned by the remote end.
+     */
+    constructor(cs, challenge) {
+        _AddFidoChallenge_cs.set(this, void 0);
+        __classPrivateFieldSet(this, _AddFidoChallenge_cs, cs, "f");
+        this.challengeId = challenge.challenge_id;
+        // fix options returned from the server: rename fields and decode base64 fields to uint8[]
+        this.options = {
+            ...challenge.options,
+            challenge: (0, util_1.decodeBase64Url)(challenge.options.challenge),
+        };
+        this.options.pubKeyCredParams ??= challenge.options.pub_key_cred_params;
+        this.options.excludeCredentials ??= challenge.options.exclude_credentials;
+        this.options.authenticatorSelection ??= challenge.options.authenticator_selection;
+        delete this.options.pub_key_cred_params;
+        delete this.options.exclude_credentials;
+        delete this.options.authenticator_selection;
+        if (challenge.options.user) {
+            this.options.user.id = (0, util_1.decodeBase64Url)(challenge.options.user.id);
+        }
+        for (const credential of this.options.excludeCredentials ?? []) {
+            credential.id = (0, util_1.decodeBase64Url)(credential.id);
+        }
+    }
+    /**
+     * Answers this challenge by using the `CredentialsContainer` API to create a credential
+     * based on the the public key credential creation options from this challenge.
+     */
+    async createCredentialAndAnswer() {
+        const cred = await navigator.credentials.create({ publicKey: this.options });
+        await this.answer(cred);
+    }
+    /**
+     * Answers this challenge using a given credential `cred`;
+     * the credential should be obtained by calling
+     *
+     * ```
+     * const cred = await navigator.credentials.create({ publicKey: this.options });
+     * ```
+     *
+     * @param {any} cred Credential created by calling the `CredentialContainer`'s `create` method
+     *                   based on the public key creation options from this challenge.
+     */
+    async answer(cred) {
+        const answer = {
+            id: cred.id,
+            response: {
+                clientDataJSON: (0, util_1.encodeToBase64Url)(cred.response.clientDataJSON),
+                attestationObject: (0, util_1.encodeToBase64Url)(cred.response.attestationObject),
+            },
+        };
+        await __classPrivateFieldGet(this, _AddFidoChallenge_cs, "f").addFidoComplete(this.challengeId, answer);
+    }
+}
+exports.AddFidoChallenge = AddFidoChallenge;
+_AddFidoChallenge_cs = new WeakMap();
+/**
+ * Returned after initiating MFA approval using FIDO.
+ * Provides some helper methods for answering this challenge.
+ */
+class MfaFidoChallenge {
+    /**
+     * @param {SignerSession} ss The session used to initiate MFA approval using FIDO
+     * @param {string} mfaId The MFA request id.
+     * @param {ApiMfaFidoChallenge} challenge The challenge returned by the remote end
+     */
+    constructor(ss, mfaId, challenge) {
+        _MfaFidoChallenge_ss.set(this, void 0);
+        __classPrivateFieldSet(this, _MfaFidoChallenge_ss, ss, "f");
+        this.mfaId = mfaId;
+        this.challengeId = challenge.challenge_id;
+        // fix options returned from the server: rename fields and decode base64 fields into uint8[]
+        this.options = {
+            ...challenge.options,
+            challenge: (0, util_1.decodeBase64Url)(challenge.options.challenge),
+        };
+        this.options.rpId ??= challenge.options.rp_id;
+        this.options.allowCredentials ??= challenge.options.allow_credentials;
+        this.options.userVerification ??= challenge.options.user_verification;
+        delete this.options.rp_id;
+        delete this.options.allow_credentials;
+        delete this.options.user_verification;
+        for (const credential of this.options.allowCredentials ?? []) {
+            credential.id = (0, util_1.decodeBase64Url)(credential.id);
+            if (credential.transports === null) {
+                delete credential.transports;
+            }
+        }
+    }
+    /**
+     * Answers this challenge by using the `CredentialsContainer` API to get a credential
+     * based on the the public key credential request options from this challenge.
+     */
+    async createCredentialAndAnswer() {
+        const cred = await navigator.credentials.get({ publicKey: this.options });
+        return await this.answer(cred);
+    }
+    /**
+     * Answers this challenge using a given credential `cred`.
+     * To obtain this credential, for example, call
+     *
+     * ```
+     * const cred = await navigator.credentials.get({ publicKey: this.options });
+     * ```
+     *
+     * @param {any} cred Credential created by calling the `CredentialContainer`'s `get` method
+     *                   based on the public key credential request options from this challenge.
+     */
+    async answer(cred) {
+        const answer = {
+            id: cred.id,
+            response: {
+                clientDataJSON: (0, util_1.encodeToBase64Url)(cred.response.clientDataJSON),
+                authenticatorData: (0, util_1.encodeToBase64Url)(cred.response.authenticatorData),
+                signature: (0, util_1.encodeToBase64Url)(cred.response.signature),
+            },
+        };
+        return await __classPrivateFieldGet(this, _MfaFidoChallenge_ss, "f").fidoApproveComplete(this.mfaId, this.challengeId, answer);
+    }
+}
+exports.MfaFidoChallenge = MfaFidoChallenge;
+_MfaFidoChallenge_ss = new WeakMap();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fido.js","sourceRoot":"","sources":["../../src/fido.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport { CubeSigner, MfaRequestInfo, SignerSession } from \".\";\nimport { components } from \"./schema\";\nimport { decodeBase64Url, encodeToBase64Url } from \"./util\";\n\nexport type ApiAddFidoChallenge =\n  components[\"responses\"][\"FidoCreateChallengeResponse\"][\"content\"][\"application/json\"];\n\nexport type ApiMfaFidoChallenge =\n  components[\"responses\"][\"FidoAssertChallenge\"][\"content\"][\"application/json\"];\n\nexport type PublicKeyCredentialCreationOptions =\n  components[\"schemas\"][\"PublicKeyCredentialCreationOptions\"];\nexport type PublicKeyCredentialRequestOptions =\n  components[\"schemas\"][\"PublicKeyCredentialRequestOptions\"];\nexport type PublicKeyCredentialParameters = components[\"schemas\"][\"PublicKeyCredentialParameters\"];\nexport type PublicKeyCredentialDescriptor = components[\"schemas\"][\"PublicKeyCredentialDescriptor\"];\nexport type AuthenticatorSelectionCriteria =\n  components[\"schemas\"][\"AuthenticatorSelectionCriteria\"];\nexport type PublicKeyCredentialUserEntity = components[\"schemas\"][\"PublicKeyCredentialUserEntity\"];\nexport type PublicKeyCredential = components[\"schemas\"][\"PublicKeyCredential\"];\n\n/**\n * Returned after creating a request to add a new FIDO device.\n * Provides some helper methods for answering this challenge.\n */\nexport class AddFidoChallenge {\n  readonly #cs: CubeSigner;\n  readonly challengeId: string;\n  readonly options: any;\n\n  /**\n   * Constructor\n   * @param {CubeSigner} cs CubeSigner instance used to request to add a FIDO device\n   * @param {ApiAddFidoChallenge} challenge The challenge returned by the remote end.\n   */\n  constructor(cs: CubeSigner, challenge: ApiAddFidoChallenge) {\n    this.#cs = cs;\n    this.challengeId = challenge.challenge_id;\n\n    // fix options returned from the server: rename fields and decode base64 fields to uint8[]\n    this.options = {\n      ...challenge.options,\n      challenge: decodeBase64Url(challenge.options.challenge),\n    };\n    this.options.pubKeyCredParams ??= challenge.options.pub_key_cred_params;\n    this.options.excludeCredentials ??= challenge.options.exclude_credentials;\n    this.options.authenticatorSelection ??= challenge.options.authenticator_selection;\n    delete this.options.pub_key_cred_params;\n    delete this.options.exclude_credentials;\n    delete this.options.authenticator_selection;\n\n    if (challenge.options.user) {\n      this.options.user.id = decodeBase64Url(challenge.options.user.id);\n    }\n\n    for (const credential of this.options.excludeCredentials ?? []) {\n      credential.id = decodeBase64Url(credential.id);\n    }\n  }\n\n  /**\n   * Answers this challenge by using the `CredentialsContainer` API to create a credential\n   * based on the the public key credential creation options from this challenge.\n   */\n  async createCredentialAndAnswer() {\n    const cred = await navigator.credentials.create({ publicKey: this.options });\n    await this.answer(cred);\n  }\n\n  /**\n   * Answers this challenge using a given credential `cred`;\n   * the credential should be obtained by calling\n   *\n   * ```\n   * const cred = await navigator.credentials.create({ publicKey: this.options });\n   * ```\n   *\n   * @param {any} cred Credential created by calling the `CredentialContainer`'s `create` method\n   *                   based on the public key creation options from this challenge.\n   */\n  async answer(cred: any) {\n    const answer = <PublicKeyCredential>{\n      id: cred.id,\n      response: {\n        clientDataJSON: encodeToBase64Url(cred.response.clientDataJSON),\n        attestationObject: encodeToBase64Url(cred.response.attestationObject),\n      },\n    };\n    await this.#cs.addFidoComplete(this.challengeId, answer);\n  }\n}\n\n/**\n * Returned after initiating MFA approval using FIDO.\n * Provides some helper methods for answering this challenge.\n */\nexport class MfaFidoChallenge {\n  readonly #ss: SignerSession;\n  readonly mfaId: string;\n  readonly challengeId: string;\n  readonly options: any;\n\n  /**\n   * @param {SignerSession} ss The session used to initiate MFA approval using FIDO\n   * @param {string} mfaId The MFA request id.\n   * @param {ApiMfaFidoChallenge} challenge The challenge returned by the remote end\n   */\n  constructor(ss: SignerSession, mfaId: string, challenge: ApiMfaFidoChallenge) {\n    this.#ss = ss;\n    this.mfaId = mfaId;\n    this.challengeId = challenge.challenge_id;\n\n    // fix options returned from the server: rename fields and decode base64 fields into uint8[]\n    this.options = {\n      ...challenge.options,\n      challenge: decodeBase64Url(challenge.options.challenge),\n    };\n    this.options.rpId ??= challenge.options.rp_id;\n    this.options.allowCredentials ??= challenge.options.allow_credentials;\n    this.options.userVerification ??= challenge.options.user_verification;\n    delete this.options.rp_id;\n    delete this.options.allow_credentials;\n    delete this.options.user_verification;\n\n    for (const credential of this.options.allowCredentials ?? []) {\n      credential.id = decodeBase64Url(credential.id);\n      if (credential.transports === null) {\n        delete credential.transports;\n      }\n    }\n  }\n\n  /**\n   * Answers this challenge by using the `CredentialsContainer` API to get a credential\n   * based on the the public key credential request options from this challenge.\n   */\n  async createCredentialAndAnswer(): Promise<MfaRequestInfo> {\n    const cred = await navigator.credentials.get({ publicKey: this.options });\n    return await this.answer(cred);\n  }\n\n  /**\n   * Answers this challenge using a given credential `cred`.\n   * To obtain this credential, for example, call\n   *\n   * ```\n   * const cred = await navigator.credentials.get({ publicKey: this.options });\n   * ```\n   *\n   * @param {any} cred Credential created by calling the `CredentialContainer`'s `get` method\n   *                   based on the public key credential request options from this challenge.\n   */\n  async answer(cred: any): Promise<MfaRequestInfo> {\n    const answer = <PublicKeyCredential>{\n      id: cred.id,\n      response: {\n        clientDataJSON: encodeToBase64Url(cred.response.clientDataJSON),\n        authenticatorData: encodeToBase64Url(cred.response.authenticatorData),\n        signature: encodeToBase64Url(cred.response.signature),\n      },\n    };\n    return await this.#ss.fidoApproveComplete(this.mfaId, this.challengeId, answer);\n  }\n}\n"]}

package/dist/src/index.d.ts

@@ -4,26 +4,54 @@ import { Org } from "./org";
 import { SignerSessionStorage, SignerSessionManager } from "./session/signer_session_manager";
 import { MfaRequestInfo, SignResponse, SignerSession } from "./signer_session";
 import { CognitoSessionManager, CognitoSessionStorage } from "./session/cognito_manager";
+import { AddFidoChallenge, PublicKeyCredential } from "./fido";
 /** CubeSigner constructor options */
 export interface CubeSignerOptions {
     /** The environment to use */
     env?: EnvInterface;
     /** The management authorization token */
     sessionMgr?: CognitoSessionManager | SignerSessionManager;
+    /** Optional organization id */
+    orgId?: string;
 }
 export type UserInfo = components["schemas"]["UserInfo"];
 export type TotpInfo = components["responses"]["TotpInfo"]["content"]["application/json"];
 export type ConfiguredMfa = components["schemas"]["ConfiguredMfa"];
 export type RatchetConfig = components["schemas"]["RatchetConfig"];
+export type IdentityProof = components["schemas"]["IdentityProof"];
 type OidcAuthResponse = paths["/v0/org/{org_id}/oidc"]["post"]["responses"]["200"]["content"]["application/json"];
+/** TOTP challenge that must be answered before user's TOTP is updated */
+export declare class TotpChallenge {
+    #private;
+    /** The id of the challenge */
+    get totpId(): string;
+    /** The new TOTP configuration */
+    get totpUrl(): string;
+    /**
+     * @param {CubeSigner} cs Used when answering the challenge.
+     * @param {TotpInfo} totpInfo TOTP challenge information.
+     */
+    constructor(cs: CubeSigner, totpInfo: TotpInfo);
+    /**
+     * Answer the challenge with the code that corresponds to this `this.totpUrl`.
+     * @param {string} code 6-digit code that corresponds to this `this.totpUrl`.
+     */
+    answer(code: string): Promise<void>;
+}
 /** CubeSigner client */
 export declare class CubeSigner {
     #private;
     readonly sessionMgr?: CognitoSessionManager | SignerSessionManager;
     /** @return {EnvInterface} The CubeSigner environment of this client */
     get env(): EnvInterface;
+    /**
+     * Set the organization ID
+     * @param {string} orgId The new organization id.
+     */
+    setOrgId(orgId: string): void;
     /**
      * Loads an existing management session and creates a CubeSigner instance.
+     *
      * @param {CognitoSessionStorage} storage Optional session storage to load
      * the session from. If not specified, the management session from the config
      * directory will be loaded.
@@ -53,15 +81,12 @@ export declare class CubeSigner {
      * @return {Promise<SignerSessionManager>} The signer session manager
      */
     oidcAuth(oidcToken: string, orgId: string, scopes: Array<string>, lifetimes?: RatchetConfig, storage?: SignerSessionStorage): Promise<SignerSessionManager>;
-    /** Retrieves information about the current user. */
-    aboutMe(): Promise<UserInfo>;
     /**
-     * Creates and sets a new TOTP configuration for the logged in user,
-     * if and only if no TOTP configuration is already set.
+     * Retrieves information about the current user.
      *
-     * @return {Promise<TotpInfo>} Newly created TOTP configuration.
+     * @return {Promise<UserInfo>} User information.
      */
-    initTotp(): Promise<TotpInfo>;
+    aboutMe(): Promise<UserInfo>;
     /**
      * Retrieves existing MFA request.
      *
@@ -71,10 +96,47 @@ export declare class CubeSigner {
      */
     mfaGet(orgId: string, mfaId: string): Promise<MfaRequestInfo>;
     /**
-     * Creates and sets a new TOTP configuration for the logged-in user,
-     * overriding the existing one (if any).
+     * List pending MFA requests accessible to the current user.
+     * @param {string} orgId Organization ID
+     * @return {Promise<MfaRequestInfo[]>} The MFA requests.
+     */
+    mfaList(orgId: string): Promise<MfaRequestInfo[]>;
+    /**
+     * Approve a pending MFA request.
+     *
+     * @param {string} orgId The org id of the MFA request
+     * @param {string} mfaId The id of the MFA request
+     * @return {Promise<MfaRequestInfo>} The result of the MFA request
+     */
+    mfaApprove(orgId: string, mfaId: string): Promise<MfaRequestInfo>;
+    /**
+     * Initiate adding a new FIDO device. MFA may be required.
+     * @param {string} name The name of the new device.
+     * @param {MfaReceipt} mfaReceipt Optional MFA receipt to include in HTTP headers
+     * @return {Promise<SignResponse<AddFidoChallenge>>} A challenge that must be answered in order to complete FIDO registration.
      */
-    resetTotp(): Promise<TotpInfo>;
+    addFidoStart(name: string, mfaReceipt?: MfaReceipt): Promise<SignResponse<AddFidoChallenge>>;
+    /**
+     * Complete a previously initiated request to add a new FIDO device.
+     * @param {string} challengeId The ID of the challenge returned by the remote end.
+     * @param {PublicKeyCredential} credential The answer to the challenge.
+     */
+    addFidoComplete(challengeId: string, credential: PublicKeyCredential): Promise<void>;
+    /**
+     * Creates a request to change user's TOTP. This request returns a new TOTP challenge
+     * that must be answered by calling `resetTotpComplete`
+     *
+     * @param {MfaReceipt} mfaReceipt MFA receipt to include in HTTP headers
+     */
+    resetTotpStart(mfaReceipt?: MfaReceipt): Promise<SignResponse<TotpChallenge>>;
+    /**
+     * Answer the TOTP challenge issued by `resetTotpStart`. If successful, user's
+     * TOTP configuration will be updated to that of the TOTP challenge.
+     *
+     * @param {string} totpId - The ID of the TOTP challenge
+     * @param {string} code - The TOTP code that should verify against the TOTP configuration from the challenge.
+     */
+    resetTotpComplete(totpId: string, code: string): Promise<void>;
     /**
      * Verifies a given TOTP code against the current user's TOTP configuration.
      * Throws an error if the verification fails.
@@ -86,11 +148,39 @@ export declare class CubeSigner {
      * @return {Org} The organization.
      * */
     getOrg(orgId: string): Promise<Org>;
+    /**
+     * Deletes a given key.
+     * @param {string} orgId - Organization id
+     * @param {string} keyId - Key id
+     */
+    deleteKey(orgId: string, keyId: string): Promise<void>;
     /** Get the management client.
      * @return {Client} The client.
      * @internal
      * */
     management(): Promise<Client>;
+    /**
+     * Obtain a proof of authentication.
+     *
+     * @param {string} orgId The id of the organization that the user is in
+     * @return {Promise<IdentityProof>} Proof of authentication
+     */
+    proveIdentity(orgId: string): Promise<IdentityProof>;
+    /**
+     * Exchange an OIDC token for a proof of authentication.
+     *
+     * @param {string} oidcToken The OIDC token
+     * @param {string} orgId The id of the organization that the user is in
+     * @return {Promise<IdentityProof>} Proof of authentication
+     */
+    oidcProveIdentity(oidcToken: string, orgId: string): Promise<IdentityProof>;
+    /**
+     * Checks if a given identity proof is valid.
+     *
+     * @param {string} orgId The id of the organization that the user is in.
+     * @param {IdentityProof} identityProof The proof of authentication.
+     */
+    verifyIdentity(orgId: string, identityProof: IdentityProof): Promise<void>;
     /**
      * Exchange an OIDC token for a CubeSigner session token.
      * @param {string} oidcToken The OIDC token
@@ -106,6 +196,8 @@ export declare class CubeSigner {
 export interface MfaReceipt {
     /** MFA request ID */
     mfaId: string;
+    /** Corresponding org ID */
+    mfaOrgId: string;
     /** MFA confirmation code */
     mfaConf: string;
 }
@@ -117,6 +209,10 @@ export * from "./key";
 export * from "./role";
 /** Env */
 export * from "./env";
+/** Fido */
+export * from "./fido";
+/** Pagination */
+export * from "./paginator";
 /** Sessions */
 export * from "./signer_session";
 /** Session storage */