@cubist-labs/cubesigner-sdk-key-import 0.4.68-0

package/README.md

@@ -0,0 +1,90 @@
+# CubeSigner key import
+
+This library implements the client-side encryption used to import keys
+into CubeSigner.
+
+## WARNING
+
+Importing keys using code running in an untrusted environment is **dangerous**
+because that code must process secret key material. For example, importing
+keys from a user's web browser is **very risky**: exposing secret keys
+in browsers means that malicious web pages, advertisements, and extensions
+may be able to steal your key. JS execution environments are also great
+targets for side-channel attackers.
+
+Whenever possible, Cubist strongly recommends generating keys using the
+`createKey` API. We strongly recommend against using local keygen plus
+import as a replacement for real disaster-recovery backup. Please contact
+us if you have questions about or need help with disaster-recovery planning.
+
+## Example
+
+```ts
+import * as cs from "@cubist-labs/cubesigner-sdk";
+import * as csFs from "@cubist-labs/cubesigner-sdk-fs-storage";
+import { KeyImporter, type MnemonicToImport } from "@cubist-labs/cubesigner-sdk-key-import";
+
+// create a CubeSigner client from credentials on-disk, which
+// you can create by running `cs login` from the CLI.
+const client = await cs.CubeSignerClient.create(csFs.defaultManagementSessionManager());
+
+// create the key-importer instance
+const keyImporter = new KeyImporter(client.org());
+
+// mnemonics to import directly as EVM keys
+const evmMnemonics: MnemonicToImport[] = [
+  {
+    mnemonic: "car split like parrot uphold faint amount alert inch bean priority custom auction denial reason oyster food duck horn top battle video seed company",
+    derivationPath: "m/44'/60'/0'/0/0",
+  },
+  {
+    mnemonic: "force focus walnut scale barrel faint hotel fabric source because heavy provide bridge intact they receive stairs matter fetch family color happy slender accident",
+    derivationPath: "m/44'/60'/1'/0/0",
+    password: "bip39 passwords are silly",
+  },
+];
+// mnemonic to import directly as Bitcoin Segwit keys
+const btcMnemonics: MnemonicToImport[] = [
+  {
+    mnemonic: "style goddess hair mountain open when train mail fly engage fork walnut end toe mail price priority ocean uncover immune spray person slogan avoid",
+    derivationPath: "m/84'/0'/0'/0/0",
+  },
+  {
+    mnemonic: "marine airport maze doll note assume deliver second bus include deal escape detail friend letter captain glide actual resemble nation shell search elephant busy",
+    derivationPath: "m/84'/0'/9'/0/1",
+  },
+];
+
+// import the keys
+const evmKeys = await keyImporter.importMnemonics(cs.Secp256k1.Evm, evmMnemonics);
+const btcKeys = await keyImporter.importMnemonics(cs.Secp256k1.Btc, btcMnemonics);
+
+// If you want to derive many keys from the same mnemonic, you should import
+// the bare mnemonic and use the `deriveKey` and/or `deriveKeys` methods to
+// create keys.
+const bareMnemonic: MnemonicToImport = {
+  mnemonic: "divide impact town typical inhale uncover rifle pet multiply idea long before debate apart pulse type need produce among pony attend cat injury ring",
+};
+
+// First, import the bare mnemonic
+const mnemonic = (await keyImporter.importMnemonics(cs.Mnemonic, [bareMnemonic]))[0];
+
+// Then derive keys from it.
+const deriveResponse = await org.deriveKey(cs.Secp256k1.Taproot, "m/86'/0'/3'/1/0", mnemonic.materialId);
+const otherDeriveResponses = await org.deriveKeys(
+  cs.Secp256k1.Ava,
+  [
+    "m/1'/2'/3",
+    "m/4'/5/6",
+    "m/7/8'/9",
+  ],
+  mnemonic.materialId,
+);
+```
+
+# License
+
+Copyright (C) 2024 Cubist, Inc. All rights reserved.
+
+This library is licensed under the MIT and Apache-2.0 licenses.
+See the [../../NOTICE] file for further information.

package/dist/import.d.ts

@@ -0,0 +1,23 @@
+import type { Key, KeyType, Org } from "@cubist-labs/cubesigner-sdk";
+import type { MnemonicToImport } from "./mnemonic";
+/**
+ * An import encryption key and the corresponding attestation document
+ */
+export declare class KeyImporter {
+    #private;
+    /**
+     * Construct from a CubeSigner `Org` instance
+     *
+     * @param { Org } cs A CubeSigner `Org` instance
+     */
+    constructor(cs: Org);
+    /**
+     * Encrypts a set of mnemonics and imports them.
+     *
+     * @param { KeyType } keyType The type of key to import
+     * @param { MnemonicToImport[] } mnes The mnemonics to import, with optional derivation paths and passwords
+     * @return { Promise<Key[]> } `Key` objects for each imported key.
+     */
+    importMnemonics(keyType: KeyType, mnes: MnemonicToImport[]): Promise<Key[]>;
+}
+//# sourceMappingURL=import.d.ts.map

package/dist/import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../src/import.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,GAAG,EACH,OAAO,EACP,GAAG,EACJ,MAAM,6BAA6B,CAAC;AAWrC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAoLnD;;GAEG;AACH,qBAAa,WAAW;;IAOtB;;;;OAIG;gBACS,EAAE,EAAE,GAAG;IAoDnB;;;;;;OAMG;IACU,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;CAyEzF"}

package/dist/import.js

