@sudoplatform/sudo-common 7.1.3 → 8.0.2

package/cjs/sudoKeyArchive/keyArchive.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUnrecognizedKeyArchive = exports.isInsecureKeyArchive = exports.isSecureKeyArchive = exports.KeyArchiveCodec = exports.SecureKeyArchiveCodec = exports.UnrecognizedKeyArchiveCodec = exports.SecureKeyArchiveType = exports.InsecureKeyArchiveCodec = exports.InsecureKeyArchiveType = exports.CURRENT_ARCHIVE_VERSION = void 0;
+const tslib_1 = require("tslib");
+const t = tslib_1.__importStar(require("io-ts"));
+const keyInfo_1 = require("./keyInfo");
+exports.CURRENT_ARCHIVE_VERSION = 3;
+const CommonKeyArchiveRequiredProps = {
+    /**
+     * Version this archive format.
+     */
+    Version: t.literal(exports.CURRENT_ARCHIVE_VERSION),
+    /**
+     * Metainfo user is able to associate with the archive.
+     */
+    MetaInfo: t.record(t.string, t.string),
+};
+exports.InsecureKeyArchiveType = 'Insecure';
+const InsecureKeyArchiveRequiredProps = {
+    ...CommonKeyArchiveRequiredProps,
+    /**
+     * Discriminant for InsecureKeyArchive type.
+     */
+    Type: t.literal(exports.InsecureKeyArchiveType),
+    /**
+     * Array of exported keys in clear text.
+     */
+    Keys: t.array(keyInfo_1.KeyArchiveKeyInfoCodec),
+};
+exports.InsecureKeyArchiveCodec = t.type(InsecureKeyArchiveRequiredProps, 'InsecureKeyArchive');
+exports.SecureKeyArchiveType = 'Secure';
+const SecureKeyArchiveRequiredProps = {
+    ...CommonKeyArchiveRequiredProps,
+    /**
+     * Discriminant for SecureKeyArchive type.
+     */
+    Type: t.literal(exports.SecureKeyArchiveType),
+    /**
+     * Format is:
+     *
+     * base64(gzip(encrypt(stringify(array of KeyArchiveKeyInfo)))
+     *
+     * Encrypt is 256-bit AES-CBC using symmetric key derived from
+     * password and IV specified by IV property.
+     */
+    Keys: t.string,
+    /**
+     * Rounds of PBKDF2 applied to password to derive symmetric key.
+     */
+    Rounds: t.number,
+    /**
+     * Salt passed to PBKDF2 to derive symmetric key.
+     */
+    Salt: t.string,
+    /**
+     * IV used for AES encryption of keys.
+     */
+    IV: t.string,
+};
+const UnrecognizedKeyArchiveProps = {
+    Version: t.number,
+    Type: t.string,
+};
+exports.UnrecognizedKeyArchiveCodec = t.partial(UnrecognizedKeyArchiveProps);
+exports.SecureKeyArchiveCodec = t.type(SecureKeyArchiveRequiredProps, 'SecureKeyArchive');
+exports.KeyArchiveCodec = t.union([
+    exports.SecureKeyArchiveCodec,
+    exports.InsecureKeyArchiveCodec,
+    // Leave UnrecognizedKeyArchiveCodec last so it's tried last
+    exports.UnrecognizedKeyArchiveCodec,
+], 'KeyArchive');
+function isSecureKeyArchive(keyArchive) {
+    return keyArchive.Type === exports.SecureKeyArchiveType;
+}
+exports.isSecureKeyArchive = isSecureKeyArchive;
+function isInsecureKeyArchive(keyArchive) {
+    return keyArchive.Type === exports.InsecureKeyArchiveType;
+}
+exports.isInsecureKeyArchive = isInsecureKeyArchive;
+function isUnrecognizedKeyArchive(keyArchive) {
+    return !isSecureKeyArchive(keyArchive) && !isInsecureKeyArchive(keyArchive);
+}
+exports.isUnrecognizedKeyArchive = isUnrecognizedKeyArchive;
+//# sourceMappingURL=keyArchive.js.map

