@sudoplatform/sudo-common 8.0.0 → 8.0.1

package/lib/sudoKeyArchive/keyArchive.d.ts

@@ -1,137 +0,0 @@
-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/lib/sudoKeyArchive/keyInfo.d.ts

@@ -1,41 +0,0 @@
-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/lib/sudoKeyArchive/keyType.d.ts

@@ -1,13 +0,0 @@
-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/lib/sudoKeyArchive/sudoKeyArchive.d.ts

@@ -1,190 +0,0 @@
-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;

package/lib/sudoKeyManager/index.d.ts

@@ -1,4 +0,0 @@
-export * from './keyData';
-export * from './publicKey';
-export * from './sudoCryptoProvider';
-export * from './sudoKeyManager';

package/lib/sudoKeyManager/keyData.d.ts

@@ -1,56 +0,0 @@
-/**
- * Type of key
- */
-export declare enum KeyDataKeyType {
-    SymmetricKey = "SymmetricKey",
-    RSAPublicKey = "RSAPublicKey",
-    RSAPrivateKey = "RSAPrivateKey",
-    Password = "Password"
-}
-export declare enum 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
-     */
-    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
-     */
-    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
-     */
-    PKCS8 = "PKCS8"
-}
-/**
- * Record of key in a key archive
- *
- * @property name name of the key within the namespace
- * @property namespace namespace of the key manager for this key
- * @property data raw binary data of the key
- * @property type type of the key
- * @property format format of the raw binary data
- */
-export interface KeyData {
-    name: string;
-    namespace: string;
-    data: ArrayBuffer;
-    type: KeyDataKeyType;
-    format: KeyDataKeyFormat;
-}

package/lib/sudoKeyManager/publicKey.d.ts

@@ -1,8 +0,0 @@
-export declare enum PublicKeyFormat {
-    RSAPublicKey = 0,
-    SPKI = 1
-}
-export interface PublicKey {
-    readonly keyData: ArrayBuffer;
-    readonly keyFormat: PublicKeyFormat;
-}