@sudoplatform/sudo-common 7.0.2 → 8.0.0

package/cjs/logging/logger.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultLogger = void 0;
+const bunyanLogger_1 = require("./bunyanLogger");
+class DefaultLogger {
+    /**
+     * The default logger implementation which wraps browser-bunyan
+     *
+     * @param identifier the name of the module
+     * @param logLevel the log level for the module
+     */
+    constructor(identifier, logLevel) {
+        this.logger = (0, bunyanLogger_1.createBunyanLogger)(identifier, logLevel);
+    }
+    trace(message, fields) {
+        if (message === undefined)
+            return this.logger.trace();
+        if (fields) {
+            this.logger.trace({ obj: fields }, message);
+        }
+        else {
+            this.logger.trace(message);
+        }
+    }
+    debug(message, fields) {
+        if (message === undefined)
+            return this.logger.debug();
+        if (fields) {
+            this.logger.debug({ obj: fields }, message);
+        }
+        else {
+            this.logger.debug(message);
+        }
+    }
+    info(message, fields) {
+        if (message === undefined)
+            return this.logger.info();
+        if (fields) {
+            this.logger.info({ obj: fields }, message);
+        }
+        else {
+            this.logger.info(message);
+        }
+    }
+    warn(message, fields) {
+        if (message === undefined)
+            return this.logger.warn();
+        if (fields) {
+            this.logger.warn({ obj: fields }, message);
+        }
+        else {
+            this.logger.warn(message);
+        }
+    }
+    error(message, fields) {
+        if (message === undefined)
+            return this.logger.error();
+        if (fields) {
+            this.logger.error({ obj: fields }, message);
+        }
+        else {
+            this.logger.error(message);
+        }
+    }
+    fatal(message, fields) {
+        if (message === undefined)
+            return this.logger.fatal();
+        if (fields) {
+            this.logger.fatal({ obj: fields }, message);
+        }
+        else {
+            this.logger.fatal(message);
+        }
+    }
+}
+exports.DefaultLogger = DefaultLogger;
+//# sourceMappingURL=logger.js.map

package/cjs/logging/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/logging/logger.ts"],"names":[],"mappings":";;;AAAA,iDAAiE;AA+EjE,MAAa,aAAa;IAGxB;;;;;OAKG;IACH,YAAY,UAAmB,EAAE,QAAiB;QAChD,IAAI,CAAC,MAAM,GAAG,IAAA,iCAAkB,EAAC,UAAU,EAAE,QAAQ,CAAC,CAAA;IACxD,CAAC;IAID,KAAK,CAAC,OAAgB,EAAE,MAAgC;QACtD,IAAI,OAAO,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAA;QAErD,IAAI,MAAM,EAAE;YACV,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,CAAA;SAC5C;aAAM;YACL,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;SAC3B;IACH,CAAC;IAID,KAAK,CAAC,OAAgB,EAAE,MAAgC;QACtD,IAAI,OAAO,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAA;QAErD,IAAI,MAAM,EAAE;YACV,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,CAAA;SAC5C;aAAM;YACL,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;SAC3B;IACH,CAAC;IAID,IAAI,CAAC,OAAgB,EAAE,MAAgC;QACrD,IAAI,OAAO,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAA;QAEpD,IAAI,MAAM,EAAE;YACV,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,CAAA;SAC3C;aAAM;YACL,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;SAC1B;IACH,CAAC;IAID,IAAI,CAAC,OAAgB,EAAE,MAAgC;QACrD,IAAI,OAAO,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAA;QAEpD,IAAI,MAAM,EAAE;YACV,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,CAAA;SAC3C;aAAM;YACL,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;SAC1B;IACH,CAAC;IAID,KAAK,CAAC,OAAgB,EAAE,MAAgC;QACtD,IAAI,OAAO,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAA;QAErD,IAAI,MAAM,EAAE;YACV,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,CAAA;SAC5C;aAAM;YACL,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;SAC3B;IACH,CAAC;IAID,KAAK,CAAC,OAAgB,EAAE,MAAgC;QACtD,IAAI,OAAO,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAA;QAErD,IAAI,MAAM,EAAE;YACV,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,CAAA;SAC5C;aAAM;YACL,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;SAC3B;IACH,CAAC;CACF;AApFD,sCAoFC"}

