@fgv/ts-extras 5.0.2 → 5.1.0-1

package/dist/packlets/crypto-utils/keystore/keyStore.js

@@ -0,0 +1,758 @@
+// Copyright (c) 2026 Erik Fortune
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+import { captureResult, fail, succeed } from '@fgv/ts-utils';
+import * as Constants from '../constants';
+import { createEncryptedFile } from '../encryptedFile';
+import { DEFAULT_KEYSTORE_ITERATIONS, DEFAULT_SECRET_ITERATIONS, KEYSTORE_FORMAT, MIN_SALT_LENGTH } from './model';
+import { keystoreFile, keystoreVaultContents } from './converters';
+/**
+ * Gets the current ISO timestamp.
+ */
+function getCurrentTimestamp() {
+    return new Date().toISOString();
+}
+// ============================================================================
+// KeyStore Class
+// ============================================================================
+/**
+ * Password-protected key store for managing encryption secrets.
+ *
+ * The KeyStore provides a secure vault for storing named encryption keys.
+ * The vault is encrypted at rest using a master password via PBKDF2 key derivation.
+ *
+ * @example
+ * ```typescript
+ * // Create new key store
+ * const keystore = KeyStore.create({ cryptoProvider: nodeCryptoProvider }).orThrow();
+ * await keystore.initialize('master-password');
+ *
+ * // Add secrets
+ * await keystore.addSecret('my-key', { description: 'Production key' });
+ *
+ * // Save to file
+ * const fileContent = await keystore.save();
+ *
+ * // Later: Open existing key store
+ * const keystore2 = KeyStore.open({
+ *   cryptoProvider: nodeCryptoProvider,
+ *   keystoreFile: fileContent.value
+ * }).orThrow();
+ * await keystore2.unlock('master-password');
+ *
+ * // Use as secret provider for encrypted file loading
+ * const encryptionConfig = keystore2.getEncryptionConfig().orThrow();
+ * ```
+ *
+ * @public
+ */
+export class KeyStore {
+    constructor(cryptoProvider, iterations, keystoreFile, isNew = true) {
+        this._cryptoProvider = cryptoProvider;
+        this._iterations = iterations;
+        this._keystoreFile = keystoreFile;
+        this._state = 'locked';
+        this._dirty = false;
+        this._isNew = isNew;
+    }
+    // ============================================================================
+    // Factory Methods
+    // ============================================================================
+    /**
+     * Creates a new, empty key store.
+     * Call `initialize(password)` to set the master password.
+     * @param params - Creation parameters
+     * @returns Success with new KeyStore instance, or Failure if parameters invalid
+     * @public
+     */
+    static create(params) {
+        var _a;
+        const iterations = (_a = params.iterations) !== null && _a !== void 0 ? _a : DEFAULT_KEYSTORE_ITERATIONS;
+        if (iterations < 1) {
+            return fail('Iterations must be at least 1');
+        }
+        return succeed(new KeyStore(params.cryptoProvider, iterations, undefined, true));
+    }
+    /**
+     * Opens an existing encrypted key store.
+     * Call `unlock(password)` to decrypt and access secrets.
+     * @param params - Open parameters including the encrypted file
+     * @returns Success with KeyStore instance, or Failure if file format invalid
+     * @public
+     */
+    static open(params) {
+        // Validate the file format
+        const fileResult = keystoreFile.convert(params.keystoreFile);
+        if (fileResult.isFailure()) {
+            return fail(`Invalid key store file: ${fileResult.message}`);
+        }
+        const iterations = fileResult.value.keyDerivation.iterations;
+        return succeed(new KeyStore(params.cryptoProvider, iterations, fileResult.value, false));
+    }
+    // ============================================================================
+    // Lifecycle Methods
+    // ============================================================================
+    /**
+     * Initializes a new key store with the master password.
+     * Generates a random salt for key derivation.
+     * Only valid for newly created (not opened) key stores.
+     * @param password - The master password
+     * @returns Success with this instance when initialized, Failure if already initialized or opened
+     * @public
+     */
+    async initialize(password) {
+        if (!this._isNew) {
+            return fail('Cannot initialize an opened key store - use unlock() instead');
+        }
+        if (this._state === 'unlocked') {
+            return fail('Key store is already initialized');
+        }
+        if (!password || password.length === 0) {
+            return fail('Password cannot be empty');
+        }
+        // Generate salt for this key store using crypto provider
+        const saltResult = this._cryptoProvider.generateRandomBytes(MIN_SALT_LENGTH);
+        /* c8 ignore next 3 - crypto provider errors tested but coverage intermittently missed */
+        if (saltResult.isFailure()) {
+            return fail(`Failed to generate salt: ${saltResult.message}`);
+        }
+        this._salt = saltResult.value;
+        this._secrets = new Map();
+        this._state = 'unlocked';
+        this._dirty = true; // New store needs to be saved
+        return succeed(this);
+    }
+    /**
+     * Unlocks an existing key store with the master password.
+     * Decrypts the vault and loads secrets into memory.
+     * @param password - The master password
+     * @returns Success with this instance when unlocked, Failure if password incorrect
+     * @public
+     */
+    async unlock(password) {
+        var _a;
+        if (this._isNew) {
+            return fail('Cannot unlock a new key store - use initialize() instead');
+        }
+        /* c8 ignore next 6 - error paths tested but coverage intermittently missed */
+        if (this._state === 'unlocked') {
+            return fail('Key store is already unlocked');
+        }
+        if (!this._keystoreFile) {
+            return fail('No key store file to unlock');
+        }
+        const keyDerivation = this._keystoreFile.keyDerivation;
+        const saltResult = this._cryptoProvider.fromBase64(keyDerivation.salt);
+        /* c8 ignore next 3 - error path tested but coverage intermittently missed */
+        if (saltResult.isFailure()) {
+            return fail(`Invalid salt in key store file: ${saltResult.message}`);
+        }
+        const salt = saltResult.value;
+        // Derive the key from password
+        const keyResult = await this._cryptoProvider.deriveKey(password, salt, keyDerivation.iterations);
+        /* c8 ignore next 3 - error path tested but coverage intermittently missed */
+        if (keyResult.isFailure()) {
+            return fail(`Key derivation failed: ${keyResult.message}`);
+        }
+        // Decrypt the vault
+        const ivResult = this._cryptoProvider.fromBase64(this._keystoreFile.iv);
+        const authTagResult = this._cryptoProvider.fromBase64(this._keystoreFile.authTag);
+        const encryptedDataResult = this._cryptoProvider.fromBase64(this._keystoreFile.encryptedData);
+        /* c8 ignore next 9 - base64 decode errors tested but coverage intermittently missed */
+        if (ivResult.isFailure()) {
+            return fail(`Invalid IV in key store file: ${ivResult.message}`);
+        }
+        if (authTagResult.isFailure()) {
+            return fail(`Invalid auth tag in key store file: ${authTagResult.message}`);
+        }
+        if (encryptedDataResult.isFailure()) {
+            return fail(`Invalid encrypted data in key store file: ${encryptedDataResult.message}`);
+        }
+        const decryptResult = await this._cryptoProvider.decrypt(encryptedDataResult.value, keyResult.value, ivResult.value, authTagResult.value);
+        if (decryptResult.isFailure()) {
+            return fail('Incorrect password or corrupted key store');
+        }
+        // Parse the vault contents
+        const parseResult = captureResult(() => JSON.parse(decryptResult.value));
+        /* c8 ignore next 3 - error path tested but coverage intermittently missed */
+        if (parseResult.isFailure()) {
+            return fail(`Failed to parse vault contents: ${parseResult.message}`);
+        }
+        const vaultResult = keystoreVaultContents.convert(parseResult.value);
+        /* c8 ignore next 3 - error path tested but coverage intermittently missed */
+        if (vaultResult.isFailure()) {
+            return fail(`Invalid vault format: ${vaultResult.message}`);
+        }
+        // Load secrets into memory
+        this._salt = salt;
+        this._secrets = new Map();
+        for (const [name, jsonEntry] of Object.entries(vaultResult.value.secrets)) {
+            const keyBytesResult = this._cryptoProvider.fromBase64(jsonEntry.key);
+            /* c8 ignore next 3 - error path tested but coverage intermittently missed */
+            if (keyBytesResult.isFailure()) {
+                return fail(`Invalid key for secret '${name}': ${keyBytesResult.message}`);
+            }
+            const entry = {
+                name,
+                /* c8 ignore next 1 - backwards compatibility: old vaults may lack type field */
+                type: (_a = jsonEntry.type) !== null && _a !== void 0 ? _a : 'encryption-key',
+                key: keyBytesResult.value,
+                description: jsonEntry.description,
+                createdAt: jsonEntry.createdAt
+            };
+            this._secrets.set(name, entry);
+        }
+        this._state = 'unlocked';
+        this._dirty = false;
+        return succeed(this);
+    }
+    /**
+     * Locks the key store, clearing all secrets from memory.
+     * @param force - If true, discards unsaved changes
+     * @returns Success when locked, Failure if unsaved changes and !force
+     * @public
+     */
+    lock(force) {
+        if (this._state === 'locked') {
+            return succeed(this);
+        }
+        if (this._dirty && !force) {
+            return fail('Unsaved changes - use force=true to discard or save() first');
+        }
+        // Clear secrets from memory (overwrite for security)
+        if (this._secrets) {
+            for (const entry of this._secrets.values()) {
+                entry.key.fill(0);
+            }
+            this._secrets.clear();
+            this._secrets = undefined;
+        }
+        this._state = 'locked';
+        this._dirty = false;
+        return succeed(this);
+    }
+    /**
+     * Checks if the key store is unlocked.
+     * @public
+     */
+    get isUnlocked() {
+        return this._state === 'unlocked';
+    }
+    /**
+     * Checks if there are unsaved changes.
+     * @public
+     */
+    get isDirty() {
+        return this._dirty;
+    }
+    /**
+     * Whether this is a newly created key store (not opened from a file).
+     * A new key store must be initialized with a password before use.
+     * An opened key store must be unlocked with the existing password.
+     * @public
+     */
+    get isNew() {
+        return this._isNew;
+    }
+    /**
+     * Gets the current lock state.
+     * @public
+     */
+    get state() {
+        return this._state;
+    }
+    /**
+     * Gets the crypto provider used by this key store.
+     * Available regardless of lock state.
+     * @public
+     */
+    get cryptoProvider() {
+        return this._cryptoProvider;
+    }
+    // ============================================================================
+    // Secret Management
+    // ============================================================================
+    /**
+     * Lists all secret names in the key store.
+     * @returns Success with array of secret names, Failure if locked
+     * @public
+     */
+    listSecrets() {
+        if (!this._secrets) {
+            return fail('Key store is locked');
+        }
+        return succeed(Array.from(this._secrets.keys()));
+    }
+    /**
+     * Gets a secret by name.
+     * @param name - Name of the secret
+     * @returns Success with secret entry, Failure if not found or locked
+     * @public
+     */
+    getSecret(name) {
+        if (!this._secrets) {
+            return fail('Key store is locked');
+        }
+        const entry = this._secrets.get(name);
+        if (!entry) {
+            return fail(`Secret '${name}' not found`);
+        }
+        return succeed(entry);
+    }
+    /**
+     * Checks if a secret exists.
+     * @param name - Name of the secret
+     * @returns Success with boolean, Failure if locked
+     * @public
+     */
+    hasSecret(name) {
+        if (!this._secrets) {
+            return fail('Key store is locked');
+        }
+        return succeed(this._secrets.has(name));
+    }
+    /**
+     * Adds a new secret with a randomly generated key.
+     * @param name - Unique name for the secret
+     * @param options - Optional description
+     * @returns Success with the generated entry, Failure if locked or name invalid
+     * @public
+     */
+    async addSecret(name, options) {
+        if (!this._secrets) {
+            return fail('Key store is locked');
+        }
+        if (!name || name.length === 0) {
+            return fail('Secret name cannot be empty');
+        }
+        const replaced = this._secrets.has(name);
+        // Generate a new random key
+        const keyResult = await this._cryptoProvider.generateKey();
+        /* c8 ignore next 3 - crypto provider errors tested but coverage intermittently missed */
+        if (keyResult.isFailure()) {
+            return fail(`Failed to generate key: ${keyResult.message}`);
+        }
+        const entry = {
+            name,
+            type: 'encryption-key',
+            key: keyResult.value,
+            description: options === null || options === void 0 ? void 0 : options.description,
+            createdAt: getCurrentTimestamp()
+        };
+        this._secrets.set(name, entry);
+        this._dirty = true;
+        return succeed({ entry, replaced });
+    }
+    /**
+     * Imports an existing secret key.
+     * @param name - Unique name for the secret
+     * @param key - The 32-byte AES-256 key
+     * @param options - Optional description, whether to replace existing
+     * @returns Success with entry, Failure if locked, key invalid, or exists and !replace
+     * @public
+     */
+    importSecret(name, key, options) {
+        if (!this._secrets) {
+            return fail('Key store is locked');
+        }
+        if (!name || name.length === 0) {
+            return fail('Secret name cannot be empty');
+        }
+        if (key.length !== Constants.AES_256_KEY_SIZE) {
+            return fail(`Key must be ${Constants.AES_256_KEY_SIZE} bytes, got ${key.length}`);
+        }
+        const exists = this._secrets.has(name);
+        if (exists && !(options === null || options === void 0 ? void 0 : options.replace)) {
+            return fail(`Secret '${name}' already exists - use replace=true to overwrite`);
+        }
+        const entry = {
+            name,
+            type: 'encryption-key',
+            key: new Uint8Array(key), // Copy to prevent external modification
+            description: options === null || options === void 0 ? void 0 : options.description,
+            createdAt: getCurrentTimestamp()
+        };
+        this._secrets.set(name, entry);
+        this._dirty = true;
+        return succeed({ entry, replaced: exists });
+    }
+    /**
+     * Adds a secret derived from a password using PBKDF2.
+     *
+     * Generates a random salt, derives a 32-byte AES-256 key from the password,
+     * and stores it in the vault. Returns the key derivation parameters so they
+     * can be stored alongside encrypted files, enabling decryption with just the
+     * password (without unlocking the keystore).
+     *
+     * @param name - Unique name for the secret
+     * @param password - Password to derive the key from
+     * @param options - Optional description, iterations, replace flag
+     * @returns Success with entry and keyDerivation params, Failure if locked or invalid
+     * @public
+     */
+    async addSecretFromPassword(name, password, options) {
+        var _a;
+        if (!this._secrets) {
+            return fail('Key store is locked');
+        }
+        if (!name || name.length === 0) {
+            return fail('Secret name cannot be empty');
+        }
+        if (!password || password.length === 0) {
+            return fail('Password cannot be empty');
+        }
+        const exists = this._secrets.has(name);
+        if (exists && !(options === null || options === void 0 ? void 0 : options.replace)) {
+            return fail(`Secret '${name}' already exists - use replace=true to overwrite`);
+        }
+        const iterations = (_a = options === null || options === void 0 ? void 0 : options.iterations) !== null && _a !== void 0 ? _a : DEFAULT_SECRET_ITERATIONS;
+        // Generate a random salt for this secret's key derivation
+        const saltResult = this._cryptoProvider.generateRandomBytes(MIN_SALT_LENGTH);
+        /* c8 ignore next 3 - crypto provider errors tested but coverage intermittently missed */
+        if (saltResult.isFailure()) {
+            return fail(`Failed to generate salt: ${saltResult.message}`);
+        }
+        // Derive the key from password
+        const keyResult = await this._cryptoProvider.deriveKey(password, saltResult.value, iterations);
+        /* c8 ignore next 3 - crypto provider errors tested but coverage intermittently missed */
+        if (keyResult.isFailure()) {
+            return fail(`Key derivation failed: ${keyResult.message}`);
+        }
+        const entry = {
+            name,
+            type: 'encryption-key',
+            key: keyResult.value,
+            description: options === null || options === void 0 ? void 0 : options.description,
+            createdAt: getCurrentTimestamp()
+        };
+        this._secrets.set(name, entry);
+        this._dirty = true;
+        return succeed({
+            entry,
+            replaced: exists,
+            keyDerivation: {
+                kdf: 'pbkdf2',
+                salt: this._cryptoProvider.toBase64(saltResult.value),
+                iterations
+            }
+        });
+    }
+    /**
+     * Removes a secret by name.
+     * @param name - Name of the secret to remove
+     * @returns Success with removed entry, Failure if not found or locked
+     * @public
+     */
+    removeSecret(name) {
+        if (!this._secrets) {
+            return fail('Key store is locked');
+        }
+        const entry = this._secrets.get(name);
+        if (!entry) {
+            return fail(`Secret '${name}' not found`);
+        }
+        // Clear the key before removing (security)
+        entry.key.fill(0);
+        this._secrets.delete(name);
+        this._dirty = true;
+        return succeed(entry);
+    }
+    /**
+     * Imports an API key string into the vault.
+     * The string is UTF-8 encoded and stored with type `'api-key'`.
+     * @param name - Unique name for the secret
+     * @param apiKey - The API key string
+     * @param options - Optional description, whether to replace existing
+     * @returns Success with entry, Failure if locked, empty, or exists and !replace
+     * @public
+     */
+    importApiKey(name, apiKey, options) {
+        if (!this._secrets) {
+            return fail('Key store is locked');
+        }
+        if (!name || name.length === 0) {
+            return fail('Secret name cannot be empty');
+        }
+        if (!apiKey || apiKey.length === 0) {
+            return fail('API key cannot be empty');
+        }
+        const exists = this._secrets.has(name);
+        if (exists && !(options === null || options === void 0 ? void 0 : options.replace)) {
+            return fail(`Secret '${name}' already exists - use replace=true to overwrite`);
+        }
+        const encoder = new TextEncoder();
+        const entry = {
+            name,
+            type: 'api-key',
+            key: encoder.encode(apiKey),
+            description: options === null || options === void 0 ? void 0 : options.description,
+            createdAt: getCurrentTimestamp()
+        };
+        this._secrets.set(name, entry);
+        this._dirty = true;
+        return succeed({ entry, replaced: exists });
+    }
+    /**
+     * Retrieves an API key string by name.
+     * Only works for secrets with type `'api-key'`.
+     * @param name - Name of the secret
+     * @returns Success with the API key string, Failure if not found, locked, or wrong type
+     * @public
+     */
+    getApiKey(name) {
+        if (!this._secrets) {
+            return fail('Key store is locked');
+        }
+        const entry = this._secrets.get(name);
+        if (!entry) {
+            return fail(`Secret '${name}' not found`);
+        }
+        if (entry.type !== 'api-key') {
+            return fail(`Secret '${name}' is not an API key (type: ${entry.type})`);
+        }
+        const decoder = new TextDecoder();
+        return succeed(decoder.decode(entry.key));
+    }
+    /**
+     * Lists secret names filtered by type.
+     * @param type - The secret type to filter by
+     * @returns Success with array of matching secret names, Failure if locked
+     * @public
+     */
+    listSecretsByType(type) {
+        if (!this._secrets) {
+            return fail('Key store is locked');
+        }
+        const names = [];
+        for (const [name, entry] of this._secrets) {
+            if (entry.type === type) {
+                names.push(name);
+            }
+        }
+        return succeed(names);
+    }
+    /**
+     * Renames a secret.
+     * @param oldName - Current name
+     * @param newName - New name
+     * @returns Success with updated entry, Failure if source not found, target exists, or locked
+     * @public
+     */
+    renameSecret(oldName, newName) {
+        if (!this._secrets) {
+            return fail('Key store is locked');
+        }
+        if (!newName || newName.length === 0) {
+            return fail('New name cannot be empty');
+        }
+        const entry = this._secrets.get(oldName);
+        if (!entry) {
+            return fail(`Secret '${oldName}' not found`);
+        }
+        if (oldName !== newName && this._secrets.has(newName)) {
+            return fail(`Secret '${newName}' already exists`);
+        }
+        // Create new entry with new name (preserve type)
+        const newEntry = Object.assign(Object.assign({}, entry), { name: newName });
+        this._secrets.delete(oldName);
+        this._secrets.set(newName, newEntry);
+        this._dirty = true;
+        return succeed(newEntry);
+    }
+    // ============================================================================
+    // Persistence
+    // ============================================================================
+    /**
+     * Saves the key store, returning the encrypted file content.
+     * Requires the master password to encrypt.
+     * @param password - The master password
+     * @returns Success with IKeyStoreFile, Failure if locked
+     * @public
+     */
+    async save(password) {
+        if (!this._secrets || !this._salt) {
+            return fail('Key store is locked');
+        }
+        if (!password || password.length === 0) {
+            return fail('Password cannot be empty');
+        }
+        // Derive the encryption key
+        const keyResult = await this._cryptoProvider.deriveKey(password, this._salt, this._iterations);
+        /* c8 ignore next 3 - crypto provider errors tested but coverage intermittently missed */
+        if (keyResult.isFailure()) {
+            return fail(`Key derivation failed: ${keyResult.message}`);
+        }
+        // Build vault contents
+        const secrets = {};
+        for (const [name, entry] of this._secrets) {
+            secrets[name] = {
+                name: entry.name,
+                type: entry.type,
+                key: this._cryptoProvider.toBase64(entry.key),
+                description: entry.description,
+                createdAt: entry.createdAt
+            };
+        }
+        const vaultContents = {
+            version: KEYSTORE_FORMAT,
+            secrets
+        };
+        // Serialize and encrypt
+        const jsonResult = captureResult(() => JSON.stringify(vaultContents));
+        /* c8 ignore next 3 - error path tested but coverage intermittently missed */
+        if (jsonResult.isFailure()) {
+            return fail(`Failed to serialize vault: ${jsonResult.message}`);
+        }
+        const encryptResult = await this._cryptoProvider.encrypt(jsonResult.value, keyResult.value);
+        /* c8 ignore next 3 - crypto provider errors tested but coverage intermittently missed */
+        if (encryptResult.isFailure()) {
+            return fail(`Encryption failed: ${encryptResult.message}`);
+        }
+        const { iv, authTag, encryptedData } = encryptResult.value;
+        const keystoreFileData = {
+            format: KEYSTORE_FORMAT,
+            algorithm: Constants.DEFAULT_ALGORITHM,
+            iv: this._cryptoProvider.toBase64(iv),
+            authTag: this._cryptoProvider.toBase64(authTag),
+            encryptedData: this._cryptoProvider.toBase64(encryptedData),
+            keyDerivation: {
+                kdf: 'pbkdf2',
+                salt: this._cryptoProvider.toBase64(this._salt),
+                iterations: this._iterations
+            }
+        };
+        this._keystoreFile = keystoreFileData;
+        this._dirty = false;
+        this._isNew = false;
+        return succeed(keystoreFileData);
+    }
+    /**
+     * Changes the master password.
+     * Re-encrypts the vault with the new password-derived key.
+     * @param currentPassword - Current master password (for verification)
+     * @param newPassword - New master password
+     * @returns Success when password changed, Failure if locked or current password incorrect
+     * @public
+     */
+    async changePassword(currentPassword, newPassword) {
+        if (!this._secrets || !this._salt) {
+            return fail('Key store is locked');
+        }
+        if (!newPassword || newPassword.length === 0) {
+            return fail('New password cannot be empty');
+        }
+        // Verify current password by trying to derive and re-encrypt
+        // (For opened stores, we'd need to verify against the stored file)
+        if (this._keystoreFile) {
+            const saltResult = this._cryptoProvider.fromBase64(this._keystoreFile.keyDerivation.salt);
+            /* c8 ignore next 3 - error path tested but coverage intermittently missed */
+            if (saltResult.isFailure()) {
+                return fail(`Invalid salt in key store file: ${saltResult.message}`);
+            }
+            const keyResult = await this._cryptoProvider.deriveKey(currentPassword, saltResult.value, this._keystoreFile.keyDerivation.iterations);
+            /* c8 ignore next 3 - error path tested but coverage intermittently missed */
+            if (keyResult.isFailure()) {
+                return fail(`Key derivation failed: ${keyResult.message}`);
+            }
+            // Try to decrypt to verify password
+            const ivResult = this._cryptoProvider.fromBase64(this._keystoreFile.iv);
+            const authTagResult = this._cryptoProvider.fromBase64(this._keystoreFile.authTag);
+            const encryptedDataResult = this._cryptoProvider.fromBase64(this._keystoreFile.encryptedData);
+            /* c8 ignore next 3 - error path tested but coverage intermittently missed */
+            if (ivResult.isFailure() || authTagResult.isFailure() || encryptedDataResult.isFailure()) {
+                return fail('Invalid key store file format');
+            }
+            const decryptResult = await this._cryptoProvider.decrypt(encryptedDataResult.value, keyResult.value, ivResult.value, authTagResult.value);
+            if (decryptResult.isFailure()) {
+                return fail('Current password is incorrect');
+            }
+        }
+        // Generate new salt for the new password using crypto provider
+        const saltResult = this._cryptoProvider.generateRandomBytes(MIN_SALT_LENGTH);
+        /* c8 ignore next 3 - crypto provider errors tested but coverage intermittently missed */
+        if (saltResult.isFailure()) {
+            return fail(`Failed to generate salt: ${saltResult.message}`);
+        }
+        this._salt = saltResult.value;
+        this._dirty = true;
+        // Save with new password
+        const saveResult = await this.save(newPassword);
+        /* c8 ignore next 3 - error path tested but coverage intermittently missed */
+        if (saveResult.isFailure()) {
+            return fail(saveResult.message);
+        }
+        return succeed(this);
+    }
+    // ============================================================================
+    // IEncryptionProvider
+    // ============================================================================
+    /** {@inheritDoc IEncryptionProvider.encryptByName} */
+    async encryptByName(secretName, content, metadata) {
+        const secretResult = this.getSecret(secretName);
+        if (secretResult.isFailure()) {
+            return fail(`encryptByName: ${secretResult.message}`);
+        }
+        return createEncryptedFile({
+            content,
+            secretName,
+            key: secretResult.value.key,
+            cryptoProvider: this._cryptoProvider,
+            metadata
+        });
+    }
+    // ============================================================================
+    // Integration with IEncryptionConfig
+    // ============================================================================
+    /**
+     * Creates a SecretProvider function for use with IEncryptionConfig.
+     * The returned function looks up secrets from this key store.
+     * @returns Success with SecretProvider, Failure if locked
+     * @public
+     */
+    getSecretProvider() {
+        if (!this._secrets) {
+            return fail('Key store is locked');
+        }
+        const secrets = this._secrets;
+        const provider = async (secretName) => {
+            const entry = secrets.get(secretName);
+            if (!entry) {
+                return fail(`Secret '${secretName}' not found in key store`);
+            }
+            return succeed(entry.key);
+        };
+        return succeed(provider);
+    }
+    /**
+     * Creates a partial IEncryptionConfig using this key store as the secret source.
+     * @returns Partial config that can be spread into a full IEncryptionConfig
+     * @public
+     */
+    getEncryptionConfig() {
+        const providerResult = this.getSecretProvider();
+        if (providerResult.isFailure()) {
+            return fail(providerResult.message);
+        }
+        return succeed({
+            secretProvider: providerResult.value,
+            cryptoProvider: this._cryptoProvider
+        });
+    }
+}
+//# sourceMappingURL=keyStore.js.map