package/cjs/sudoKeyArchive/keyArchive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyArchive.js","sourceRoot":"","sources":["../../src/sudoKeyArchive/keyArchive.ts"],"names":[],"mappings":";;;;AAAA,iDAA0B;AAC1B,uCAAkD;AAErC,QAAA,uBAAuB,GAAG,CAAC,CAAA;AAExC,MAAM,6BAA6B,GAAG;IACpC;;OAEG;IACH,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,+BAAuB,CAAC;IAE3C;;OAEG;IACH,QAAQ,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC;CACvC,CAAA;AAEY,QAAA,sBAAsB,GAAG,UAAU,CAAA;AAEhD,MAAM,+BAA+B,GAAG;IACtC,GAAG,6BAA6B;IAChC;;OAEG;IACH,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,8BAAsB,CAAC;IAEvC;;OAEG;IACH,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,gCAAsB,CAAC;CACtC,CAAA;AAEY,QAAA,uBAAuB,GAAG,CAAC,CAAC,IAAI,CAC3C,+BAA+B,EAC/B,oBAAoB,CACrB,CAAA;AAIY,QAAA,oBAAoB,GAAG,QAAQ,CAAA;AAE5C,MAAM,6BAA6B,GAAG;IACpC,GAAG,6BAA6B;IAChC;;OAEG;IACH,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,4BAAoB,CAAC;IAErC;;;;;;;OAOG;IACH,IAAI,EAAE,CAAC,CAAC,MAAM;IAEd;;OAEG;IACH,MAAM,EAAE,CAAC,CAAC,MAAM;IAEhB;;OAEG;IACH,IAAI,EAAE,CAAC,CAAC,MAAM;IAEd;;OAEG;IACH,EAAE,EAAE,CAAC,CAAC,MAAM;CACb,CAAA;AAED,MAAM,2BAA2B,GAAG;IAClC,OAAO,EAAE,CAAC,CAAC,MAAM;IACjB,IAAI,EAAE,CAAC,CAAC,MAAM;CACf,CAAA;AAEY,QAAA,2BAA2B,GAAG,CAAC,CAAC,OAAO,CAClD,2BAA2B,CAC5B,CAAA;AAKY,QAAA,qBAAqB,GAAG,CAAC,CAAC,IAAI,CACzC,6BAA6B,EAC7B,kBAAkB,CACnB,CAAA;AAGY,QAAA,eAAe,GAAG,CAAC,CAAC,KAAK,CACpC;IACE,6BAAqB;IACrB,+BAAuB;IAEvB,4DAA4D;IAC5D,mCAA2B;CAC5B,EACD,YAAY,CACb,CAAA;AAID,SAAgB,kBAAkB,CAChC,UAAsB;IAEtB,OAAO,UAAU,CAAC,IAAI,KAAK,4BAAoB,CAAA;AACjD,CAAC;AAJD,gDAIC;AAED,SAAgB,oBAAoB,CAClC,UAAsB;IAEtB,OAAO,UAAU,CAAC,IAAI,KAAK,8BAAsB,CAAA;AACnD,CAAC;AAJD,oDAIC;AAED,SAAgB,wBAAwB,CACtC,UAAsB;IAEtB,OAAO,CAAC,kBAAkB,CAAC,UAAU,CAAC,IAAI,CAAC,oBAAoB,CAAC,UAAU,CAAC,CAAA;AAC7E,CAAC;AAJD,4DAIC"}

package/cjs/sudoKeyArchive/keyInfo.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyArchiveKeyInfoArrayCodec = exports.KeyArchiveKeyInfoCodec = void 0;
+const tslib_1 = require("tslib");
+const t = tslib_1.__importStar(require("io-ts"));
+const keyType_1 = require("./keyType");
+const KeyArchiveKeyInfoRequiredProps = {
+    Name: t.string,
+    Type: keyType_1.KeyArchiveKeyTypeCodec,
+    Data: t.string,
+    Synchronizable: t.boolean,
+    Exportable: t.boolean,
+    NameSpace: t.string,
+};
+exports.KeyArchiveKeyInfoCodec = t.type(KeyArchiveKeyInfoRequiredProps, 'KeyArchiveKeyInfo');
+exports.KeyArchiveKeyInfoArrayCodec = t.array(exports.KeyArchiveKeyInfoCodec, 'KeyArchiveKeyInfoArray');
+//# sourceMappingURL=keyInfo.js.map

package/cjs/sudoKeyArchive/keyInfo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyInfo.js","sourceRoot":"","sources":["../../src/sudoKeyArchive/keyInfo.ts"],"names":[],"mappings":";;;;AAAA,iDAA0B;AAE1B,uCAAkD;AAElD,MAAM,8BAA8B,GAAG;IACrC,IAAI,EAAE,CAAC,CAAC,MAAM;IACd,IAAI,EAAE,gCAAsB;IAC5B,IAAI,EAAE,CAAC,CAAC,MAAM;IACd,cAAc,EAAE,CAAC,CAAC,OAAO;IACzB,UAAU,EAAE,CAAC,CAAC,OAAO;IACrB,SAAS,EAAE,CAAC,CAAC,MAAM;CACpB,CAAA;AAEY,QAAA,sBAAsB,GAAG,CAAC,CAAC,IAAI,CAC1C,8BAA8B,EAC9B,mBAAmB,CACpB,CAAA;AAEY,QAAA,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAChD,8BAAsB,EACtB,wBAAwB,CACzB,CAAA"}