package/cjs/sudoKeyArchive/index.d.ts

@@ -0,0 +1,4 @@
+export * from './keyArchive';
+export * from './keyInfo';
+export * from './keyType';
+export * from './sudoKeyArchive';

package/cjs/sudoKeyArchive/index.js

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

package/cjs/sudoKeyArchive/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/sudoKeyArchive/index.ts"],"names":[],"mappings":";;;AAAA,uDAA4B;AAC5B,oDAAyB;AACzB,oDAAyB;AACzB,2DAAgC"}

package/cjs/sudoKeyArchive/keyArchive.d.ts

@@ -0,0 +1,137 @@
+import * as t from 'io-ts';
+export declare const CURRENT_ARCHIVE_VERSION = 3;
+export declare const InsecureKeyArchiveType = "Insecure";
+export declare const InsecureKeyArchiveCodec: t.TypeC<{
+    /**
+     * Discriminant for InsecureKeyArchive type.
+     */
+    Type: t.LiteralC<"Insecure">;
+    /**
+     * Array of exported keys in clear text.
+     */
+    Keys: t.ArrayC<t.TypeC<{
+        Name: t.StringC;
+        Type: t.Type<import("./keyType").KeyArchiveKeyType, string, unknown>;
+        Data: t.StringC;
+        Synchronizable: t.BooleanC;
+        Exportable: t.BooleanC;
+        NameSpace: t.StringC;
+    }>>;
+    /**
+     * Version this archive format.
+     */
+    Version: t.LiteralC<3>;
+    /**
+     * Metainfo user is able to associate with the archive.
+     */
+    MetaInfo: t.RecordC<t.StringC, t.StringC>;
+}>;
+export declare type InsecureKeyArchive = t.TypeOf<typeof InsecureKeyArchiveCodec>;
+export declare const SecureKeyArchiveType = "Secure";
+export declare const UnrecognizedKeyArchiveCodec: t.PartialC<{
+    Version: t.NumberC;
+    Type: t.StringC;
+}>;
+export declare type UnrecognizedKeyArchive = t.TypeOf<typeof UnrecognizedKeyArchiveCodec>;
+export declare const SecureKeyArchiveCodec: t.TypeC<{
+    /**
+     * Discriminant for SecureKeyArchive type.
+     */
+    Type: t.LiteralC<"Secure">;
+    /**
+     * 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.StringC;
+    /**
+     * Rounds of PBKDF2 applied to password to derive symmetric key.
+     */
+    Rounds: t.NumberC;
+    /**
+     * Salt passed to PBKDF2 to derive symmetric key.
+     */
+    Salt: t.StringC;
+    /**
+     * IV used for AES encryption of keys.
+     */
+    IV: t.StringC;
+    /**
+     * Version this archive format.
+     */
+    Version: t.LiteralC<3>;
+    /**
+     * Metainfo user is able to associate with the archive.
+     */
+    MetaInfo: t.RecordC<t.StringC, t.StringC>;
+}>;
+export declare type SecureKeyArchive = t.TypeOf<typeof SecureKeyArchiveCodec>;
+export declare const KeyArchiveCodec: t.UnionC<[t.TypeC<{
+    /**
+     * Discriminant for SecureKeyArchive type.
+     */
+    Type: t.LiteralC<"Secure">;
+    /**
+     * 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.StringC;
+    /**
+     * Rounds of PBKDF2 applied to password to derive symmetric key.
+     */
+    Rounds: t.NumberC;
+    /**
+     * Salt passed to PBKDF2 to derive symmetric key.
+     */
+    Salt: t.StringC;
+    /**
+     * IV used for AES encryption of keys.
+     */
+    IV: t.StringC;
+    /**
+     * Version this archive format.
+     */
+    Version: t.LiteralC<3>;
+    /**
+     * Metainfo user is able to associate with the archive.
+     */
+    MetaInfo: t.RecordC<t.StringC, t.StringC>;
+}>, t.TypeC<{
+    /**
+     * Discriminant for InsecureKeyArchive type.
+     */
+    Type: t.LiteralC<"Insecure">;
+    /**
+     * Array of exported keys in clear text.
+     */
+    Keys: t.ArrayC<t.TypeC<{
+        Name: t.StringC;
+        Type: t.Type<import("./keyType").KeyArchiveKeyType, string, unknown>;
+        Data: t.StringC;
+        Synchronizable: t.BooleanC;
+        Exportable: t.BooleanC;
+        NameSpace: t.StringC;
+    }>>;
+    /**
+     * Version this archive format.
+     */
+    Version: t.LiteralC<3>;
+    /**
+     * Metainfo user is able to associate with the archive.
+     */
+    MetaInfo: t.RecordC<t.StringC, t.StringC>;
+}>, t.PartialC<{
+    Version: t.NumberC;
+    Type: t.StringC;
+}>]>;
+export declare type KeyArchive = t.TypeOf<typeof KeyArchiveCodec>;
+export declare function isSecureKeyArchive(keyArchive: KeyArchive): keyArchive is SecureKeyArchive;
+export declare function isInsecureKeyArchive(keyArchive: KeyArchive): keyArchive is InsecureKeyArchive;
+export declare function isUnrecognizedKeyArchive(keyArchive: KeyArchive): keyArchive is UnrecognizedKeyArchive;

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.d.ts