@@ -0,0 +1,333 @@
+"use strict";
+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 _WrappedImportKey_instances, _WrappedImportKey_enclaveAttestation, _WrappedImportKey_enclaveSignature, _WrappedImportKey_verifyImportKey, _WrappedImportKey_signedData, _KeyImporter_instances, _KeyImporter_wrappedImportKey, _KeyImporter_subtleCrypto, _KeyImporter_publicKeyHandle, _KeyImporter_hpkeSuite, _KeyImporter_cs, _KeyImporter_getWrappedImportAndPubKey, _KeyImporter_getSubtleCrypto, _KeyImporter_encrypt;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyImporter = void 0;
+const cubesigner_sdk_1 = require("@cubist-labs/cubesigner-sdk");
+const core_1 = require("@hpke/core");
+const asn1_ecc_1 = require("@peculiar/asn1-ecc");
+const asn1_schema_1 = require("@peculiar/asn1-schema");
+const x509_1 = require("@peculiar/x509");
+const mnemonic_1 = require("./mnemonic");
+const util_1 = require("./util");
+// domain-separation tag used when generating signing hash for import key
+const IMPORT_KEY_SIGNING_DST = new TextEncoder().encode("CUBESIGNER_EPHEMERAL_IMPORT_P384");
+// attestation document slack times
+const MAX_ATTESTATION_AGE_MINUTES = 15n;
+const MAX_ATTESTATION_FUTURE_MINUTES = 5n;
+const WIK_REFRESH_EARLY_MILLIS = 60000n;
+// OIDs for elliptic curve X509 certs
+const EC_PUBLIC_KEY = "1.2.840.10045.2.1";
+const NIST_P384 = "1.3.132.0.34";
+// Maximum number of keys to import in a single API call
+const MAX_IMPORTS_PER_API_CALL = 32n;
+// AWS Nitro Enclaves root CA certificate
+// https://aws-nitro-enclaves.amazonaws.com/AWS_NitroEnclaves_Root-G1.zip
+//
+// See the documentation about AWS Nitro Enclaves verification:
+// https://docs.aws.amazon.com/enclaves/latest/user/verify-root.html
+const AWS_CA_CERT = "MIICETCCAZagAwIBAgIRAPkxdWgbkK/hHUbMtOTn+FYwCgYIKoZIzj0EAwMwSTELMAkGA1UEBhMCVVMxDzANBgNVBAoMBkFtYXpvbjEMMAoGA1UECwwDQVdTMRswGQYDVQQDDBJhd3Mubml0cm8tZW5jbGF2ZXMwHhcNMTkxMDI4MTMyODA1WhcNNDkxMDI4MTQyODA1WjBJMQswCQYDVQQGEwJVUzEPMA0GA1UECgwGQW1hem9uMQwwCgYDVQQLDANBV1MxGzAZBgNVBAMMEmF3cy5uaXRyby1lbmNsYXZlczB2MBAGByqGSM49AgEGBSuBBAAiA2IABPwCVOumCMHzaHDimtqQvkY4MpJzbolL//Zy2YlES1BR5TSksfbb48C8WBoyt7F2Bw7eEtaaP+ohG2bnUs990d0JX28TcPQXCEPZ3BABIeTPYwEoCWZEh8l5YoQwTcU/9KNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkCW1DdkFR+eWw5b6cp3PmanfS5YwDgYDVR0PAQH/BAQDAgGGMAoGCCqGSM49BAMDA2kAMGYCMQCjfy+Rocm9Xue4YnwWmNJVA44fA0P5W2OpYow9OYCVRaEevL8uO1XYru5xtMPWrfMCMQCi85sWBbJwKKXdS6BptQFuZbT73o/gBh1qUxl/nNr12UO8Yfwr6wPLb+6NIwLz3/Y=";
+/**
+ * The result of deserializing a CreateKeyImportKeyResponse
+ */
+class WrappedImportKey {
+    /**
+     * Constructor. This is only called from `WrappedImportKey.createAndVerify()`.
+     *
+     * @param { CreateKeyImportKeyResponse } resp The response from CubeSigner
+     */
+    constructor(resp) {
+        _WrappedImportKey_instances.add(this);
+        _WrappedImportKey_enclaveAttestation.set(this, void 0);
+        _WrappedImportKey_enclaveSignature.set(this, void 0);
+        if (!resp.enclave_attestation || !resp.enclave_signature) {
+            throw new Error("No attestation found in CreateKeyImportKeyResponse");
+        }
+        // parse the response
+        this.publicKey = new Uint8Array(Buffer.from(resp.public_key, "base64"));
+        this.publicKeyBase64 = resp.public_key;
+        this.skEnc = new Uint8Array(Buffer.from(resp.sk_enc, "base64"));
+        this.skEncBase64 = resp.sk_enc;
+        this.dkEnc = new Uint8Array(Buffer.from(resp.dk_enc, "base64"));
+        this.dkEncBase64 = resp.dk_enc;
+        __classPrivateFieldSet(this, _WrappedImportKey_enclaveAttestation, new Uint8Array(Buffer.from(resp.enclave_attestation, "base64")), "f");
+        __classPrivateFieldSet(this, _WrappedImportKey_enclaveSignature, new Uint8Array(Buffer.from(resp.enclave_signature, "base64")), "f");
+        this.expEpochSeconds = BigInt(resp.expires);
+        // this array is updated in createAndVerify once verification succeeds
+        this.verifiedHash = new Uint8Array(32);
+    }
+    /**
+     * Create and verify an instance of this type
+     *
+     * @param { CreateKeyImportKeyResponse } resp The response from CubeSigner
+     * @param { SubtleCrypto } subtle An instance of SubtleCrypto used for verification
+     * @return { Promise<WrappedImportKey> } A newly constructed instance
+     */
+    static async createAndVerify(resp, subtle) {
+        const ret = new WrappedImportKey(resp);
+        const hash = await __classPrivateFieldGet(ret, _WrappedImportKey_instances, "m", _WrappedImportKey_verifyImportKey).call(ret, subtle);
+        ret.verifiedHash.set(hash);
+        return ret;
+    }
+    /**
+     * Returns `true` if this WrappedImportKey needs to be refreshed.
+     *
+     * @return { boolean } True just if this key needs to be refreshed.
+     */
+    needsRefresh() {
+        // force refresh if we're within WIK_REFRESH_EARLY_MILLIS of the expiration
+        return (0, util_1.nowEpochMillis)() + WIK_REFRESH_EARLY_MILLIS > this.expEpochSeconds * 1000n;
+    }
+}
+_WrappedImportKey_enclaveAttestation = new WeakMap(), _WrappedImportKey_enclaveSignature = new WeakMap(), _WrappedImportKey_instances = new WeakSet(), _WrappedImportKey_verifyImportKey = 
+/**
+ * Verify this wrapped import key.
+ *
+ * @param { SubtleCrypto } subtle An instance of SubtleCrypto used for verification
+ * @return { Promise<Uint8Array> } The hash of the successfully verified wrapped import key
+ */
+async function _WrappedImportKey_verifyImportKey(subtle) {
+    // check expiration date
+    if ((0, util_1.nowEpochMillis)() > this.expEpochSeconds * 1000n) {
+        throw new Error("Import key is expired");
+    }
+    // make sure that there is an attestation
+    if (!__classPrivateFieldGet(this, _WrappedImportKey_enclaveSignature, "f") || !__classPrivateFieldGet(this, _WrappedImportKey_enclaveAttestation, "f")) {
+        throw new Error("No attestation found");
+    }
+    const signing_key = await verifyAttestationKey(__classPrivateFieldGet(this, _WrappedImportKey_enclaveAttestation, "f"));
+    // we use subtlecrypto's impl of RSA-PSS verification
+    const rsaPssKeyParams = {
+        name: "RSA-PSS",
+        hash: "SHA-256",
+    };
+    const pubkey = await subtle.importKey("spki", signing_key, rsaPssKeyParams, true, ["verify"]);
+    const pubkeyAlg = pubkey.algorithm;
+    // compute the signing hash and verify the signature
+    const message = __classPrivateFieldGet(this, _WrappedImportKey_instances, "m", _WrappedImportKey_signedData).call(this);
+    const mlen = Number(BigInt(pubkeyAlg.modulusLength) / 8n);
+    const rsaPssParams = {
+        name: "RSA-PSS",
+        saltLength: mlen - 2 - 32,
+    };
+    if (await subtle.verify(rsaPssParams, pubkey, __classPrivateFieldGet(this, _WrappedImportKey_enclaveSignature, "f"), message)) {
+        return new Uint8Array(await subtle.digest("SHA-256", message));
+    }
+    throw new Error("Import key signature verification failed");
+}, _WrappedImportKey_signedData = function _WrappedImportKey_signedData() {
+    const parts = [
+        // domain separation tag
+        (0, util_1.toBigEndian)(BigInt(IMPORT_KEY_SIGNING_DST.length), 2),
+        IMPORT_KEY_SIGNING_DST,
+        // public key
+        (0, util_1.toBigEndian)(BigInt(this.publicKey.length), 2),
+        this.publicKey,
+        // sk_enc
+        (0, util_1.toBigEndian)(BigInt(this.skEnc.length), 2),
+        this.skEnc,
+        // dk_enc
+        (0, util_1.toBigEndian)(BigInt(this.dkEnc.length), 2),
+        this.dkEnc,
+        // 8-byte big-endian expiration time in seconds since UNIX epoch
+        (0, util_1.toBigEndian)(this.expEpochSeconds, 8),
+    ];
+    return (0, util_1.concatArrays)(parts);
+};
+/**
+ * An import encryption key and the corresponding attestation document
+ */
+class KeyImporter {
+    /**
+     * Construct from a CubeSigner `Org` instance
+     *
+     * @param { Org } cs A CubeSigner `Org` instance
+     */
+    constructor(cs) {
+        _KeyImporter_instances.add(this);
+        _KeyImporter_wrappedImportKey.set(this, null);
+        _KeyImporter_subtleCrypto.set(this, null);
+        _KeyImporter_publicKeyHandle.set(this, null);
+        _KeyImporter_hpkeSuite.set(this, void 0);
+        _KeyImporter_cs.set(this, void 0);
+        __classPrivateFieldSet(this, _KeyImporter_cs, cs, "f");
+        __classPrivateFieldSet(this, _KeyImporter_hpkeSuite, new core_1.CipherSuite({
+            kem: new core_1.DhkemP384HkdfSha384(),
+            kdf: new core_1.HkdfSha384(),
+            aead: new core_1.Aes256Gcm(),
+        }), "f");
+    }
+    /**
+     * Encrypts a set of mnemonics and imports them.
+     *
+     * @param { KeyType } keyType The type of key to import
+     * @param { MnemonicToImport[] } mnes The mnemonics to import, with optional derivation paths and passwords
+     * @return { Promise<Key[]> } `Key` objects for each imported key.
+     */
+    async importMnemonics(keyType, mnes) {
+        const nChunks = Number((BigInt(mnes.length) + MAX_IMPORTS_PER_API_CALL - 1n) / MAX_IMPORTS_PER_API_CALL);
+        const keys = [];
+        for (let i = 0; i < nChunks; ++i) {
+            // first, make sure that the wrapped import key is valid, i.e., that
+            // we have retrieved it and that it hasn't expired. We do this here
+            // for a couple reasons:
+            //
+            // - all encryptions in a give request must use the same import key, and
+            //
+            // - when importing a huge number of keys the import pubkey might expire
+            //   during the import, so we check for expiration before each request
+            const { wik, ipk } = await __classPrivateFieldGet(this, _KeyImporter_instances, "m", _KeyImporter_getWrappedImportAndPubKey).call(this);
+            // next, encrypt this chunk of mnemonics
+            const start = Number(MAX_IMPORTS_PER_API_CALL) * i;
+            const end = Number(MAX_IMPORTS_PER_API_CALL) + start;
+            const mneSlice = mnes.slice(start, end);
+            const key_material = [];
+            for (const mne of mneSlice) {
+                const keyPkg = (0, mnemonic_1.newMnemonicKeyPackage)(mne);
+                const material = await __classPrivateFieldGet(this, _KeyImporter_instances, "m", _KeyImporter_encrypt).call(this, keyPkg, wik.verifiedHash, ipk);
+                key_material.push(material);
+            }
+            // construct the request
+            const req = {
+                public_key: wik.publicKeyBase64,
+                sk_enc: wik.skEncBase64,
+                dk_enc: wik.dkEncBase64,
+                expires: Number(wik.expEpochSeconds),
+                key_type: keyType,
+                key_material,
+            };
+            // send it and append the result to the return value
+            const resp = await __classPrivateFieldGet(this, _KeyImporter_cs, "f").importKeys(req);
+            keys.push(...resp);
+        }
+        return keys;
+    }
+}
+exports.KeyImporter = KeyImporter;
+_KeyImporter_wrappedImportKey = new WeakMap(), _KeyImporter_subtleCrypto = new WeakMap(), _KeyImporter_publicKeyHandle = new WeakMap(), _KeyImporter_hpkeSuite = new WeakMap(), _KeyImporter_cs = new WeakMap(), _KeyImporter_instances = new WeakSet(), _KeyImporter_getWrappedImportAndPubKey = 
+/**
+ * Check that the wrapped import key is unexpired and verified. Otherwise,
+ * request a new one, verify it, and update the verified signing hash.
+ *
+ * @return { Promise<[WrappedImportKey, CryptoKey]> } The verified signing hash.
+ */
+async function _KeyImporter_getWrappedImportAndPubKey() {
+    if (!__classPrivateFieldGet(this, _KeyImporter_wrappedImportKey, "f")) {
+        // first time we load a WrappedImportKey, make sure the x509 crypto
+        // provider is set correctly.
+        x509_1.cryptoProvider.set(await (0, cubesigner_sdk_1.loadCrypto)());
+    }
+    if (!__classPrivateFieldGet(this, _KeyImporter_wrappedImportKey, "f") || __classPrivateFieldGet(this, _KeyImporter_wrappedImportKey, "f").needsRefresh()) {
+        const kikResp = await __classPrivateFieldGet(this, _KeyImporter_cs, "f").createKeyImportKey();
+        const subtle = await __classPrivateFieldGet(this, _KeyImporter_instances, "m", _KeyImporter_getSubtleCrypto).call(this);
+        const wik = await WrappedImportKey.createAndVerify(kikResp, subtle);
+        // import the public key from the WrappedImportKey
+        const p384Params = {
+            name: "ECDH",
+            namedCurve: "P-384",
+        };
+        __classPrivateFieldSet(this, _KeyImporter_publicKeyHandle, await subtle.importKey("raw", wik.publicKey, p384Params, true, []), "f");
+        __classPrivateFieldSet(this, _KeyImporter_wrappedImportKey, wik, "f");
+    }
+    return {
+        wik: __classPrivateFieldGet(this, _KeyImporter_wrappedImportKey, "f"),
+        ipk: __classPrivateFieldGet(this, _KeyImporter_publicKeyHandle, "f"),
+    };
+}, _KeyImporter_getSubtleCrypto = 
+/**
+ * Get or create an instance of SubtleCrypto.
+ *
+ * @return { SubtleCrypto } The instance of SubtleCrypto.
+ */
+async function _KeyImporter_getSubtleCrypto() {
+    if (!__classPrivateFieldGet(this, _KeyImporter_subtleCrypto, "f")) {
+        __classPrivateFieldSet(this, _KeyImporter_subtleCrypto, await (0, cubesigner_sdk_1.loadSubtleCrypto)(), "f");
+    }
+    return __classPrivateFieldGet(this, _KeyImporter_subtleCrypto, "f");
+}, _KeyImporter_encrypt = 
+/**
+ * Encrypt to this wrapped import key. Stores the result in `this.encrypted_keys`
+ *
+ * @param { Uint8Array } data The data to encrypt
+ * @param { Uint8Array } verifiedHash The verified signing hash of the wrapped import key to which to encrypt
+ * @param { CryptoKey } pubkey The public key to encrypt to
+ * @return { Promise<ImportKeyRequestMaterial> } The encrypted key material
+ */
+async function _KeyImporter_encrypt(data, verifiedHash, pubkey) {
+    // set up the HPKE sender
+    const sender = await __classPrivateFieldGet(this, _KeyImporter_hpkeSuite, "f").createSenderContext({
+        recipientPublicKey: pubkey,
+        info: verifiedHash,
+    });
+    // encrypt and construct the return value
+    const senderCtext = await sender.seal(data);
+    return {
+        salt: "",
+        client_public_key: Buffer.from(sender.enc).toString("base64"),
+        ikm_enc: Buffer.from(senderCtext).toString("base64"),
+    };
+};
+/**
+ * Verifies the attestation key against the AWS Nitro Enclaves signing
+ * key and returns the attested signing key.
+ *
+ * @param { Uint8Array } attBytes An attestation from an AWS nitro enclave
+ * @return { Promise<Uint8Array> } The signing key that was attested, or null if verification failed
+ */
+async function verifyAttestationKey(attBytes) {
+    // cbor-x is being imported as ESM, so we must asynchronously import it here.
+    // Because we only use that and auth0/cose here, we import both this way.
+    const { Sign1 } = await import("@auth0/cose");
+    const { decode: cborDecode } = await import("cbor-x");
+    const att = Sign1.decode(attBytes);
+    const attDoc = cborDecode(att.payload);
+    // check expiration date of attestation
+    const latest = (0, util_1.nowEpochMillis)() + MAX_ATTESTATION_FUTURE_MINUTES * 60n * 1000n;
+    const earliest = latest - (MAX_ATTESTATION_FUTURE_MINUTES + MAX_ATTESTATION_AGE_MINUTES) * 60n * 1000n;
+    if (attDoc.timestamp < earliest || attDoc.timestamp > latest) {
+        throw new Error("Attestation is expired");
+    }
+    // if there's no public key in this attestation, give up
+    if (!attDoc.public_key) {
+        throw new Error("Attestation did not include a signing public key");
+    }
+    // Verify certificate chain starting with AWS Nitro CA cert
+    let parent = new x509_1.X509Certificate(AWS_CA_CERT);
+    for (let i = 0; i < attDoc.cabundle.length; ++i) {
+        const cert = new x509_1.X509Certificate(attDoc.cabundle[i]);
+        if (!(await cert.verify(parent))) {
+            throw new Error(`Attestation certificate chain failed at index ${i}`);
+        }
+        parent = cert;
+    }
+    const cert = new x509_1.X509Certificate(attDoc.certificate);
+    if (!(await cert.verify(parent))) {
+        throw new Error("Attestation certificate chain failed at leaf");
+    }
+    const pubkey = cert.publicKey;
+    // make sure that we got the expected public key type
+    const alg = new x509_1.AlgorithmProvider().toAsnAlgorithm(pubkey.algorithm);
+    if (alg.algorithm != EC_PUBLIC_KEY) {
+        // not the expected algorithm, i.e., elliptic curve signing
+        throw new Error("Attestation contained unexpected signature algorithm");
+    }
+    const params = asn1_schema_1.AsnParser.parse(alg.parameters, asn1_ecc_1.ECParameters);
+    if (!params.namedCurve || params.namedCurve !== NIST_P384) {
+        // not the expected params, i.e., NIST P384
+        throw new Error("Attestation contained unexpected signature algorithm");
+    }
+    // verify the cose signature with the key, which we verified against
+    // the AWS Nitro CA certificate above
+    await att.verify(await pubkey.export());
+    return attDoc.public_key;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"import.js","sourceRoot":"","sources":["../src/import.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAQA,gEAA2E;AAC3E,qCAAqF;AACrF,iDAAkD;AAClD,uDAAkD;AAClD,yCAIwB;AAGxB,yCAAmD;AACnD,iCAAmE;AAEnE,yEAAyE;AACzE,MAAM,sBAAsB,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,kCAAkC,CAAC,CAAC;AAE5F,mCAAmC;AACnC,MAAM,2BAA2B,GAAG,GAAG,CAAC;AACxC,MAAM,8BAA8B,GAAG,EAAE,CAAC;AAC1C,MAAM,wBAAwB,GAAG,MAAO,CAAC;AAEzC,qCAAqC;AACrC,MAAM,aAAa,GAAG,mBAAmB,CAAC;AAC1C,MAAM,SAAS,GAAG,cAAc,CAAC;AAEjC,wDAAwD;AACxD,MAAM,wBAAwB,GAAG,GAAG,CAAC;AAErC,yCAAyC;AACzC,yEAAyE;AACzE,EAAE;AACF,+DAA+D;AAC/D,oEAAoE;AACpE,MAAM,WAAW,GACf,0sBAA0sB,CAAC;AAE7sB;;GAEG;AACH,MAAM,gBAAgB;IAgBpB;;;;OAIG;IACH,YAAoB,IAAgC;;QAR3C,uDAAgC;QAChC,qDAA8B;QAQrC,IAAI,CAAC,IAAI,CAAC,mBAAmB,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACzD,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;QACxE,CAAC;QAED,qBAAqB;QACrB,IAAI,CAAC,SAAS,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC;QACxE,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,UAAU,CAAC;QAEvC,IAAI,CAAC,KAAK,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;QAChE,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC;QAE/B,IAAI,CAAC,KAAK,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;QAChE,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC;QAE/B,uBAAA,IAAI,wCAAuB,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE,QAAQ,CAAC,CAAC,MAAA,CAAC;QAC3F,uBAAA,IAAI,sCAAqB,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,QAAQ,CAAC,CAAC,MAAA,CAAC;QACvF,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAE5C,sEAAsE;QACtE,IAAI,CAAC,YAAY,GAAG,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC;IACzC,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAC,KAAK,CAAC,eAAe,CACjC,IAAgC,EAChC,MAAoB;QAEpB,MAAM,GAAG,GAAG,IAAI,gBAAgB,CAAC,IAAI,CAAC,CAAC;QACvC,MAAM,IAAI,GAAG,MAAM,uBAAA,GAAG,sEAAiB,MAApB,GAAG,EAAkB,MAAM,CAAC,CAAC;QAChD,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC3B,OAAO,GAAG,CAAC;IACb,CAAC;IA0CD;;;;OAIG;IACI,YAAY;QACjB,2EAA2E;QAC3E,OAAO,IAAA,qBAAc,GAAE,GAAG,wBAAwB,GAAG,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;IACpF,CAAC;CA+BF;;AA/EC;;;;;GAKG;AACH,KAAK,4CAAkB,MAAoB;IACzC,wBAAwB;IACxB,IAAI,IAAA,qBAAc,GAAE,GAAG,IAAI,CAAC,eAAe,GAAG,KAAK,EAAE,CAAC;QACpD,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;IAC3C,CAAC;IAED,yCAAyC;IACzC,IAAI,CAAC,uBAAA,IAAI,0CAAkB,IAAI,CAAC,uBAAA,IAAI,4CAAoB,EAAE,CAAC;QACzD,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;IAC1C,CAAC;IACD,MAAM,WAAW,GAAG,MAAM,oBAAoB,CAAC,uBAAA,IAAI,4CAAoB,CAAC,CAAC;IAEzE,qDAAqD;IACrD,MAAM,eAAe,GAAG;QACtB,IAAI,EAAE,SAAS;QACf,IAAI,EAAE,SAAS;KAChB,CAAC;IACF,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,WAAW,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC9F,MAAM,SAAS,GAAG,MAAM,CAAC,SAAiD,CAAC;IAE3E,oDAAoD;IACpD,MAAM,OAAO,GAAG,uBAAA,IAAI,iEAAY,MAAhB,IAAI,CAAc,CAAC;IACnC,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,CAAC;IAC1D,MAAM,YAAY,GAAG;QACnB,IAAI,EAAE,SAAS;QACf,UAAU,EAAE,IAAI,GAAG,CAAC,GAAG,EAAE;KAC1B,CAAC;IAEF,IAAI,MAAM,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,EAAE,uBAAA,IAAI,0CAAkB,EAAE,OAAO,CAAC,EAAE,CAAC;QAC/E,OAAO,IAAI,UAAU,CAAC,MAAM,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC;IACjE,CAAC;IACD,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;AAC9D,CAAC;IAkBC,MAAM,KAAK,GAAiB;QAC1B,wBAAwB;QACxB,IAAA,kBAAW,EAAC,MAAM,CAAC,sBAAsB,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACrD,sBAAsB;QAEtB,aAAa;QACb,IAAA,kBAAW,EAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAC7C,IAAI,CAAC,SAAS;QAEd,SAAS;QACT,IAAA,kBAAW,EAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACzC,IAAI,CAAC,KAAK;QAEV,SAAS;QACT,IAAA,kBAAW,EAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACzC,IAAI,CAAC,KAAK;QAEV,gEAAgE;QAChE,IAAA,kBAAW,EAAC,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC;KACrC,CAAC;IAEF,OAAO,IAAA,mBAAY,EAAC,KAAK,CAAC,CAAC;AAC7B,CAAC;AAWH;;GAEG;AACH,MAAa,WAAW;IAOtB;;;;OAIG;IACH,YAAY,EAAO;;QAXnB,wCAA6C,IAAI,EAAC;QAClD,oCAAqC,IAAI,EAAC;QAC1C,uCAAqC,IAAI,EAAC;QACjC,yCAAwB;QACxB,kCAAS;QAQhB,uBAAA,IAAI,mBAAO,EAAE,MAAA,CAAC;QACd,uBAAA,IAAI,0BAAc,IAAI,kBAAW,CAAC;YAChC,GAAG,EAAE,IAAI,0BAAmB,EAAE;YAC9B,GAAG,EAAE,IAAI,iBAAU,EAAE;YACrB,IAAI,EAAE,IAAI,gBAAS,EAAE;SACtB,CAAC,MAAA,CAAC;IACL,CAAC;IA6CD;;;;;;OAMG;IACI,KAAK,CAAC,eAAe,CAAC,OAAgB,EAAE,IAAwB;QACrE,MAAM,OAAO,GAAG,MAAM,CACpB,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,wBAAwB,GAAG,EAAE,CAAC,GAAG,wBAAwB,CACjF,CAAC;QACF,MAAM,IAAI,GAAG,EAAE,CAAC;QAEhB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,EAAE,CAAC,EAAE,CAAC;YACjC,oEAAoE;YACpE,mEAAmE;YACnE,wBAAwB;YACxB,EAAE;YACF,wEAAwE;YACxE,EAAE;YACF,wEAAwE;YACxE,sEAAsE;YACtE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,MAAM,uBAAA,IAAI,sEAA2B,MAA/B,IAAI,CAA6B,CAAC;YAE7D,wCAAwC;YACxC,MAAM,KAAK,GAAG,MAAM,CAAC,wBAAwB,CAAC,GAAG,CAAC,CAAC;YACnD,MAAM,GAAG,GAAG,MAAM,CAAC,wBAAwB,CAAC,GAAG,KAAK,CAAC;YACrD,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YACxC,MAAM,YAAY,GAAG,EAAE,CAAC;YACxB,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;gBAC3B,MAAM,MAAM,GAAG,IAAA,gCAAqB,EAAC,GAAG,CAAC,CAAC;gBAC1C,MAAM,QAAQ,GAAG,MAAM,uBAAA,IAAI,oDAAS,MAAb,IAAI,EAAU,MAAM,EAAE,GAAG,CAAC,YAAY,EAAE,GAAG,CAAC,CAAC;gBACpE,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC9B,CAAC;YAED,wBAAwB;YACxB,MAAM,GAAG,GAAqB;gBAC5B,UAAU,EAAE,GAAG,CAAC,eAAe;gBAC/B,MAAM,EAAE,GAAG,CAAC,WAAW;gBACvB,MAAM,EAAE,GAAG,CAAC,WAAW;gBACvB,OAAO,EAAE,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC;gBACpC,QAAQ,EAAE,OAAO;gBACjB,YAAY;aACb,CAAC;YAEF,oDAAoD;YACpD,MAAM,IAAI,GAAG,MAAM,uBAAA,IAAI,uBAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;YAC5C,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QACrB,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;CA6BF;AAhJD,kCAgJC;;AA3HC;;;;;GAKG;AACH,KAAK;IACH,IAAI,CAAC,uBAAA,IAAI,qCAAkB,EAAE,CAAC;QAC5B,mEAAmE;QACnE,6BAA6B;QAC7B,qBAAkB,CAAC,GAAG,CAAC,MAAM,IAAA,2BAAU,GAAE,CAAC,CAAC;IAC7C,CAAC;IACD,IAAI,CAAC,uBAAA,IAAI,qCAAkB,IAAI,uBAAA,IAAI,qCAAkB,CAAC,YAAY,EAAE,EAAE,CAAC;QACrE,MAAM,OAAO,GAAG,MAAM,uBAAA,IAAI,uBAAI,CAAC,kBAAkB,EAAE,CAAC;QACpD,MAAM,MAAM,GAAG,MAAM,uBAAA,IAAI,4DAAiB,MAArB,IAAI,CAAmB,CAAC;QAC7C,MAAM,GAAG,GAAG,MAAM,gBAAgB,CAAC,eAAe,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QAEpE,kDAAkD;QAClD,MAAM,UAAU,GAAG;YACjB,IAAI,EAAE,MAAM;YACZ,UAAU,EAAE,OAAO;SACpB,CAAC;QACF,uBAAA,IAAI,gCAAoB,MAAM,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE,EAAE,CAAC,MAAA,CAAC;QAC3F,uBAAA,IAAI,iCAAqB,GAAG,MAAA,CAAC;IAC/B,CAAC;IACD,OAAO;QACL,GAAG,EAAE,uBAAA,IAAI,qCAAkB;QAC3B,GAAG,EAAE,uBAAA,IAAI,oCAAkB;KAC5B,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,KAAK;IACH,IAAI,CAAC,uBAAA,IAAI,iCAAc,EAAE,CAAC;QACxB,uBAAA,IAAI,6BAAiB,MAAM,IAAA,iCAAgB,GAAE,MAAA,CAAC;IAChD,CAAC;IACD,OAAO,uBAAA,IAAI,iCAAc,CAAC;AAC5B,CAAC;AAuDD;;;;;;;GAOG;AACH,KAAK,+BACH,IAAgB,EAChB,YAAwB,EACxB,MAAiB;IAEjB,yBAAyB;IACzB,MAAM,MAAM,GAAG,MAAM,uBAAA,IAAI,8BAAW,CAAC,mBAAmB,CAAC;QACvD,kBAAkB,EAAE,MAAM;QAC1B,IAAI,EAAE,YAAY;KACnB,CAAC,CAAC;IAEH,yCAAyC;IACzC,MAAM,WAAW,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC5C,OAAO;QACL,IAAI,EAAE,EAAE;QACR,iBAAiB,EAAE,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAC7D,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC;KACrD,CAAC;AACJ,CAAC;AAoBH;;;;;;GAMG;AACH,KAAK,UAAU,oBAAoB,CAAC,QAAoB;IACtD,6EAA6E;IAC7E,yEAAyE;IACzE,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,MAAM,CAAC,aAAa,CAAC,CAAC;IAC9C,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,MAAM,CAAC,QAAQ,CAAC,CAAC;IAEtD,MAAM,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACnC,MAAM,MAAM,GAAG,UAAU,CAAC,GAAG,CAAC,OAAO,CAAmB,CAAC;IAEzD,uCAAuC;IACvC,MAAM,MAAM,GAAG,IAAA,qBAAc,GAAE,GAAG,8BAA8B,GAAG,GAAG,GAAG,KAAK,CAAC;IAC/E,MAAM,QAAQ,GACZ,MAAM,GAAG,CAAC,8BAA8B,GAAG,2BAA2B,CAAC,GAAG,GAAG,GAAG,KAAK,CAAC;IACxF,IAAI,MAAM,CAAC,SAAS,GAAG,QAAQ,IAAI,MAAM,CAAC,SAAS,GAAG,MAAM,EAAE,CAAC;QAC7D,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;IAC5C,CAAC;IAED,wDAAwD;IACxD,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;QACvB,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;IACtE,CAAC;IAED,2DAA2D;IAC3D,IAAI,MAAM,GAAG,IAAI,sBAAe,CAAC,WAAW,CAAC,CAAC;IAC9C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;QAChD,MAAM,IAAI,GAAG,IAAI,sBAAe,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACrD,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,EAAE,CAAC,CAAC;QACxE,CAAC;QACD,MAAM,GAAG,IAAI,CAAC;IAChB,CAAC;IACD,MAAM,IAAI,GAAG,IAAI,sBAAe,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IACrD,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;IAClE,CAAC;IACD,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC;IAE9B,qDAAqD;IACrD,MAAM,GAAG,GAAG,IAAI,wBAAiB,EAAE,CAAC,cAAc,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IACrE,IAAI,GAAG,CAAC,SAAS,IAAI,aAAa,EAAE,CAAC;QACnC,2DAA2D;QAC3D,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;IAC1E,CAAC;IACD,MAAM,MAAM,GAAG,uBAAS,CAAC,KAAK,CAAC,GAAG,CAAC,UAAW,EAAE,uBAAY,CAAC,CAAC;IAC9D,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,MAAM,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;QAC1D,2CAA2C;QAC3C,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;IAC1E,CAAC;IAED,oEAAoE;IACpE,qCAAqC;IACrC,MAAM,GAAG,CAAC,MAAM,CAAC,MAAM,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;IAExC,OAAO,MAAM,CAAC,UAAU,CAAC;AAC3B,CAAC","sourcesContent":["import type {\n  CreateKeyImportKeyResponse,\n  ImportKeyRequest,\n  ImportKeyRequestMaterial,\n  Key,\n  KeyType,\n  Org,\n} from \"@cubist-labs/cubesigner-sdk\";\nimport { loadCrypto, loadSubtleCrypto } from \"@cubist-labs/cubesigner-sdk\";\nimport { CipherSuite, Aes256Gcm, HkdfSha384, DhkemP384HkdfSha384 } from \"@hpke/core\";\nimport { ECParameters } from \"@peculiar/asn1-ecc\";\nimport { AsnParser } from \"@peculiar/asn1-schema\";\nimport {\n  AlgorithmProvider,\n  X509Certificate,\n  cryptoProvider as x509CryptoProvider,\n} from \"@peculiar/x509\";\n\nimport type { MnemonicToImport } from \"./mnemonic\";\nimport { newMnemonicKeyPackage } from \"./mnemonic\";\nimport { toBigEndian, concatArrays, nowEpochMillis } from \"./util\";\n\n// domain-separation tag used when generating signing hash for import key\nconst IMPORT_KEY_SIGNING_DST = new TextEncoder().encode(\"CUBESIGNER_EPHEMERAL_IMPORT_P384\");\n\n// attestation document slack times\nconst MAX_ATTESTATION_AGE_MINUTES = 15n;\nconst MAX_ATTESTATION_FUTURE_MINUTES = 5n;\nconst WIK_REFRESH_EARLY_MILLIS = 60_000n;\n\n// OIDs for elliptic curve X509 certs\nconst EC_PUBLIC_KEY = \"1.2.840.10045.2.1\";\nconst NIST_P384 = \"1.3.132.0.34\";\n\n// Maximum number of keys to import in a single API call\nconst MAX_IMPORTS_PER_API_CALL = 32n;\n\n// AWS Nitro Enclaves root CA certificate\n// https://aws-nitro-enclaves.amazonaws.com/AWS_NitroEnclaves_Root-G1.zip\n//\n// See the documentation about AWS Nitro Enclaves verification:\n// https://docs.aws.amazon.com/enclaves/latest/user/verify-root.html\nconst AWS_CA_CERT =\n  \"MIICETCCAZagAwIBAgIRAPkxdWgbkK/hHUbMtOTn+FYwCgYIKoZIzj0EAwMwSTELMAkGA1UEBhMCVVMxDzANBgNVBAoMBkFtYXpvbjEMMAoGA1UECwwDQVdTMRswGQYDVQQDDBJhd3Mubml0cm8tZW5jbGF2ZXMwHhcNMTkxMDI4MTMyODA1WhcNNDkxMDI4MTQyODA1WjBJMQswCQYDVQQGEwJVUzEPMA0GA1UECgwGQW1hem9uMQwwCgYDVQQLDANBV1MxGzAZBgNVBAMMEmF3cy5uaXRyby1lbmNsYXZlczB2MBAGByqGSM49AgEGBSuBBAAiA2IABPwCVOumCMHzaHDimtqQvkY4MpJzbolL//Zy2YlES1BR5TSksfbb48C8WBoyt7F2Bw7eEtaaP+ohG2bnUs990d0JX28TcPQXCEPZ3BABIeTPYwEoCWZEh8l5YoQwTcU/9KNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkCW1DdkFR+eWw5b6cp3PmanfS5YwDgYDVR0PAQH/BAQDAgGGMAoGCCqGSM49BAMDA2kAMGYCMQCjfy+Rocm9Xue4YnwWmNJVA44fA0P5W2OpYow9OYCVRaEevL8uO1XYru5xtMPWrfMCMQCi85sWBbJwKKXdS6BptQFuZbT73o/gBh1qUxl/nNr12UO8Yfwr6wPLb+6NIwLz3/Y=\";\n\n/**\n * The result of deserializing a CreateKeyImportKeyResponse\n */\nclass WrappedImportKey {\n  readonly verifiedHash: Uint8Array;\n\n  readonly publicKey: Uint8Array;\n  readonly publicKeyBase64: string;\n\n  readonly skEnc: Uint8Array;\n  readonly skEncBase64: string;\n\n  readonly dkEnc: Uint8Array;\n  readonly dkEncBase64: string;\n\n  readonly expEpochSeconds: bigint;\n  readonly #enclaveAttestation: Uint8Array;\n  readonly #enclaveSignature: Uint8Array;\n\n  /**\n   * Constructor. This is only called from `WrappedImportKey.createAndVerify()`.\n   *\n   * @param { CreateKeyImportKeyResponse } resp The response from CubeSigner\n   */\n  private constructor(resp: CreateKeyImportKeyResponse) {\n    if (!resp.enclave_attestation || !resp.enclave_signature) {\n      throw new Error(\"No attestation found in CreateKeyImportKeyResponse\");\n    }\n\n    // parse the response\n    this.publicKey = new Uint8Array(Buffer.from(resp.public_key, \"base64\"));\n    this.publicKeyBase64 = resp.public_key;\n\n    this.skEnc = new Uint8Array(Buffer.from(resp.sk_enc, \"base64\"));\n    this.skEncBase64 = resp.sk_enc;\n\n    this.dkEnc = new Uint8Array(Buffer.from(resp.dk_enc, \"base64\"));\n    this.dkEncBase64 = resp.dk_enc;\n\n    this.#enclaveAttestation = new Uint8Array(Buffer.from(resp.enclave_attestation, \"base64\"));\n    this.#enclaveSignature = new Uint8Array(Buffer.from(resp.enclave_signature, \"base64\"));\n    this.expEpochSeconds = BigInt(resp.expires);\n\n    // this array is updated in createAndVerify once verification succeeds\n    this.verifiedHash = new Uint8Array(32);\n  }\n\n  /**\n   * Create and verify an instance of this type\n   *\n   * @param { CreateKeyImportKeyResponse } resp The response from CubeSigner\n   * @param { SubtleCrypto } subtle An instance of SubtleCrypto used for verification\n   * @return { Promise<WrappedImportKey> } A newly constructed instance\n   */\n  public static async createAndVerify(\n    resp: CreateKeyImportKeyResponse,\n    subtle: SubtleCrypto,\n  ): Promise<WrappedImportKey> {\n    const ret = new WrappedImportKey(resp);\n    const hash = await ret.#verifyImportKey(subtle);\n    ret.verifiedHash.set(hash);\n    return ret;\n  }\n\n  /**\n   * Verify this wrapped import key.\n   *\n   * @param { SubtleCrypto } subtle An instance of SubtleCrypto used for verification\n   * @return { Promise<Uint8Array> } The hash of the successfully verified wrapped import key\n   */\n  async #verifyImportKey(subtle: SubtleCrypto): Promise<Uint8Array> {\n    // check expiration date\n    if (nowEpochMillis() > this.expEpochSeconds * 1000n) {\n      throw new Error(\"Import key is expired\");\n    }\n\n    // make sure that there is an attestation\n    if (!this.#enclaveSignature || !this.#enclaveAttestation) {\n      throw new Error(\"No attestation found\");\n    }\n    const signing_key = await verifyAttestationKey(this.#enclaveAttestation);\n\n    // we use subtlecrypto's impl of RSA-PSS verification\n    const rsaPssKeyParams = {\n      name: \"RSA-PSS\",\n      hash: \"SHA-256\",\n    };\n    const pubkey = await subtle.importKey(\"spki\", signing_key, rsaPssKeyParams, true, [\"verify\"]);\n    const pubkeyAlg = pubkey.algorithm as unknown as { modulusLength: number };\n\n    // compute the signing hash and verify the signature\n    const message = this.#signedData();\n    const mlen = Number(BigInt(pubkeyAlg.modulusLength) / 8n);\n    const rsaPssParams = {\n      name: \"RSA-PSS\",\n      saltLength: mlen - 2 - 32,\n    };\n\n    if (await subtle.verify(rsaPssParams, pubkey, this.#enclaveSignature, message)) {\n      return new Uint8Array(await subtle.digest(\"SHA-256\", message));\n    }\n    throw new Error(\"Import key signature verification failed\");\n  }\n\n  /**\n   * Returns `true` if this WrappedImportKey needs to be refreshed.\n   *\n   * @return { boolean } True just if this key needs to be refreshed.\n   */\n  public needsRefresh(): boolean {\n    // force refresh if we're within WIK_REFRESH_EARLY_MILLIS of the expiration\n    return nowEpochMillis() + WIK_REFRESH_EARLY_MILLIS > this.expEpochSeconds * 1000n;\n  }\n\n  /**\n   * Computes the signing hash for a wrapped import key\n   *\n   * @return { Uint8Array } The signing hash\n   */\n  #signedData(): Uint8Array {\n    const parts: Uint8Array[] = [\n      // domain separation tag\n      toBigEndian(BigInt(IMPORT_KEY_SIGNING_DST.length), 2),\n      IMPORT_KEY_SIGNING_DST,\n\n      // public key\n      toBigEndian(BigInt(this.publicKey.length), 2),\n      this.publicKey,\n\n      // sk_enc\n      toBigEndian(BigInt(this.skEnc.length), 2),\n      this.skEnc,\n\n      // dk_enc\n      toBigEndian(BigInt(this.dkEnc.length), 2),\n      this.dkEnc,\n\n      // 8-byte big-endian expiration time in seconds since UNIX epoch\n      toBigEndian(this.expEpochSeconds, 8),\n    ];\n\n    return concatArrays(parts);\n  }\n}\n\n/**\n * The return value from KeyImporter.#getWrappedImportAndPubKey()\n */\ntype WrappedImportAndPubKey = {\n  wik: WrappedImportKey;\n  ipk: CryptoKey;\n};\n\n/**\n * An import encryption key and the corresponding attestation document\n */\nexport class KeyImporter {\n  #wrappedImportKey: null | WrappedImportKey = null;\n  #subtleCrypto: null | SubtleCrypto = null;\n  #publicKeyHandle: null | CryptoKey = null;\n  readonly #hpkeSuite: CipherSuite;\n  readonly #cs: Org;\n\n  /**\n   * Construct from a CubeSigner `Org` instance\n   *\n   * @param { Org } cs A CubeSigner `Org` instance\n   */\n  constructor(cs: Org) {\n    this.#cs = cs;\n    this.#hpkeSuite = new CipherSuite({\n      kem: new DhkemP384HkdfSha384(),\n      kdf: new HkdfSha384(),\n      aead: new Aes256Gcm(),\n    });\n  }\n\n  /**\n   * Check that the wrapped import key is unexpired and verified. Otherwise,\n   * request a new one, verify it, and update the verified signing hash.\n   *\n   * @return { Promise<[WrappedImportKey, CryptoKey]> } The verified signing hash.\n   */\n  async #getWrappedImportAndPubKey(): Promise<WrappedImportAndPubKey> {\n    if (!this.#wrappedImportKey) {\n      // first time we load a WrappedImportKey, make sure the x509 crypto\n      // provider is set correctly.\n      x509CryptoProvider.set(await loadCrypto());\n    }\n    if (!this.#wrappedImportKey || this.#wrappedImportKey.needsRefresh()) {\n      const kikResp = await this.#cs.createKeyImportKey();\n      const subtle = await this.#getSubtleCrypto();\n      const wik = await WrappedImportKey.createAndVerify(kikResp, subtle);\n\n      // import the public key from the WrappedImportKey\n      const p384Params = {\n        name: \"ECDH\",\n        namedCurve: \"P-384\",\n      };\n      this.#publicKeyHandle = await subtle.importKey(\"raw\", wik.publicKey, p384Params, true, []);\n      this.#wrappedImportKey = wik;\n    }\n    return {\n      wik: this.#wrappedImportKey,\n      ipk: this.#publicKeyHandle!,\n    };\n  }\n\n  /**\n   * Get or create an instance of SubtleCrypto.\n   *\n   * @return { SubtleCrypto } The instance of SubtleCrypto.\n   */\n  async #getSubtleCrypto(): Promise<SubtleCrypto> {\n    if (!this.#subtleCrypto) {\n      this.#subtleCrypto = await loadSubtleCrypto();\n    }\n    return this.#subtleCrypto;\n  }\n\n  /**\n   * Encrypts a set of mnemonics and imports them.\n   *\n   * @param { KeyType } keyType The type of key to import\n   * @param { MnemonicToImport[] } mnes The mnemonics to import, with optional derivation paths and passwords\n   * @return { Promise<Key[]> } `Key` objects for each imported key.\n   */\n  public async importMnemonics(keyType: KeyType, mnes: MnemonicToImport[]): Promise<Key[]> {\n    const nChunks = Number(\n      (BigInt(mnes.length) + MAX_IMPORTS_PER_API_CALL - 1n) / MAX_IMPORTS_PER_API_CALL,\n    );\n    const keys = [];\n\n    for (let i = 0; i < nChunks; ++i) {\n      // first, make sure that the wrapped import key is valid, i.e., that\n      // we have retrieved it and that it hasn't expired. We do this here\n      // for a couple reasons:\n      //\n      // - all encryptions in a give request must use the same import key, and\n      //\n      // - when importing a huge number of keys the import pubkey might expire\n      //   during the import, so we check for expiration before each request\n      const { wik, ipk } = await this.#getWrappedImportAndPubKey();\n\n      // next, encrypt this chunk of mnemonics\n      const start = Number(MAX_IMPORTS_PER_API_CALL) * i;\n      const end = Number(MAX_IMPORTS_PER_API_CALL) + start;\n      const mneSlice = mnes.slice(start, end);\n      const key_material = [];\n      for (const mne of mneSlice) {\n        const keyPkg = newMnemonicKeyPackage(mne);\n        const material = await this.#encrypt(keyPkg, wik.verifiedHash, ipk);\n        key_material.push(material);\n      }\n\n      // construct the request\n      const req: ImportKeyRequest = {\n        public_key: wik.publicKeyBase64,\n        sk_enc: wik.skEncBase64,\n        dk_enc: wik.dkEncBase64,\n        expires: Number(wik.expEpochSeconds),\n        key_type: keyType,\n        key_material,\n      };\n\n      // send it and append the result to the return value\n      const resp = await this.#cs.importKeys(req);\n      keys.push(...resp);\n    }\n\n    return keys;\n  }\n\n  /**\n   * Encrypt to this wrapped import key. Stores the result in `this.encrypted_keys`\n   *\n   * @param { Uint8Array } data The data to encrypt\n   * @param { Uint8Array } verifiedHash The verified signing hash of the wrapped import key to which to encrypt\n   * @param { CryptoKey } pubkey The public key to encrypt to\n   * @return { Promise<ImportKeyRequestMaterial> } The encrypted key material\n   */\n  async #encrypt(\n    data: Uint8Array,\n    verifiedHash: Uint8Array,\n    pubkey: CryptoKey,\n  ): Promise<ImportKeyRequestMaterial> {\n    // set up the HPKE sender\n    const sender = await this.#hpkeSuite.createSenderContext({\n      recipientPublicKey: pubkey,\n      info: verifiedHash,\n    });\n\n    // encrypt and construct the return value\n    const senderCtext = await sender.seal(data);\n    return {\n      salt: \"\",\n      client_public_key: Buffer.from(sender.enc).toString(\"base64\"),\n      ikm_enc: Buffer.from(senderCtext).toString(\"base64\"),\n    };\n  }\n}\n\n/*\n * An AWS Nitro attestation document\n *\n * https://github.com/aws/aws-nitro-enclaves-nsm-api/blob/4b851f3006c6fa98f23dcffb2cba03b39de9b8af/src/api/mod.rs#L208\n */\ntype AttestationDoc = {\n  module_id: string;\n  digest: \"SHA256\" | \"SHA384\" | \"SHA512\";\n  timestamp: bigint;\n  pcrs: Map<number, Uint8Array>;\n  certificate: Uint8Array;\n  cabundle: Uint8Array[];\n  public_key?: Uint8Array;\n  user_data?: Uint8Array;\n  nonce?: Uint8Array;\n};\n\n/**\n * Verifies the attestation key against the AWS Nitro Enclaves signing\n * key and returns the attested signing key.\n *\n * @param { Uint8Array } attBytes An attestation from an AWS nitro enclave\n * @return { Promise<Uint8Array> } The signing key that was attested, or null if verification failed\n */\nasync function verifyAttestationKey(attBytes: Uint8Array): Promise<Uint8Array> {\n  // cbor-x is being imported as ESM, so we must asynchronously import it here.\n  // Because we only use that and auth0/cose here, we import both this way.\n  const { Sign1 } = await import(\"@auth0/cose\");\n  const { decode: cborDecode } = await import(\"cbor-x\");\n\n  const att = Sign1.decode(attBytes);\n  const attDoc = cborDecode(att.payload) as AttestationDoc;\n\n  // check expiration date of attestation\n  const latest = nowEpochMillis() + MAX_ATTESTATION_FUTURE_MINUTES * 60n * 1000n;\n  const earliest =\n    latest - (MAX_ATTESTATION_FUTURE_MINUTES + MAX_ATTESTATION_AGE_MINUTES) * 60n * 1000n;\n  if (attDoc.timestamp < earliest || attDoc.timestamp > latest) {\n    throw new Error(\"Attestation is expired\");\n  }\n\n  // if there's no public key in this attestation, give up\n  if (!attDoc.public_key) {\n    throw new Error(\"Attestation did not include a signing public key\");\n  }\n\n  // Verify certificate chain starting with AWS Nitro CA cert\n  let parent = new X509Certificate(AWS_CA_CERT);\n  for (let i = 0; i < attDoc.cabundle.length; ++i) {\n    const cert = new X509Certificate(attDoc.cabundle[i]);\n    if (!(await cert.verify(parent))) {\n      throw new Error(`Attestation certificate chain failed at index ${i}`);\n    }\n    parent = cert;\n  }\n  const cert = new X509Certificate(attDoc.certificate);\n  if (!(await cert.verify(parent))) {\n    throw new Error(\"Attestation certificate chain failed at leaf\");\n  }\n  const pubkey = cert.publicKey;\n\n  // make sure that we got the expected public key type\n  const alg = new AlgorithmProvider().toAsnAlgorithm(pubkey.algorithm);\n  if (alg.algorithm != EC_PUBLIC_KEY) {\n    // not the expected algorithm, i.e., elliptic curve signing\n    throw new Error(\"Attestation contained unexpected signature algorithm\");\n  }\n  const params = AsnParser.parse(alg.parameters!, ECParameters);\n  if (!params.namedCurve || params.namedCurve !== NIST_P384) {\n    // not the expected params, i.e., NIST P384\n    throw new Error(\"Attestation contained unexpected signature algorithm\");\n  }\n\n  // verify the cose signature with the key, which we verified against\n  // the AWS Nitro CA certificate above\n  await att.verify(await pubkey.export());\n\n  return attDoc.public_key;\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { KeyImporter } from "./import";
+export { MnemonicToImport } from "./mnemonic";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACvC,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyImporter = void 0;
+var import_1 = require("./import");
+Object.defineProperty(exports, "KeyImporter", { enumerable: true, get: function () { return import_1.KeyImporter; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsbUNBQXVDO0FBQTlCLHFHQUFBLFdBQVcsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IEtleUltcG9ydGVyIH0gZnJvbSBcIi4vaW1wb3J0XCI7XG5leHBvcnQgeyBNbmVtb25pY1RvSW1wb3J0IH0gZnJvbSBcIi4vbW5lbW9uaWNcIjtcbiJdfQ==

package/dist/mnemonic.d.ts

@@ -0,0 +1,35 @@
+export type MnemonicKeyPackage = {
+    EnglishMnemonic: {
+        mnemonic: {
+            entropy: Uint8Array;
+        };
+        der_path: {
+            path: number[];
+        };
+        password: string;
+    };
+};
+/**
+ * A BIP39 mnemonic to be imported, plus optional BIP39 password
+ * and BIP32 derivation path.
+ */
+export type MnemonicToImport = {
+    mnemonic: string;
+    derivationPath?: string;
+    password?: string;
+};
+/**
+ * Create a new MnemonicKeyPackage value
+ *
+ * @param { MnemonicToImport } mne A BIP39 mnemonic and optional BIP39 password and BIP32 derivation path
+ * @return { Uint8Array } A serialized key package for import to CubeSigner
+ */
+export declare function newMnemonicKeyPackage(mne: MnemonicToImport): Uint8Array;
+/**
+ * Parse a derivation path into a sequence of 32-bit integers
+ *
+ * @param { string } derp The derivation path to parse; must start with 'm/'
+ * @return { number[] } The parsed path
+ */
+export declare function parseDerivationPath(derp: string): number[];
+//# sourceMappingURL=mnemonic.d.ts.map

package/dist/mnemonic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mnemonic.d.ts","sourceRoot":"","sources":["../src/mnemonic.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,eAAe,EAAE;QACf,QAAQ,EAAE;YACR,OAAO,EAAE,UAAU,CAAC;SACrB,CAAC;QACF,QAAQ,EAAE;YACR,IAAI,EAAE,MAAM,EAAE,CAAC;SAChB,CAAC;QACF,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,gBAAgB,GAAG,UAAU,CAgBvE;AAMD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CA6B1D"}