package/cjs/sudoKeyArchive/keyType.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyArchiveKeyTypeCodec = exports.KeyArchiveKeyType = void 0;
+const tslib_1 = require("tslib");
+const t = tslib_1.__importStar(require("io-ts"));
+/**
+ * Key types supported in key archives
+ *
+ * These form part of the interoperable secure key archive format.
+ */
+var KeyArchiveKeyType;
+(function (KeyArchiveKeyType) {
+    // Byte array of secret data - to be stored and retrievable using *Password
+    // methods on key managers
+    KeyArchiveKeyType["Password"] = "password";
+    // PKCS8 PrivateKey encoded RSA private key
+    KeyArchiveKeyType["PrivateKey"] = "privateKey";
+    // SPKI encoded RSA public key
+    KeyArchiveKeyType["PublicKey"] = "publicKey";
+    // Byte array of AES symmetric key
+    KeyArchiveKeyType["SymmetricKey"] = "symmetricKey";
+})(KeyArchiveKeyType = exports.KeyArchiveKeyType || (exports.KeyArchiveKeyType = {}));
+// Android is tolerating the following case insensitive alias key type
+// names so we will do the same
+const keyArchiveKeyTypeAlternatives = {
+    password: KeyArchiveKeyType.Password,
+    privatekey: KeyArchiveKeyType.PrivateKey,
+    private_key: KeyArchiveKeyType.PrivateKey,
+    publickey: KeyArchiveKeyType.PublicKey,
+    public_key: KeyArchiveKeyType.PublicKey,
+    symmetrickey: KeyArchiveKeyType.SymmetricKey,
+    symmetric_key: KeyArchiveKeyType.SymmetricKey,
+};
+const failureMessage = `Key type is not one of: ${Object.keys(keyArchiveKeyTypeAlternatives).join(',')}`; // eslint-disable-line tree-shaking/no-side-effects-in-initialization
+const isKeyArchiveKeyType = (u) => t.string.is(u) && keyArchiveKeyTypeAlternatives[u.toLowerCase()] !== undefined;
+exports.KeyArchiveKeyTypeCodec = new t.Type('KeyArchiveKeyType', isKeyArchiveKeyType, (u, c) => isKeyArchiveKeyType(u)
+    ? t.success(keyArchiveKeyTypeAlternatives[u.toLowerCase()])
+    : t.failure(u, c, failureMessage), t.identity);
+//# sourceMappingURL=keyType.js.map

package/cjs/sudoKeyArchive/keyType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyType.js","sourceRoot":"","sources":["../../src/sudoKeyArchive/keyType.ts"],"names":[],"mappings":";;;;AAAA,iDAA0B;AAE1B;;;;GAIG;AACH,IAAY,iBAaX;AAbD,WAAY,iBAAiB;IAC3B,2EAA2E;IAC3E,0BAA0B;IAC1B,0CAAqB,CAAA;IAErB,2CAA2C;IAC3C,8CAAyB,CAAA;IAEzB,8BAA8B;IAC9B,4CAAuB,CAAA;IAEvB,kCAAkC;IAClC,kDAA6B,CAAA;AAC/B,CAAC,EAbW,iBAAiB,GAAjB,yBAAiB,KAAjB,yBAAiB,QAa5B;AAED,sEAAsE;AACtE,+BAA+B;AAC/B,MAAM,6BAA6B,GAAsC;IACvE,QAAQ,EAAE,iBAAiB,CAAC,QAAQ;IACpC,UAAU,EAAE,iBAAiB,CAAC,UAAU;IACxC,WAAW,EAAE,iBAAiB,CAAC,UAAU;IACzC,SAAS,EAAE,iBAAiB,CAAC,SAAS;IACtC,UAAU,EAAE,iBAAiB,CAAC,SAAS;IACvC,YAAY,EAAE,iBAAiB,CAAC,YAAY;IAC5C,aAAa,EAAE,iBAAiB,CAAC,YAAY;CAC9C,CAAA;AAED,MAAM,cAAc,GAAG,2BAA2B,MAAM,CAAC,IAAI,CAC3D,6BAA6B,CAC9B,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAA,CAAC,qEAAqE;AAEnF,MAAM,mBAAmB,GAAG,CAAC,CAAU,EAA0B,EAAE,CACjE,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,6BAA6B,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,KAAK,SAAS,CAAA;AAEnE,QAAA,sBAAsB,GAAG,IAAI,CAAC,CAAC,IAAI,CAC9C,mBAAmB,EACnB,mBAAmB,EACnB,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CACP,mBAAmB,CAAC,CAAC,CAAC;IACpB,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,6BAA6B,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;IAC3D,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,cAAc,CAAC,EACrC,CAAC,CAAC,QAAQ,CACX,CAAA"}