@@ -0,0 +1,41 @@
+import * as t from 'io-ts';
+export declare const KeyArchiveKeyInfoCodec: t.TypeC<{
+    Name: t.StringC;
+    Type: t.Type<import("./keyType").KeyArchiveKeyType, string, unknown>;
+    Data: t.StringC;
+    Synchronizable: t.BooleanC;
+    Exportable: t.BooleanC;
+    NameSpace: t.StringC;
+}>;
+export declare const KeyArchiveKeyInfoArrayCodec: t.ArrayC<t.TypeC<{
+    Name: t.StringC;
+    Type: t.Type<import("./keyType").KeyArchiveKeyType, string, unknown>;
+    Data: t.StringC;
+    Synchronizable: t.BooleanC;
+    Exportable: t.BooleanC;
+    NameSpace: t.StringC;
+}>>;
+/**
+ * Record of key in a key archive
+ *
+ * @property NameSpace
+ *     NameSpace to which the key belongs.
+ *
+ * @property Name
+ *     Name of the key within the namespace
+ *
+ * @property Type
+ *     Type of the key (also implies key format)
+ *
+ * @property Data
+ *     Base64 encoded key data
+ *
+ * @property Synchronizable
+ *     Whether key should be synced out of band of archiving.
+ *     For future use - always false for now.
+ *
+ * @property Exportable
+ *     Whether restored key should be exportable. Always true on archive.
+ *     For future use on unarchive.
+ */
+export declare type KeyArchiveKeyInfo = t.TypeOf<typeof KeyArchiveKeyInfoCodec>;

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.d.ts

@@ -0,0 +1,13 @@
+import * as t from 'io-ts';
+/**
+ * Key types supported in key archives
+ *
+ * These form part of the interoperable secure key archive format.
+ */
+export declare enum KeyArchiveKeyType {
+    Password = "password",
+    PrivateKey = "privateKey",
+    PublicKey = "publicKey",
+    SymmetricKey = "symmetricKey"
+}
+export declare const KeyArchiveKeyTypeCodec: t.Type<KeyArchiveKeyType, string, unknown>;

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.d.ts

