@cubist-labs/cubesigner-sdk 0.3.26 → 0.3.28

package/dist/src/session/signer_session_manager.js

@@ -0,0 +1,239 @@
+"use strict";
+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 __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 _SignerSessionManager_instances, _a, _SignerSessionManager_eventEmitter, _SignerSessionManager_refreshing, _SignerSessionManager_client, _SignerSessionManager_createClient, _SignerSessionManager_hasTimestampExpired;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignerSessionManager = void 0;
+const events_1 = require("../events");
+const api_1 = require("../api");
+const session_storage_1 = require("./session_storage");
+const util_1 = require("../util");
+const events_2 = require("../events");
+const error_1 = require("../error");
+const DEFAULT_EXPIRATION_BUFFER_SECS = 30;
+/**
+ * Constructs {@link Date} from a number representing seconds since unix epoch.
+ * @param {number} secs Seconds since unix epoch.
+ * @return {Date} The equivalent date.
+ */
+function secondsSinceEpochToDate(secs) {
+    return new Date(secs * 1000);
+}
+/** Generic session manager interface. */
+class SignerSessionManager {
+    /**
+     * @return {string} The current auth token.
+     * @internal
+     */
+    async token() {
+        const session = await this.storage.retrieve();
+        return session.token;
+    }
+    /**
+     * Refreshes the current session if needed, then returns a client using the current session.
+     *
+     * May **UPDATE/MUTATE** self.
+     *
+     * @param {operations} operation The operation that this client will be
+     *   used for. This parameter is used exclusively for more accurate error
+     *   reporting and does not affect functionality.
+     * @return {Client} The client with the current session
+     */
+    async client(operation) {
+        await this.refreshIfNeeded();
+        // trigger "session expired" if the session as a whole has expired
+        // or if (for whatever reason) the token is still stale
+        if (__classPrivateFieldGet(_a, _a, "m", _SignerSessionManager_hasTimestampExpired).call(_a, __classPrivateFieldGet(this, _SignerSessionManager_client, "f").token_exp) || this.hasExpired()) {
+            await __classPrivateFieldGet(this, _SignerSessionManager_eventEmitter, "f").emitSessionExpired();
+            throw new error_1.SessionExpiredError(operation);
+        }
+        return __classPrivateFieldGet(this, _SignerSessionManager_client, "f").client;
+    }
+    /** Revokes the session. */
+    async revoke() {
+        const client = new api_1.OpClient("revokeCurrentSession", await this.client(), __classPrivateFieldGet(this, _SignerSessionManager_eventEmitter, "f"));
+        await client.del("/v0/org/{org_id}/session/self", {
+            params: { path: { org_id: this.orgId } },
+        });
+    }
+    /**
+     * Refreshes the session and **UPDATES/MUTATES** self.
+     */
+    async refresh() {
+        if (this.hasExpired()) {
+            await __classPrivateFieldGet(this, _SignerSessionManager_eventEmitter, "f").emitSessionExpired();
+            throw new error_1.SessionExpiredError("signerSessionRefresh");
+        }
+        const currSession = await this.storage.retrieve();
+        const client = new api_1.OpClient("signerSessionRefresh", __classPrivateFieldGet(this, _SignerSessionManager_client, "f").client, __classPrivateFieldGet(this, _SignerSessionManager_eventEmitter, "f"));
+        const csi = currSession.session_info;
+        const data = await client.patch("/v1/org/{org_id}/token/refresh", {
+            params: { path: { org_id: this.orgId } },
+            body: {
+                epoch_num: csi.epoch,
+                epoch_token: csi.epoch_token,
+                other_token: csi.refresh_token,
+            },
+        });
+        const newSession = {
+            ...currSession,
+            session_info: data.session_info,
+            token: data.token,
+        };
+        await this.storage.save(newSession);
+        __classPrivateFieldSet(this, _SignerSessionManager_client, {
+            client: __classPrivateFieldGet(this, _SignerSessionManager_instances, "m", _SignerSessionManager_createClient).call(this, newSession.token),
+            token_exp: secondsSinceEpochToDate(newSession.session_info.auth_token_exp),
+            session_exp: newSession.session_exp
+                ? secondsSinceEpochToDate(newSession.session_exp)
+                : undefined,
+        }, "f");
+    }
+    /**
+     * Returns whether it's time to refresh this token.
+     * @return {boolean} Whether it's time to refresh this token.
+     * @internal
+     */
+    async isStale() {
+        return __classPrivateFieldGet(_a, _a, "m", _SignerSessionManager_hasTimestampExpired).call(_a, __classPrivateFieldGet(this, _SignerSessionManager_client, "f").token_exp, DEFAULT_EXPIRATION_BUFFER_SECS);
+    }
+    /**
+     * Return whether this session has expired and cannot be refreshed anymore.
+     * @return {boolean} Whether this session has expired.
+     * @internal
+     */
+    hasExpired() {
+        return ((__classPrivateFieldGet(this, _SignerSessionManager_client, "f").session_exp || false) &&
+            __classPrivateFieldGet(_a, _a, "m", _SignerSessionManager_hasTimestampExpired).call(_a, __classPrivateFieldGet(this, _SignerSessionManager_client, "f").session_exp));
+    }
+    /**
+     * Refreshes the session if it is about to expire.
+     * @return {boolean} Whether the session token was refreshed.
+     * @internal
+     */
+    async refreshIfNeeded() {
+        if (await this.isStale()) {
+            if (__classPrivateFieldGet(this, _SignerSessionManager_refreshing, "f")) {
+                // wait until done refreshing
+                while (__classPrivateFieldGet(this, _SignerSessionManager_refreshing, "f")) {
+                    await (0, util_1.delay)(100);
+                }
+                return false;
+            }
+            else {
+                // refresh
+                __classPrivateFieldSet(this, _SignerSessionManager_refreshing, true, "f");
+                try {
+                    await this.refresh();
+                    return true;
+                }
+                finally {
+                    __classPrivateFieldSet(this, _SignerSessionManager_refreshing, false, "f");
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Automatically refreshes the session in the background (if needed) every
+     * minute. This is a simple wrapper around `setInterval`.
+     * @return {number} The interval ID of the refresh timer.
+     */
+    autoRefresh() {
+        return setInterval(async () => {
+            await this.refreshIfNeeded();
+        }, 60 * 1000);
+    }
+    /**
+     * Clears the auto refresh timer.
+     * @param {number} timer The timer ID to clear.
+     */
+    clearAutoRefresh(timer) {
+        clearInterval(timer);
+    }
+    /**
+     * @param {EnvInterface} env The CubeSigner environment
+     * @param {string} orgId The organization ID
+     * @param {NewSessionResponse} session The session information.
+     * @param {SignerSessionStorage} storage The storage to use for saving the session.
+     * @return {Promise<SignerSessionManager>} New signer session manager.
+     */
+    static async createFromSessionInfo(env, orgId, session, storage) {
+        const sessionData = {
+            env: {
+                ["Dev-CubeSignerStack"]: env,
+            },
+            org_id: orgId,
+            token: session.token,
+            purpose: "sign via oidc",
+            session_info: session.session_info,
+            session_exp: session.expiration,
+        };
+        storage ??= new session_storage_1.MemorySessionStorage();
+        await storage.save(sessionData);
+        return await _a.loadFromStorage(storage);
+    }
+    /**
+     * @param {SignerSessionData} sessionData The session information.
+     * @param {SignerSessionStorage} storage The storage to use for saving the session.
+     * @return {Promise<SignerSessionManager>} New signer session manager.
+     */
+    static async createFromSessionData(sessionData, storage) {
+        storage ??= new session_storage_1.MemorySessionStorage();
+        await storage.save(sessionData);
+        return await _a.loadFromStorage(storage);
+    }
+    /**
+     * Uses an existing session to create a new signer session manager.
+     *
+     * @param {SignerSessionStorage} storage The session storage to use
+     * @return {Promise<SingerSession>} New signer session manager
+     */
+    static async loadFromStorage(storage) {
+        const session = await storage.retrieve();
+        return new _a(session, storage);
+    }
+    /**
+     * Constructor.
+     * @param {SignerSessionData} sessionData Session data
+     * @param {SignerSessionStorage} storage The session storage to use.
+     */
+    constructor(sessionData, storage) {
+        _SignerSessionManager_instances.add(this);
+        this.events = new events_1.Events();
+        _SignerSessionManager_eventEmitter.set(this, void 0);
+        _SignerSessionManager_refreshing.set(this, false);
+        _SignerSessionManager_client.set(this, void 0);
+        this.env = sessionData.env["Dev-CubeSignerStack"];
+        this.orgId = sessionData.org_id;
+        this.storage = storage;
+        __classPrivateFieldSet(this, _SignerSessionManager_eventEmitter, new events_2.EventEmitter([this.events]), "f");
+        __classPrivateFieldSet(this, _SignerSessionManager_client, {
+            client: __classPrivateFieldGet(this, _SignerSessionManager_instances, "m", _SignerSessionManager_createClient).call(this, sessionData.token),
+            token_exp: secondsSinceEpochToDate(sessionData.session_info.auth_token_exp),
+            session_exp: sessionData.session_exp
+                ? secondsSinceEpochToDate(sessionData.session_exp)
+                : undefined,
+        }, "f");
+    }
+}
+exports.SignerSessionManager = SignerSessionManager;
+_a = SignerSessionManager, _SignerSessionManager_eventEmitter = new WeakMap(), _SignerSessionManager_refreshing = new WeakMap(), _SignerSessionManager_client = new WeakMap(), _SignerSessionManager_instances = new WeakSet(), _SignerSessionManager_createClient = function _SignerSessionManager_createClient(token) {
+    return (0, api_1.createHttpClient)(this.env.SignerApiRoot, token);
+}, _SignerSessionManager_hasTimestampExpired = function _SignerSessionManager_hasTimestampExpired(exp, bufferSeconds) {
+    bufferSeconds ??= 0;
+    const expMsSinceEpoch = exp.getTime();
+    const nowMsSinceEpoch = new Date().getTime();
+    const bufferMs = bufferSeconds * 1000;
+    return expMsSinceEpoch < nowMsSinceEpoch + bufferMs;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signer_session_manager.js","sourceRoot":"","sources":["../../../src/session/signer_session_manager.ts"],"names":[],"mappings":"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","sourcesContent":["import { Events } from \"../events\";\nimport { EnvInterface } from \"../env\";\nimport { Client, createHttpClient, OpClient } from \"../api\";\nimport { MemorySessionStorage, SessionStorage } from \"./session_storage\";\nimport { delay } from \"../util\";\nimport {\n  ClientSessionInfo,\n  NewSessionResponse,\n  RefreshSignerSessionRequest,\n} from \"../schema_types\";\nimport { EventEmitter } from \"../events\";\nimport { SessionExpiredError } from \"../error\";\nimport { operations } from \"../schema\";\n\nconst DEFAULT_EXPIRATION_BUFFER_SECS = 30;\n\n/** JSON representation of our \"signer session\" file format */\nexport interface SignerSessionData {\n  /** The organization ID */\n  org_id: string;\n  /** The role ID */\n  role_id?: string;\n  /** The purpose of the session token */\n  purpose?: string;\n  /** The token to include in Authorization header */\n  token: string;\n  /** Session info */\n  session_info: ClientSessionInfo;\n  /** Session expiration (in seconds since UNIX epoch) beyond which it cannot be refreshed */\n  session_exp: number | undefined; // may be missing in legacy session files\n  /** The environment */\n  env: {\n    [\"Dev-CubeSignerStack\"]: EnvInterface;\n  };\n}\n\n/**\n * Constructs {@link Date} from a number representing seconds since unix epoch.\n * @param {number} secs Seconds since unix epoch.\n * @return {Date} The equivalent date.\n */\nfunction secondsSinceEpochToDate(secs: number): Date {\n  return new Date(secs * 1000);\n}\n\n/** Type of storage required for signer sessions */\nexport type SignerSessionStorage = SessionStorage<SignerSessionData>;\n\nexport interface SignerSessionLifetime {\n  /** Session lifetime (in seconds). Defaults to one week (604800). */\n  session?: number;\n  /** Auth token lifetime (in seconds). Defaults to five minutes (300). */\n  auth: number;\n  /** Refresh token lifetime (in seconds). Defaults to one day (86400). */\n  refresh?: number;\n  /** Grace lifetime (in seconds). Defaults to 30 seconds (30). */\n  grace?: number;\n}\n\n/** Generic session manager interface. */\nexport class SignerSessionManager {\n  readonly env: EnvInterface;\n  readonly orgId: string;\n  readonly storage: SignerSessionStorage;\n  readonly events = new Events();\n  readonly #eventEmitter: EventEmitter;\n  #refreshing: boolean = false;\n  #client: { client: Client; token_exp: Date; session_exp?: Date };\n\n  /**\n   * @return {string} The current auth token.\n   * @internal\n   */\n  async token(): Promise<string> {\n    const session = await this.storage.retrieve();\n    return session.token;\n  }\n\n  /**\n   * Refreshes the current session if needed, then returns a client using the current session.\n   *\n   * May **UPDATE/MUTATE** self.\n   *\n   * @param {operations} operation The operation that this client will be\n   *   used for. This parameter is used exclusively for more accurate error\n   *   reporting and does not affect functionality.\n   * @return {Client} The client with the current session\n   */\n  async client(operation?: keyof operations): Promise<Client> {\n    await this.refreshIfNeeded();\n\n    // trigger \"session expired\" if the session as a whole has expired\n    // or if (for whatever reason) the token is still stale\n    if (SignerSessionManager.#hasTimestampExpired(this.#client.token_exp) || this.hasExpired()) {\n      await this.#eventEmitter.emitSessionExpired();\n      throw new SessionExpiredError(operation);\n    }\n\n    return this.#client.client;\n  }\n\n  /** Revokes the session. */\n  async revoke(): Promise<void> {\n    const client = new OpClient(\"revokeCurrentSession\", await this.client(), this.#eventEmitter);\n    await client.del(\"/v0/org/{org_id}/session/self\", {\n      params: { path: { org_id: this.orgId } },\n    });\n  }\n\n  /**\n   * Refreshes the session and **UPDATES/MUTATES** self.\n   */\n  async refresh(): Promise<void> {\n    if (this.hasExpired()) {\n      await this.#eventEmitter.emitSessionExpired();\n      throw new SessionExpiredError(\"signerSessionRefresh\");\n    }\n\n    const currSession = await this.storage.retrieve();\n\n    const client = new OpClient(\"signerSessionRefresh\", this.#client.client, this.#eventEmitter);\n    const csi = currSession.session_info;\n    const data = await client.patch(\"/v1/org/{org_id}/token/refresh\", {\n      params: { path: { org_id: this.orgId } },\n      body: <RefreshSignerSessionRequest>{\n        epoch_num: csi.epoch,\n        epoch_token: csi.epoch_token,\n        other_token: csi.refresh_token,\n      },\n    });\n    const newSession = <SignerSessionData>{\n      ...currSession,\n      session_info: data.session_info,\n      token: data.token,\n    };\n\n    await this.storage.save(newSession);\n    this.#client = {\n      client: this.#createClient(newSession.token),\n      token_exp: secondsSinceEpochToDate(newSession.session_info.auth_token_exp),\n      session_exp: newSession.session_exp\n        ? secondsSinceEpochToDate(newSession.session_exp)\n        : undefined,\n    };\n  }\n\n  /**\n   * Returns whether it's time to refresh this token.\n   * @return {boolean} Whether it's time to refresh this token.\n   * @internal\n   */\n  async isStale(): Promise<boolean> {\n    return SignerSessionManager.#hasTimestampExpired(\n      this.#client.token_exp,\n      DEFAULT_EXPIRATION_BUFFER_SECS,\n    );\n  }\n\n  /**\n   * Return whether this session has expired and cannot be refreshed anymore.\n   * @return {boolean} Whether this session has expired.\n   * @internal\n   */\n  hasExpired(): boolean {\n    return (\n      (this.#client.session_exp || false) &&\n      SignerSessionManager.#hasTimestampExpired(this.#client.session_exp)\n    );\n  }\n\n  /**\n   * Refreshes the session if it is about to expire.\n   * @return {boolean} Whether the session token was refreshed.\n   * @internal\n   */\n  async refreshIfNeeded(): Promise<boolean> {\n    if (await this.isStale()) {\n      if (this.#refreshing) {\n        // wait until done refreshing\n        while (this.#refreshing) {\n          await delay(100);\n        }\n        return false;\n      } else {\n        // refresh\n        this.#refreshing = true;\n        try {\n          await this.refresh();\n          return true;\n        } finally {\n          this.#refreshing = false;\n        }\n      }\n    }\n\n    return false;\n  }\n\n  /**\n   * Automatically refreshes the session in the background (if needed) every\n   * minute. This is a simple wrapper around `setInterval`.\n   * @return {number} The interval ID of the refresh timer.\n   */\n  autoRefresh(): RefreshId {\n    return setInterval(async () => {\n      await this.refreshIfNeeded();\n    }, 60 * 1000);\n  }\n\n  /**\n   * Clears the auto refresh timer.\n   * @param {number} timer The timer ID to clear.\n   */\n  clearAutoRefresh(timer: RefreshId): void {\n    clearInterval(timer);\n  }\n\n  /**\n   * @param {EnvInterface} env The CubeSigner environment\n   * @param {string} orgId The organization ID\n   * @param {NewSessionResponse} session The session information.\n   * @param {SignerSessionStorage} storage The storage to use for saving the session.\n   * @return {Promise<SignerSessionManager>} New signer session manager.\n   */\n  static async createFromSessionInfo(\n    env: EnvInterface,\n    orgId: string,\n    session: NewSessionResponse,\n    storage?: SignerSessionStorage,\n  ): Promise<SignerSessionManager> {\n    const sessionData = {\n      env: {\n        [\"Dev-CubeSignerStack\"]: env,\n      },\n      org_id: orgId,\n      token: session.token,\n      purpose: \"sign via oidc\",\n      session_info: session.session_info,\n      session_exp: session.expiration!,\n    };\n    storage ??= new MemorySessionStorage();\n    await storage.save(sessionData);\n    return await SignerSessionManager.loadFromStorage(storage);\n  }\n\n  /**\n   * @param {SignerSessionData} sessionData The session information.\n   * @param {SignerSessionStorage} storage The storage to use for saving the session.\n   * @return {Promise<SignerSessionManager>} New signer session manager.\n   */\n  static async createFromSessionData(\n    sessionData: SignerSessionData,\n    storage?: SignerSessionStorage,\n  ): Promise<SignerSessionManager> {\n    storage ??= new MemorySessionStorage();\n    await storage.save(sessionData);\n    return await SignerSessionManager.loadFromStorage(storage);\n  }\n\n  /**\n   * Uses an existing session to create a new signer session manager.\n   *\n   * @param {SignerSessionStorage} storage The session storage to use\n   * @return {Promise<SingerSession>} New signer session manager\n   */\n  static async loadFromStorage(storage: SignerSessionStorage): Promise<SignerSessionManager> {\n    const session = await storage.retrieve();\n    return new SignerSessionManager(session, storage);\n  }\n\n  /**\n   * Constructor.\n   * @param {SignerSessionData} sessionData Session data\n   * @param {SignerSessionStorage} storage The session storage to use.\n   */\n  constructor(sessionData: SignerSessionData, storage: SignerSessionStorage) {\n    this.env = sessionData.env[\"Dev-CubeSignerStack\"];\n    this.orgId = sessionData.org_id;\n    this.storage = storage;\n    this.#eventEmitter = new EventEmitter([this.events]);\n    this.#client = {\n      client: this.#createClient(sessionData.token),\n      token_exp: secondsSinceEpochToDate(sessionData.session_info.auth_token_exp),\n      session_exp: sessionData.session_exp\n        ? secondsSinceEpochToDate(sessionData.session_exp)\n        : undefined,\n    };\n  }\n\n  /**\n   * Creates a new REST client with a given token\n   * @param {string} token The authorization token to use for the client\n   * @return {Client} The new REST client\n   */\n  #createClient(token: string): Client {\n    return createHttpClient(this.env.SignerApiRoot, token);\n  }\n\n  /**\n   * Check if a timestamp is within {@link bufferSeconds} seconds from expiration.\n   * @param {Date} exp The timestamp to check\n   * @param {number} bufferSeconds Time buffer in seconds (defaults to 0s)\n   * @return {boolean} True if the timestamp has expired\n   */\n  static #hasTimestampExpired(exp: Date, bufferSeconds?: number): boolean {\n    bufferSeconds ??= 0;\n    const expMsSinceEpoch = exp.getTime();\n    const nowMsSinceEpoch = new Date().getTime();\n    const bufferMs = bufferSeconds * 1000;\n    return expMsSinceEpoch < nowMsSinceEpoch + bufferMs;\n  }\n}\n\n/** Type of the refresh timer ID. */\nexport type RefreshId = ReturnType<typeof setInterval>;\n"]}

package/dist/src/signer_session.d.ts

@@ -0,0 +1,41 @@
+import { CubeSignerClient } from "./client";
+import { KeyInfo } from "./key";
+import { SignerSessionManager, SignerSessionStorage } from "./session/signer_session_manager";
+/** Signer session info. Can only be used to revoke a token, but not for authentication. */
+export declare class SignerSessionInfo {
+    #private;
+    readonly purpose: string;
+    /** Revoke this session */
+    revoke(): Promise<void>;
+    /**
+     * Internal constructor.
+     * @param {CubeSignerClient} cs CubeSigner instance to use when calling `revoke`
+     * @param {string} sessionId The ID of the session; can be used for revocation but not for auth
+     * @param {string} purpose Session purpose
+     * @internal
+     */
+    constructor(cs: CubeSignerClient, sessionId: string, purpose: string);
+}
+/**
+ * Signer session.
+ * Extends {@link CubeSignerClient} and provides a few convenience methods on top.
+ */
+export declare class SignerSession extends CubeSignerClient {
+    /**
+     * Loads an existing signer session from storage.
+     * @param {SignerSessionStorage} storage The session storage to use
+     * @return {Promise<SingerSession>} New signer session
+     */
+    static loadSignerSession(storage: SignerSessionStorage): Promise<SignerSession>;
+    /**
+     * Constructor.
+     * @param {SignerSessionManager} sessionMgr The session manager to use
+     * @internal
+     */
+    constructor(sessionMgr: SignerSessionManager);
+    /**
+     * Returns the list of keys that this token grants access to.
+     * @return {KeyInfo[]} The list of keys.
+     */
+    keys(): Promise<KeyInfo[]>;
+}

package/dist/src/signer_session.js

@@ -0,0 +1,77 @@
+"use strict";
+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 __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 _SignerSessionInfo_csc, _SignerSessionInfo_sessionId;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignerSession = exports.SignerSessionInfo = void 0;
+const client_1 = require("./client");
+const key_1 = require("./key");
+const signer_session_manager_1 = require("./session/signer_session_manager");
+/** Signer session info. Can only be used to revoke a token, but not for authentication. */
+class SignerSessionInfo {
+    /** Revoke this session */
+    async revoke() {
+        await __classPrivateFieldGet(this, _SignerSessionInfo_csc, "f").sessionRevoke(__classPrivateFieldGet(this, _SignerSessionInfo_sessionId, "f"));
+    }
+    // --------------------------------------------------------------------------
+    // -- INTERNAL --------------------------------------------------------------
+    // --------------------------------------------------------------------------
+    /**
+     * Internal constructor.
+     * @param {CubeSignerClient} cs CubeSigner instance to use when calling `revoke`
+     * @param {string} sessionId The ID of the session; can be used for revocation but not for auth
+     * @param {string} purpose Session purpose
+     * @internal
+     */
+    constructor(cs, sessionId, purpose) {
+        _SignerSessionInfo_csc.set(this, void 0);
+        _SignerSessionInfo_sessionId.set(this, void 0);
+        __classPrivateFieldSet(this, _SignerSessionInfo_csc, cs, "f");
+        __classPrivateFieldSet(this, _SignerSessionInfo_sessionId, sessionId, "f");
+        this.purpose = purpose;
+    }
+}
+exports.SignerSessionInfo = SignerSessionInfo;
+_SignerSessionInfo_csc = new WeakMap(), _SignerSessionInfo_sessionId = new WeakMap();
+/**
+ * Signer session.
+ * Extends {@link CubeSignerClient} and provides a few convenience methods on top.
+ */
+class SignerSession extends client_1.CubeSignerClient {
+    /**
+     * Loads an existing signer session from storage.
+     * @param {SignerSessionStorage} storage The session storage to use
+     * @return {Promise<SingerSession>} New signer session
+     */
+    static async loadSignerSession(storage) {
+        const manager = await signer_session_manager_1.SignerSessionManager.loadFromStorage(storage);
+        return new SignerSession(manager);
+    }
+    /**
+     * Constructor.
+     * @param {SignerSessionManager} sessionMgr The session manager to use
+     * @internal
+     */
+    constructor(sessionMgr) {
+        super(sessionMgr);
+    }
+    /**
+     * Returns the list of keys that this token grants access to.
+     * @return {KeyInfo[]} The list of keys.
+     */
+    async keys() {
+        const keys = await this.sessionKeysList();
+        return keys.map((k) => (0, key_1.toKeyInfo)(k));
+    }
+}
+exports.SignerSession = SignerSession;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/user_export.d.ts

@@ -0,0 +1,52 @@
+import { UserExportCompleteResponse, UserExportKeyMaterial } from "./schema_types";
+import type { CipherSuite } from "@hpke/core";
+/** Get the HPKE ciphersuite for user-export decryption.
+ *
+ * @return {any} The HPKE ciphersuite for user export.
+ */
+export declare function userExportCipherSuite(): Promise<CipherSuite>;
+/**
+ * Generate a key pair for user export.
+ *
+ * @return {Promise<CryptoKeyPair>} The newly generated key pair.
+ */
+export declare function userExportKeygen(): Promise<CryptoKeyPair>;
+/**
+ * Decrypt a user export.
+ *
+ * @param {CryptoKey} recipientKey The NIST P-256 secret key corresponding to the `publicKey` argument to the `userExportComplete` invocation that returned `response`.
+ * @param {UserExportCompleteResponse} response The response from a successful `userExportComplete` request.
+ * @return {Promise<UserExportKeyMaterial>} The decrypted key material.
+ */
+export declare function userExportDecrypt(recipientKey: CryptoKey, response: UserExportCompleteResponse): Promise<UserExportKeyMaterial>;
+/**
+ * Figure out how to load SubtleCrypto in the current environment.
+ *
+ * This functionality is reproduced from the hpke-js package,
+ *   https://github.com/dajiaji/hpke-js/
+ * which is Copyright (C) 2022 Ajitomi Daisuke and licensed
+ * under the MIT License, which follows:
+ *
+ * MIT License
+ *
+ * Copyright (c) 2022 Ajitomi Daisuke
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+export declare function loadSubtleCrypto(): Promise<SubtleCrypto>;

package/dist/src/user_export.js

@@ -0,0 +1,129 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSubtleCrypto = exports.userExportDecrypt = exports.userExportKeygen = exports.userExportCipherSuite = void 0;
+const util_1 = require("./util");
+/** Get the HPKE ciphersuite for user-export decryption.
+ *
+ * @return {any} The HPKE ciphersuite for user export.
+ */
+async function userExportCipherSuite() {
+    const hpke = await Promise.resolve().then(() => __importStar(require("@hpke/core"))); // eslint-disable-line @typescript-eslint/no-var-requires
+    const suite = new hpke.CipherSuite({
+        kem: new hpke.DhkemP256HkdfSha256(),
+        kdf: new hpke.HkdfSha256(),
+        aead: new hpke.Aes256Gcm(),
+    });
+    return suite;
+}
+exports.userExportCipherSuite = userExportCipherSuite;
+/**
+ * Generate a key pair for user export.
+ *
+ * @return {Promise<CryptoKeyPair>} The newly generated key pair.
+ */
+async function userExportKeygen() {
+    return (await userExportCipherSuite()).kem.generateKeyPair();
+}
+exports.userExportKeygen = userExportKeygen;
+/**
+ * Get the ArrayBuffer slice represented by a Buffer
+ *
+ * @param {Uint8Array} b The buffer to convert
+ * @return {ArrayBuffer} The resulting ArrayBuffer
+ */
+function toArrayBuffer(b) {
+    return b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength);
+}
+/**
+ * Decrypt a user export.
+ *
+ * @param {CryptoKey} recipientKey The NIST P-256 secret key corresponding to the `publicKey` argument to the `userExportComplete` invocation that returned `response`.
+ * @param {UserExportCompleteResponse} response The response from a successful `userExportComplete` request.
+ * @return {Promise<UserExportKeyMaterial>} The decrypted key material.
+ */
+async function userExportDecrypt(recipientKey, response) {
+    // The ciphersuite we use for decryption
+    const suite = await userExportCipherSuite();
+    // decrypt the export ciphertext using the HPKE one-shot API
+    const tenc = new TextEncoder();
+    const tdec = new TextDecoder();
+    const info = toArrayBuffer(tenc.encode(`cubist-signer::UserExportOwner::${response.user_id}`));
+    const public_key = toArrayBuffer((0, util_1.decodeBase64)(response.ephemeral_public_key));
+    const ctxt = toArrayBuffer((0, util_1.decodeBase64)(response.encrypted_key_material));
+    const decrypted = JSON.parse(tdec.decode(await suite.open({
+        recipientKey,
+        enc: public_key,
+        info: info,
+    }, ctxt)));
+    return decrypted;
+}
+exports.userExportDecrypt = userExportDecrypt;
+/**
+ * Figure out how to load SubtleCrypto in the current environment.
+ *
+ * This functionality is reproduced from the hpke-js package,
+ *   https://github.com/dajiaji/hpke-js/
+ * which is Copyright (C) 2022 Ajitomi Daisuke and licensed
+ * under the MIT License, which follows:
+ *
+ * MIT License
+ *
+ * Copyright (c) 2022 Ajitomi Daisuke
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+async function loadSubtleCrypto() {
+    if (globalThis !== undefined && globalThis.crypto !== undefined) {
+        // Browsers, Node.js >= v19, Cloudflare Workers, Bun, etc.
+        return globalThis.crypto.subtle;
+    }
+    // Node.js <= v18
+    try {
+        const { webcrypto } = await Promise.resolve().then(() => __importStar(require("crypto"))); // node:crypto
+        return webcrypto.subtle;
+    }
+    catch (e) {
+        throw new Error("subtle crypto not supported");
+    }
+}
+exports.loadSubtleCrypto = loadSubtleCrypto;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user_export.js","sourceRoot":"","sources":["../../src/user_export.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,iCAAsC;AAGtC;;;GAGG;AACI,KAAK,UAAU,qBAAqB;IACzC,MAAM,IAAI,GAAG,wDAAa,YAAY,GAAC,CAAC,CAAC,yDAAyD;IAClG,MAAM,KAAK,GAAG,IAAI,IAAI,CAAC,WAAW,CAAC;QACjC,GAAG,EAAE,IAAI,IAAI,CAAC,mBAAmB,EAAE;QACnC,GAAG,EAAE,IAAI,IAAI,CAAC,UAAU,EAAE;QAC1B,IAAI,EAAE,IAAI,IAAI,CAAC,SAAS,EAAE;KAC3B,CAAC,CAAC;IACH,OAAO,KAAK,CAAC;AACf,CAAC;AARD,sDAQC;AAED;;;;GAIG;AACI,KAAK,UAAU,gBAAgB;IACpC,OAAO,CAAC,MAAM,qBAAqB,EAAE,CAAC,CAAC,GAAG,CAAC,eAAe,EAAE,CAAC;AAC/D,CAAC;AAFD,4CAEC;AAED;;;;;GAKG;AACH,SAAS,aAAa,CAAC,CAAa;IAClC,OAAO,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,UAAU,CAAC,CAAC;AACnE,CAAC;AAED;;;;;;GAMG;AACI,KAAK,UAAU,iBAAiB,CACrC,YAAuB,EACvB,QAAoC;IAEpC,wCAAwC;IACxC,MAAM,KAAK,GAAG,MAAM,qBAAqB,EAAE,CAAC;IAE5C,4DAA4D;IAC5D,MAAM,IAAI,GAAG,IAAI,WAAW,EAAE,CAAC;IAC/B,MAAM,IAAI,GAAG,IAAI,WAAW,EAAE,CAAC;IAC/B,MAAM,IAAI,GAAG,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,mCAAmC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IAC/F,MAAM,UAAU,GAAG,aAAa,CAAC,IAAA,mBAAY,EAAC,QAAQ,CAAC,oBAAoB,CAAC,CAAC,CAAC;IAC9E,MAAM,IAAI,GAAG,aAAa,CAAC,IAAA,mBAAY,EAAC,QAAQ,CAAC,sBAAsB,CAAC,CAAC,CAAC;IAC1E,MAAM,SAAS,GAA0B,IAAI,CAAC,KAAK,CACjD,IAAI,CAAC,MAAM,CACT,MAAM,KAAK,CAAC,IAAI,CACd;QACE,YAAY;QACZ,GAAG,EAAE,UAAU;QACf,IAAI,EAAE,IAAI;KACX,EACD,IAAI,CACL,CACF,CACF,CAAC;IAEF,OAAO,SAAS,CAAC;AACnB,CAAC;AA3BD,8CA2BC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACI,KAAK,UAAU,gBAAgB;IACpC,IAAI,UAAU,KAAK,SAAS,IAAI,UAAU,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAChE,0DAA0D;QAC1D,OAAO,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC;IAClC,CAAC;IACD,iBAAiB;IACjB,IAAI,CAAC;QACH,MAAM,EAAE,SAAS,EAAE,GAAG,wDAAa,QAAQ,GAAC,CAAC,CAAC,cAAc;QAC5D,OAAQ,SAA+B,CAAC,MAAM,CAAC;IACjD,CAAC;IAAC,OAAO,CAAU,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;IACjD,CAAC;AACH,CAAC;AAZD,4CAYC","sourcesContent":["import { UserExportCompleteResponse, UserExportKeyMaterial } from \"./schema_types\";\nimport { decodeBase64 } from \"./util\";\nimport type { CipherSuite } from \"@hpke/core\";\n\n/** Get the HPKE ciphersuite for user-export decryption.\n *\n * @return {any} The HPKE ciphersuite for user export.\n */\nexport async function userExportCipherSuite(): Promise<CipherSuite> {\n  const hpke = await import(\"@hpke/core\"); // eslint-disable-line @typescript-eslint/no-var-requires\n  const suite = new hpke.CipherSuite({\n    kem: new hpke.DhkemP256HkdfSha256(),\n    kdf: new hpke.HkdfSha256(),\n    aead: new hpke.Aes256Gcm(),\n  });\n  return suite;\n}\n\n/**\n * Generate a key pair for user export.\n *\n * @return {Promise<CryptoKeyPair>} The newly generated key pair.\n */\nexport async function userExportKeygen(): Promise<CryptoKeyPair> {\n  return (await userExportCipherSuite()).kem.generateKeyPair();\n}\n\n/**\n * Get the ArrayBuffer slice represented by a Buffer\n *\n * @param {Uint8Array} b The buffer to convert\n * @return {ArrayBuffer} The resulting ArrayBuffer\n */\nfunction toArrayBuffer(b: Uint8Array): ArrayBuffer {\n  return b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength);\n}\n\n/**\n * Decrypt a user export.\n *\n * @param {CryptoKey} recipientKey The NIST P-256 secret key corresponding to the `publicKey` argument to the `userExportComplete` invocation that returned `response`.\n * @param {UserExportCompleteResponse} response The response from a successful `userExportComplete` request.\n * @return {Promise<UserExportKeyMaterial>} The decrypted key material.\n */\nexport async function userExportDecrypt(\n  recipientKey: CryptoKey,\n  response: UserExportCompleteResponse,\n): Promise<UserExportKeyMaterial> {\n  // The ciphersuite we use for decryption\n  const suite = await userExportCipherSuite();\n\n  // decrypt the export ciphertext using the HPKE one-shot API\n  const tenc = new TextEncoder();\n  const tdec = new TextDecoder();\n  const info = toArrayBuffer(tenc.encode(`cubist-signer::UserExportOwner::${response.user_id}`));\n  const public_key = toArrayBuffer(decodeBase64(response.ephemeral_public_key));\n  const ctxt = toArrayBuffer(decodeBase64(response.encrypted_key_material));\n  const decrypted: UserExportKeyMaterial = JSON.parse(\n    tdec.decode(\n      await suite.open(\n        {\n          recipientKey,\n          enc: public_key,\n          info: info,\n        },\n        ctxt,\n      ),\n    ),\n  );\n\n  return decrypted;\n}\n\n/**\n * Figure out how to load SubtleCrypto in the current environment.\n *\n * This functionality is reproduced from the hpke-js package,\n *   https://github.com/dajiaji/hpke-js/\n * which is Copyright (C) 2022 Ajitomi Daisuke and licensed\n * under the MIT License, which follows:\n *\n * MIT License\n *\n * Copyright (c) 2022 Ajitomi Daisuke\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\nexport async function loadSubtleCrypto() {\n  if (globalThis !== undefined && globalThis.crypto !== undefined) {\n    // Browsers, Node.js >= v19, Cloudflare Workers, Bun, etc.\n    return globalThis.crypto.subtle;\n  }\n  // Node.js <= v18\n  try {\n    const { webcrypto } = await import(\"crypto\"); // node:crypto\n    return (webcrypto as unknown as Crypto).subtle;\n  } catch (e: unknown) {\n    throw new Error(\"subtle crypto not supported\");\n  }\n}\n"]}