package/cjs/sudoKeyArchive/sudoKeyArchive.js

@@ -0,0 +1,373 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyArchiveKeyTypeFromKeyDataKeyType = exports.keyArchiveInfoFromKeyData = exports.DefaultSudoKeyArchive = void 0;
+const fflate_1 = require("fflate");
+const Either_1 = require("fp-ts/lib/Either");
+const error_1 = require("../errors/error");
+const sudoKeyManager_1 = require("../sudoKeyManager");
+const sudoCryptoProvider_1 = require("../sudoKeyManager/sudoCryptoProvider");
+const base64_1 = require("../utils/base64");
+const buffer_1 = require("../utils/buffer");
+const keyArchive_1 = require("./keyArchive");
+const keyInfo_1 = require("./keyInfo");
+const keyType_1 = require("./keyType");
+class DefaultSudoKeyArchive {
+    /**
+     * Construct SudoKeyArchive
+     *
+     *
+     * @param keyManagers
+     *     Key manager or array of key managers to either restore archive in to
+     *     or construct archive from
+     *
+     * @param archiveData
+     *     Array buffer of binary archive data to restore.
+     *
+     * @param excludedKeys
+     *     Set of key names to exclude from archive or restore operation.
+     *     Default: None
+     *
+     * @param excludedKeyTypes
+     *     Set of key types to exclude from archive or restore operation.
+     *     Default: {@link KeyArchiveKeyType.PublicKey}
+     *
+     * @param metaInfo
+     *     Meta information to include with the key archive
+     *
+     * @throws {@link IllegalArgumentError}
+     *     If no key managers are provided
+     *
+     * @throws {@link IllegalArgumentError}
+     *     If multiple key managers are provided with the same namespace
+     *
+     * @throws {@link KeyArchiveDecodingError}
+     *     If archiveData is provided and its binary data cannot be decoded
+     *
+     * @throws {@link KeyArchiveTypeError}
+     *     If archiveData is provided and decodes to an unsupported archive
+     *     type.
+     *
+     * @throws {@link KeyArchiveVersionError}
+     *     If archiveData is provided and decodes to an unsupported archive
+     *     version.
+     */
+    constructor(keyManagers, options) {
+        this.keyManagers = {};
+        this.excludedKeys = new Set();
+        this.excludedKeyTypes = new Set();
+        this.metaInfo = new Map();
+        this.keys = new Map();
+        if (Array.isArray(keyManagers)) {
+            if (keyManagers.length === 0) {
+                throw new error_1.IllegalArgumentError('Must provide at least one key manager');
+            }
+            keyManagers.forEach((keyManager) => {
+                if (this.keyManagers[keyManager.namespace]) {
+                    throw new error_1.IllegalArgumentError(`Multiple key managers provided with namespace ${keyManager.namespace}`);
+                }
+                this.keyManagers[keyManager.namespace] = keyManager;
+            });
+            this.defaultKeyManager = keyManagers[0];
+        }
+        else {
+            this.keyManagers[keyManagers.namespace] = keyManagers;
+            this.defaultKeyManager = keyManagers;
+        }
+        if (options?.archiveData) {
+            this.keyArchive = this.loadArchive(options.archiveData);
+        }
+        // We take copies of the input parameters so we own the data
+        if (options?.excludedKeys) {
+            options?.excludedKeys.forEach((excludedKey) => this.excludedKeys.add(excludedKey));
+        }
+        if (options?.excludedKeyTypes) {
+            options?.excludedKeyTypes.forEach((excludedKeyType) => this.excludedKeyTypes.add(excludedKeyType));
+        }
+        if (options?.metaInfo?.size) {
+            for (const [key, value] of options?.metaInfo?.entries()) {
+                this.metaInfo.set(key, value);
+            }
+        }
+    }
+    /**
+     * Reads the binary data and converts it to JSON and then deserialises it
+     * into a KeyArchive
+     */
+    loadArchive(archiveData) {
+        let unzipped;
+        try {
+            unzipped = (0, fflate_1.gunzipSync)(new Uint8Array(archiveData));
+        }
+        catch (err) {
+            throw new error_1.KeyArchiveDecodingError();
+        }
+        let keyArchive;
+        try {
+            const decoded = keyArchive_1.KeyArchiveCodec.decode(JSON.parse(buffer_1.Buffer.toString(unzipped)));
+            if ((0, Either_1.isLeft)(decoded)) {
+                throw new error_1.KeyArchiveDecodingError();
+            }
+            keyArchive = decoded.right;
+        }
+        catch (err) {
+            throw new error_1.KeyArchiveDecodingError();
+        }
+        if ((0, keyArchive_1.isUnrecognizedKeyArchive)(keyArchive)) {
+            if (keyArchive.Type &&
+                keyArchive.Type !== keyArchive_1.SecureKeyArchiveType &&
+                keyArchive.Type !== keyArchive_1.InsecureKeyArchiveType) {
+                throw new error_1.KeyArchiveTypeError(keyArchive.Type);
+            }
+            // Only support DefaultSudoKeyArchive.CURRENT_ARCHIVE_VERSION for now.
+            if (keyArchive.Version !== undefined &&
+                keyArchive.Version !== DefaultSudoKeyArchive.CURRENT_ARCHIVE_VERSION) {
+                throw new error_1.KeyArchiveVersionError(keyArchive.Version);
+            }
+            throw new error_1.KeyArchiveDecodingError();
+        }
+        return keyArchive;
+    }
+    async loadKeys() {
+        for (const keyManager of Object.values(this.keyManagers)) {
+            await keyManager.exportKeys().then((exported) => {
+                exported.forEach((data) => {
+                    const keyArchiveInfoDecoded = keyArchiveInfoFromKeyData(data);
+                    if (!this.excludedKeyTypes.has(keyArchiveInfoDecoded.Type) &&
+                        !this.excludedKeys.has(data.name)) {
+                        this.keys.set(`${keyArchiveInfoDecoded.NameSpace}:${keyArchiveInfoDecoded.Type}:${keyArchiveInfoDecoded.Name}`, keyArchiveInfoDecoded);
+                    }
+                });
+            });
+        }
+    }
+    async saveKeys() {
+        for (const info of this.keys.values()) {
+            const keyManager = this.keyManagers[info.NameSpace];
+            if (!keyManager)
+                continue;
+            if (this.excludedKeyTypes.has(info.Type))
+                continue;
+            if (this.excludedKeys.has(info.Name))
+                continue;
+            const keyData = info.Decoded;
+            switch (info.Type) {
+                case keyType_1.KeyArchiveKeyType.Password:
+                    await keyManager.addPassword(keyData, info.Name);
+                    break;
+                case keyType_1.KeyArchiveKeyType.PrivateKey:
+                    await keyManager.addPrivateKey(keyData, info.Name);
+                    break;
+                case keyType_1.KeyArchiveKeyType.PublicKey:
+                    await keyManager.addPublicKey(keyData, info.Name);
+                    break;
+                case keyType_1.KeyArchiveKeyType.SymmetricKey:
+                    await keyManager.addSymmetricKey(keyData, info.Name);
+                    break;
+                default:
+                    throw new error_1.KeyArchiveUnknownKeyTypeError(`Key archive key type ${info.Type} is not recognized`);
+            }
+        }
+    }
+    async archive(password) {
+        const keys = [];
+        for (const key of this.keys.values()) {
+            keys.push({
+                NameSpace: key.NameSpace,
+                Name: key.Name,
+                Data: key.Data,
+                Type: key.Type,
+                Synchronizable: key.Synchronizable,
+                Exportable: key.Exportable,
+            });
+        }
+        let keyArchive;
+        if (!password) {
+            const insecureKeyArchive = {
+                Type: 'Insecure',
+                MetaInfo: {},
+                Version: DefaultSudoKeyArchive.CURRENT_ARCHIVE_VERSION,
+                Keys: keys,
+            };
+            keyArchive = insecureKeyArchive;
+        }
+        else {
+            const salt = await this.defaultKeyManager.generateRandomData(sudoCryptoProvider_1.SudoCryptoProviderDefaults.pbkdfSaltSize);
+            const b64Salt = base64_1.Base64.encode(salt);
+            const key = await this.defaultKeyManager.generateSymmetricKeyFromPassword(password, salt, {
+                rounds: sudoCryptoProvider_1.SudoCryptoProviderDefaults.pbkdfRounds,
+            });
+            const serializedKeys = JSON.stringify(keys);
+            const compressedSerializedKeys = (0, fflate_1.gzipSync)(buffer_1.Buffer.fromString(serializedKeys), {
+                level: 9,
+            });
+            // Don't strictly need a randomly generated IV here but no harm either
+            const iv = await this.defaultKeyManager.generateRandomData(sudoCryptoProvider_1.SudoCryptoProviderDefaults.aesIVSize);
+            const encryptedKeys = await this.defaultKeyManager.encryptWithSymmetricKey(key, compressedSerializedKeys, { iv });
+            const secureKeyArchive = {
+                Type: 'Secure',
+                Version: DefaultSudoKeyArchive.CURRENT_ARCHIVE_VERSION,
+                MetaInfo: {},
+                Salt: b64Salt,
+                Rounds: sudoCryptoProvider_1.SudoCryptoProviderDefaults.pbkdfRounds,
+                Keys: base64_1.Base64.encode(encryptedKeys),
+                IV: base64_1.Base64.encode(iv),
+            };
+            keyArchive = secureKeyArchive;
+        }
+        for (const [key, value] of this.metaInfo.entries()) {
+            keyArchive.MetaInfo[key] = value;
+        }
+        const archiveString = JSON.stringify(keyArchive);
+        // While this double Gzips the SecureKeyArchive, it allows us to roughly
+        // recover the space consumed by Base64 encoding the cipher text. Otherwise
+        // we would end up having a fully binary data structure for the archive.
+        // If the time to compute becomes prohibitive we can look at a binary, non-JSON
+        // base format for the archive.
+        const archiveGzipped = (0, fflate_1.gzipSync)(buffer_1.Buffer.fromString(archiveString), {
+            level: 9,
+        });
+        return Promise.resolve(archiveGzipped);
+    }
+    async unarchive(password) {
+        if (!this.keyArchive) {
+            throw new error_1.KeyArchiveMissingError();
+        }
+        let keys;
+        if ((0, keyArchive_1.isSecureKeyArchive)(this.keyArchive)) {
+            if (!password) {
+                throw new error_1.KeyArchivePasswordRequiredError();
+            }
+            let iv;
+            let encryptedKeys;
+            let key;
+            try {
+                const salt = base64_1.Base64.decode(this.keyArchive.Salt);
+                iv = base64_1.Base64.decode(this.keyArchive.IV);
+                encryptedKeys = base64_1.Base64.decode(this.keyArchive.Keys);
+                key = await this.defaultKeyManager.generateSymmetricKeyFromPassword(password, salt, { rounds: this.keyArchive.Rounds });
+            }
+            catch (err) {
+                throw new error_1.KeyArchiveDecodingError();
+            }
+            let compressedSerializedKeys;
+            try {
+                compressedSerializedKeys =
+                    await this.defaultKeyManager.decryptWithSymmetricKey(key, encryptedKeys, { iv });
+            }
+            catch (err) {
+                throw new error_1.KeyArchiveIncorrectPasswordError();
+            }
+            try {
+                const serializedKeys = (0, fflate_1.gunzipSync)(new Uint8Array(compressedSerializedKeys));
+                const decoded = keyInfo_1.KeyArchiveKeyInfoArrayCodec.decode(JSON.parse(buffer_1.Buffer.toString(serializedKeys)));
+                if ((0, Either_1.isLeft)(decoded)) {
+                    throw new error_1.KeyArchiveDecodingError();
+                }
+                keys = decoded.right;
+            }
+            catch (err) {
+                throw new error_1.KeyArchiveDecodingError();
+            }
+        }
+        else {
+            if (password) {
+                throw new error_1.KeyArchiveNoPasswordRequiredError();
+            }
+            keys = this.keyArchive.Keys;
+        }
+        keys.forEach((key) => {
+            const keyKey = `${key.NameSpace}:${key.Type}:${key.Name}`;
+            let decoded;
+            try {
+                decoded = base64_1.Base64.decode(key.Data);
+            }
+            catch (err) {
+                throw new error_1.KeyArchiveDecodingError(`Unable to decode key ${keyKey}`);
+            }
+            this.keys.set(keyKey, { ...key, Decoded: decoded });
+        });
+    }
+    reset() {
+        this.keys.clear();
+    }
+    containsKey(namespace, name, type) {
+        return this.keys.has(`${namespace}:${type}:${name}`);
+    }
+    getKeyData(namespace, name, type) {
+        const keyInfo = this.keys.get(`${namespace}:${type}:${name}`);
+        if (!keyInfo) {
+            throw new error_1.KeyNotFoundError();
+        }
+        return keyInfo.Decoded;
+    }
+    getExcludedKeys() {
+        return this.excludedKeys;
+    }
+    getExcludedKeyTypes() {
+        return this.excludedKeyTypes;
+    }
+    getMetaInfo() {
+        return this.metaInfo;
+    }
+}
+exports.DefaultSudoKeyArchive = DefaultSudoKeyArchive;
+/**
+ * Version 2 format is not gzipped is what's currently generated
+ * by iOS and Android. We may want to add support for importing
+ * such archives.
+ */
+DefaultSudoKeyArchive.PREGZIP_ARCHIVE_VERSION = 2;
+/**
+ * Version 3 format permits both secure and insecure key archives.
+ *
+ * Insecure key archives are used where the archive will be stored
+ * in an otherwise known secure way e.g. via secure-vault-service
+ * where the encryption of the archive would then be handled by
+ * clients of that service.
+ *
+ * Secure key archives are password protected (via PBKDF2) a la version
+ * 2 format.
+ *
+ * Insecure format detail is:
+ *
+ *     gzip(JSON.stringify(InsecureKeyArchive))
+ *
+ * Secure format detail is:
+ *
+ *     gzip(JSON.stringify(SecureKeyArchive))
+ *
+ * where Keys property of SecureKeyArchive is:
+ *
+ *     base64(encrypt(gzip(JSON.stringify(array of keys))))
+ *
+ * Where encrypt operation is 256-bit AES CBC-mode with IV SecureKeyArchive.IV
+ * and key generated by SecureKeyArchive.Rounds of PBKDF2 on the password
+ * salted with SecureKeyArchive.Salt.
+ */
+DefaultSudoKeyArchive.CURRENT_ARCHIVE_VERSION = keyArchive_1.CURRENT_ARCHIVE_VERSION;
+function keyArchiveInfoFromKeyData(keyData) {
+    return {
+        NameSpace: keyData.namespace,
+        Name: keyData.name,
+        Type: keyArchiveKeyTypeFromKeyDataKeyType(keyData.type),
+        Data: base64_1.Base64.encode(keyData.data),
+        Decoded: keyData.data,
+        Synchronizable: false,
+        Exportable: true,
+    };
+}
+exports.keyArchiveInfoFromKeyData = keyArchiveInfoFromKeyData;
+function keyArchiveKeyTypeFromKeyDataKeyType(keyDataKeyType) {
+    switch (keyDataKeyType) {
+        case sudoKeyManager_1.KeyDataKeyType.Password:
+            return keyType_1.KeyArchiveKeyType.Password;
+        case sudoKeyManager_1.KeyDataKeyType.RSAPrivateKey:
+            return keyType_1.KeyArchiveKeyType.PrivateKey;
+        case sudoKeyManager_1.KeyDataKeyType.RSAPublicKey:
+            return keyType_1.KeyArchiveKeyType.PublicKey;
+        case sudoKeyManager_1.KeyDataKeyType.SymmetricKey:
+            return keyType_1.KeyArchiveKeyType.SymmetricKey;
+    }
+}
+exports.keyArchiveKeyTypeFromKeyDataKeyType = keyArchiveKeyTypeFromKeyDataKeyType;
+//# sourceMappingURL=sudoKeyArchive.js.map