@@ -0,0 +1,190 @@
+import { KeyData, KeyDataKeyType } from '../sudoKeyManager';
+import { SudoKeyManager } from '../sudoKeyManager/sudoKeyManager';
+import { KeyArchiveKeyInfo } from './keyInfo';
+import { KeyArchiveKeyType } from './keyType';
+export interface SudoKeyArchive {
+    /**
+     * Loads keys from the secure store into the archive.
+     */
+    loadKeys(): Promise<void>;
+    /**
+     * Saves the keys in this archive to the secure store.
+     */
+    saveKeys(): Promise<void>;
+    /**
+     * Archives and encrypts the keys loaded into this archive.
+     *
+     * @param password
+     *   The password to use to encrypt the archive. Or undefined if no password.
+     *   Choice to have no password must be explicit.
+     *
+     * @returns Binary archive data.
+     */
+    archive(password: ArrayBuffer | undefined): Promise<ArrayBuffer>;
+    /**
+     * Decrypts and unarchives the keys in this archive.
+     *
+     * @param password
+     *    The password to use to decrypt the archive if its a secure archive
+     *    otherwise must be undefined.
+     *
+     * @throws {@link KeyArchiveDecodingError}
+     *    If the archive is unable to be decoding according to the
+     *    required structure.
+     *
+     * @throws {@link KeyArchiveIncorrectPasswordError}
+     *    If the archive is a secure archive and the password is unable to be
+     *    used to decrypt the encrypted keys.
+     *
+     * @throws {@link KeyArchivePasswordRequiredError}
+     *    If the archive is a secure archive but no password is provided.
+     *
+     * @throws {@link KeyArchiveNoPasswordRequiredError}
+     *    If the archive is an insecure archive but a password is provided.
+     */
+    unarchive(password: ArrayBuffer | undefined): Promise<void>;
+    /**
+     * Resets the archive by clearing loaded keys and archive data.
+     */
+    reset(): void;
+    /**
+     * Determines whether or not the archive contains the key with the
+     * specified name and type. The archive must be unarchived before the
+     * key can be searched.
+     *
+     * @param namespace the namespace of the key
+     * @param name the key name.
+     * @param type the key type.
+     *
+     * @return true if the specified key exists in the archive.
+     */
+    containsKey(namespace: string, name: string, type: KeyArchiveKeyType): boolean;
+    /**
+     * Retrieves the specified key data from the archive. The archive must
+     * be unarchived before the key data can be retrieved.
+     *
+     * @param namespace the namespace of the key
+     * @param name the key name
+     * @param type the key type
+     *
+     * @return a byte array containing the specified key data or null if it was not found.
+     *
+     * @throws {@link KeyNotFoundError}
+     *     If key is not present in the archive.
+     */
+    getKeyData(namespace: string, name: string, type: KeyArchiveKeyType): ArrayBuffer;
+    /** @return the key types to exclude from the archive in an unmodifiable set. */
+    getExcludedKeyTypes(): ReadonlySet<KeyArchiveKeyType>;
+    /** @return the key names to exclude from the archive in an unmodifiable set. */
+    getExcludedKeys(): ReadonlySet<string>;
+    /** @return the meta-information associated with this archive in an unmodifiable map. */
+    getMetaInfo(): ReadonlyMap<string, string>;
+}
+export declare type KeyArchiveKeyInfoDecoded = KeyArchiveKeyInfo & {
+    Decoded: ArrayBuffer;
+};
+export declare class DefaultSudoKeyArchive implements SudoKeyArchive {
+    /**
+     * 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.
+     */
+    static readonly 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.
+     */
+    static readonly CURRENT_ARCHIVE_VERSION = 3;
+    private readonly defaultKeyManager;
+    private readonly keyManagers;
+    private keyArchive;
+    private readonly excludedKeys;
+    private readonly excludedKeyTypes;
+    private readonly metaInfo;
+    private readonly keys;
+    /**
+     * 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: SudoKeyManager | SudoKeyManager[], options?: {
+        archiveData?: ArrayBuffer;
+        excludedKeys?: ReadonlySet<string>;
+        excludedKeyTypes?: ReadonlySet<KeyArchiveKeyType>;
+        metaInfo?: ReadonlyMap<string, string>;
+    });
+    /**
+     * Reads the binary data and converts it to JSON and then deserialises it
+     * into a KeyArchive
+     */
+    private loadArchive;
+    loadKeys(): Promise<void>;
+    saveKeys(): Promise<void>;
+    archive(password: ArrayBuffer | undefined): Promise<ArrayBuffer>;
+    unarchive(password: ArrayBuffer | undefined): Promise<void>;
+    reset(): void;
+    containsKey(namespace: string, name: string, type: KeyArchiveKeyType): boolean;
+    getKeyData(namespace: string, name: string, type: KeyArchiveKeyType): ArrayBuffer;
+    getExcludedKeys(): ReadonlySet<string>;
+    getExcludedKeyTypes(): ReadonlySet<KeyArchiveKeyType>;
+    getMetaInfo(): ReadonlyMap<string, string>;
+}
+export declare function keyArchiveInfoFromKeyData(keyData: KeyData): KeyArchiveKeyInfoDecoded;
+export declare function keyArchiveKeyTypeFromKeyDataKeyType(keyDataKeyType: KeyDataKeyType): KeyArchiveKeyType;