package/cjs/sudoKeyArchive/sudoKeyArchive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sudoKeyArchive.js","sourceRoot":"","sources":["../../src/sudoKeyArchive/sudoKeyArchive.ts"],"names":[],"mappings":"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"}

package/cjs/sudoKeyManager/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./keyData"), exports);
+tslib_1.__exportStar(require("./publicKey"), exports);
+tslib_1.__exportStar(require("./sudoCryptoProvider"), exports);
+tslib_1.__exportStar(require("./sudoKeyManager"), exports);
+//# sourceMappingURL=index.js.map

package/cjs/sudoKeyManager/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/sudoKeyManager/index.ts"],"names":[],"mappings":";;;AAAA,oDAAyB;AACzB,sDAA2B;AAC3B,+DAAoC;AACpC,2DAAgC"}

package/cjs/sudoKeyManager/keyData.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyDataKeyFormat = exports.KeyDataKeyType = void 0;
+/**
+ * Type of key
+ */
+var KeyDataKeyType;
+(function (KeyDataKeyType) {
+    KeyDataKeyType["SymmetricKey"] = "SymmetricKey";
+    KeyDataKeyType["RSAPublicKey"] = "RSAPublicKey";
+    KeyDataKeyType["RSAPrivateKey"] = "RSAPrivateKey";
+    KeyDataKeyType["Password"] = "Password";
+})(KeyDataKeyType = exports.KeyDataKeyType || (exports.KeyDataKeyType = {}));
+var KeyDataKeyFormat;
+(function (KeyDataKeyFormat) {
+    /**
+     * Raw key format.
+     *
+     * For SymmetricKey and Password types this means the raw bytes
+     * of the key/password.
+     *
+     * For RSAPublicKey this means RSAPublicKey binary format.
+     * For RSAPrivateKey this means RSAPrivateKey binary format.
+     * "RSA PUBLIC KEY" or "RSA PRIVATE KEY" in PEM speak
+     */
+    KeyDataKeyFormat["Raw"] = "Raw";
+    /**
+     * SPKI public key format.
+     *
+     * Applies to public keys (currently only RSAPublicKey)
+     * and means they are formated using SPKI.
+     *
+     * "PUBLIC KEY" in PEM speak
+     */
+    KeyDataKeyFormat["SPKI"] = "SPKI";
+    /**
+     * PKCS8 private key format.
+     *
+     * Applies to private keys (currently only RSAPrivateKey)
+     * and means they are formated using unencrypted PKCS8.
+     *
+     * "PRIVATE KEY" in PEM speak
+     */
+    KeyDataKeyFormat["PKCS8"] = "PKCS8";
+})(KeyDataKeyFormat = exports.KeyDataKeyFormat || (exports.KeyDataKeyFormat = {}));
+//# sourceMappingURL=keyData.js.map

package/cjs/sudoKeyManager/keyData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyData.js","sourceRoot":"","sources":["../../src/sudoKeyManager/keyData.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACH,IAAY,cAKX;AALD,WAAY,cAAc;IACxB,+CAA6B,CAAA;IAC7B,+CAA6B,CAAA;IAC7B,iDAA+B,CAAA;IAC/B,uCAAqB,CAAA;AACvB,CAAC,EALW,cAAc,GAAd,sBAAc,KAAd,sBAAc,QAKzB;AAED,IAAY,gBAgCX;AAhCD,WAAY,gBAAgB;IAC1B;;;;;;;;;OASG;IACH,+BAAW,CAAA;IAEX;;;;;;;OAOG;IACH,iCAAa,CAAA;IAEb;;;;;;;OAOG;IACH,mCAAe,CAAA;AACjB,CAAC,EAhCW,gBAAgB,GAAhB,wBAAgB,KAAhB,wBAAgB,QAgC3B"}

package/cjs/sudoKeyManager/publicKey.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublicKeyFormat = void 0;
+var PublicKeyFormat;
+(function (PublicKeyFormat) {
+    PublicKeyFormat[PublicKeyFormat["RSAPublicKey"] = 0] = "RSAPublicKey";
+    PublicKeyFormat[PublicKeyFormat["SPKI"] = 1] = "SPKI";
+})(PublicKeyFormat = exports.PublicKeyFormat || (exports.PublicKeyFormat = {}));
+//# sourceMappingURL=publicKey.js.map

package/cjs/sudoKeyManager/publicKey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publicKey.js","sourceRoot":"","sources":["../../src/sudoKeyManager/publicKey.ts"],"names":[],"mappings":";;;AAAA,IAAY,eAGX;AAHD,WAAY,eAAe;IACzB,qEAAY,CAAA;IACZ,qDAAI,CAAA;AACN,CAAC,EAHW,eAAe,GAAf,uBAAe,KAAf,uBAAe,QAG1B"}

package/cjs/sudoKeyManager/sudoCryptoProvider.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SudoCryptoProviderDefaults = void 0;
+class SudoCryptoProviderDefaults {
+}
+exports.SudoCryptoProviderDefaults = SudoCryptoProviderDefaults;
+SudoCryptoProviderDefaults.aesIVSize = 16;
+SudoCryptoProviderDefaults.aesKeySize = 256;
+SudoCryptoProviderDefaults.rsaKeySize = 2048;
+SudoCryptoProviderDefaults.pbkdfRounds = 10000;
+SudoCryptoProviderDefaults.pbkdfSaltSize = 16;
+//# sourceMappingURL=sudoCryptoProvider.js.map

package/cjs/sudoKeyManager/sudoCryptoProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sudoCryptoProvider.js","sourceRoot":"","sources":["../../src/sudoKeyManager/sudoCryptoProvider.ts"],"names":[],"mappings":";;;AAIA,MAAa,0BAA0B;;AAAvC,gEAMC;AALwB,oCAAS,GAAG,EAAE,CAAA;AACd,qCAAU,GAAG,GAAG,CAAA;AAChB,qCAAU,GAAG,IAAI,CAAA;AACjB,sCAAW,GAAG,KAAK,CAAA;AACnB,wCAAa,GAAG,EAAE,CAAA"}