A modern platform for visual, flexible, and extensible graph-based investigations. For cybersecurity analysts and investigators.
fix(core): keys for transforms are now only fetched from vault
dextmorgn894d6c0674bf
diff --git a/flowsint-core/src/flowsint_core/core/transform_base.py b/flowsint-core/src/flowsint_core/core/transform_base.pyindex 71f99237..b797bcc9 100644--- a/flowsint-core/src/flowsint_core/core/transform_base.py+++ b/flowsint-core/src/flowsint_core/core/transform_base.py@@ -16,6 +16,9 @@ def build_params_model(params_schema: list) -> BaseModel:"""Build a strict Pydantic model from a params_schema.Unknown fields will raise a validation error.++ Note: Vault secrets are always optional in the Pydantic model to allow+ for deferred configuration. Required validation happens after vault resolution."""fields: Dict[str, Any] = {}@@ -23,7 +26,15 @@ def build_params_model(params_schema: list) -> BaseModel:name = param["name"]type = str # You can later enhance this to support int, bool, etc.required = param.get("required", False)- default = ... if required else param.get("default")+ param_type = param.get("type", "string")++ # Vault secrets are always optional in Pydantic validation+ # Required validation happens after vault resolution+ if param_type == "vaultSecret":+ default = param.get("default", None)+ else:+ default = ... if required else param.get("default")+fields[name] = (Optional[type],Field(default=default, description=param.get("description", "")),@@ -115,14 +126,11 @@ class Transform(ABC):async def async_init(self):self.ParamsModel = build_params_model(self.params_schema)- # Resolve parameters (e.g. replace vaultSecret by real secrets)- if self.params:- resolved_params = self.resolve_params()- Logger.debug(- self.sketch_id, {"message": f"Resolved params: {str(resolved_params)}"}- )- else:- resolved_params = {}++ # Always resolve parameters, even if self.params is empty+ # This allows vault secrets to be fetched by name from params_schema+ resolved_params = self.resolve_params()+# Strict validation after resolutiontry:validated = self.ParamsModel(**resolved_params)@@ -134,41 +142,42 @@ class Transform(ABC):def resolve_params(self) -> Dict[str, Any]:resolved = {}- Logger.debug(- self.sketch_id, {"message": f"Params schema: {str(self.params_schema)}"}- )- Logger.debug(self.sketch_id, {"message": f"Params: {str(self.params)}"})- Logger.debug(- self.sketch_id,- {"message": f"Params schema length: {len(self.params_schema)}"},- )- i = 1+for param in self.params_schema:- Logger.debug(self.sketch_id, {"message": f"Param {i}: {str(param)}"})- i += 1- if param["type"] == "vaultSecret":- # Check if the vault secret parameter is provided- if param["name"] in self.params and self.params[param["name"]]:- if self.vault is not None:- secret = self.vault.get_secret(self.params[param["name"]])- if secret is not None:- resolved[param["name"]] = secret- else:- # If secret not found in vault, keep the original parameter value- resolved[param["name"]] = self.params[param["name"]]- else:- # If vault is not available, use the parameter value as-is- resolved[param["name"]] = self.params[param["name"]]- elif param.get("default") is not None:- resolved[param["name"]] = param["default"]- # If not provided and no default, skip (optional parameter)+ param_name = param["name"]+ param_type = param.get("type", "string")++ if param_type == "vaultSecret":+ # For vault secrets, try to get from vault by name or ID+ secret = None+ if self.vault is not None:+ # First, check if user provided a specific vault ID in params+ if param_name in self.params and self.params[param_name]:+ secret = self.vault.get_secret(self.params[param_name])+ # Otherwise, try to get the secret by the param name itself+ if secret is None:+ secret = self.vault.get_secret(param_name)++ if secret is not None:+ resolved[param_name] = secret+ elif param.get("required", False):+ Logger.error(+ self.sketch_id,+ {+ "message": f"Required vault secret '{param_name}' is missing. Please go to the Vault settings and create a '{param_name}' key."+ },+ )++ # If no vault or no secret found, use default if available+ if param_name not in resolved and param.get("default") is not None:+ resolved[param_name] = param["default"]else:- if param["name"] in self.params and self.params[param["name"]]:- resolved[param["name"]] = self.params[param["name"]]+ # For non-vault params, use the provided value or default+ if param_name in self.params and self.params[param_name]:+ resolved[param_name] = self.params[param_name]elif param.get("default") is not None:- resolved[param["name"]] = param["default"]- else:- continue+ resolved[param_name] = param["default"]+return resolved@classmethod@@ -317,6 +326,20 @@ class Transform(ABC):def get_params(self) -> Dict[str, Any]:return self.params+ def get_secret(self, key_name: str, default: Any = None) -> Any:+ """+ Get a secret value by key name.+ The secret is automatically resolved from the vault during async_init.++ Args:+ key_name: The name of the secret parameter (e.g., "WHOXY_API_KEY")+ default: Default value if secret is not found++ Returns:+ The secret value from the vault, or default if not found+ """+ return self.params.get(key_name, default)+def preprocess(self, values: List[str]) -> List[str]:return valuesdiff --git a/flowsint-core/src/flowsint_core/core/vault.py b/flowsint-core/src/flowsint_core/core/vault.pyindex 9d75bc5a..8cc6ef58 100644--- a/flowsint-core/src/flowsint_core/core/vault.py+++ b/flowsint-core/src/flowsint_core/core/vault.py@@ -124,21 +124,32 @@ class Vault(VaultProtocol):return new_keydef get_secret(self, vault_ref: str) -> Optional[str]:- """_summary_+ """Get a secret from the vault by ID or name.Args:- vault_ref (str): _description_+ vault_ref (str): Either a UUID (key ID) or a string (key name)Returns:- Optional[str]: _description_+ Optional[str]: The decrypted secret value, or None if not found"""try:ref_uuid = uuid.UUID(vault_ref)stmt = select(Key).where(Key.id == ref_uuid)except ValueError:stmt = select(Key).where(Key.name == vault_ref)+stmt = stmt.where(Key.owner_id == self.owner_id)result = self.db.execute(stmt)row = result.scalars().first()- decrypted_key = self._decrypt_key(row.dict())- return decrypted_key if row else None++ if row:+ # Convert SQLAlchemy model to dict for decryption+ row_dict = {+ "salt": row.salt,+ "iv": row.iv,+ "ciphertext": row.ciphertext,+ }+ decrypted_key = self._decrypt_key(row_dict)+ return decrypted_key+ else:+ return Nonediff --git a/flowsint-core/tests/__init__.py b/flowsint-core/tests/__init__.pynew file mode 100644index 00000000..00c7cf48--- /dev/null+++ b/flowsint-core/tests/__init__.py@@ -0,0 +1 @@+# Tests for flowsint-corediff --git a/flowsint-core/tests/conftest.py b/flowsint-core/tests/conftest.pynew file mode 100644index 00000000..875bfe41--- /dev/null+++ b/flowsint-core/tests/conftest.py@@ -0,0 +1,21 @@+"""Pytest configuration for flowsint-core tests."""+import pytest+import os++[email protected](autouse=True)+def setup_test_environment(monkeypatch):+ """Set up test environment variables."""+ # Set a test master key for vault tests+ test_key = "base64:qnHTmwYb+uoygIw9MsRMY22vS5YPchY+QOi/E79GAvM="+ monkeypatch.setenv("MASTER_VAULT_KEY_V1", test_key)++[email protected](autouse=True)+def mock_logger(monkeypatch):+ """Mock the Logger to avoid database calls during tests."""+ from unittest.mock import MagicMock++ mock = MagicMock()+ monkeypatch.setattr("flowsint_core.core.logger.Logger", mock)+ return mockdiff --git a/flowsint-core/tests/test_transform_vault_integration.py b/flowsint-core/tests/test_transform_vault_integration.pynew file mode 100644index 00000000..40569ab8--- /dev/null+++ b/flowsint-core/tests/test_transform_vault_integration.py@@ -0,0 +1,332 @@+"""Tests for Transform base class vault integration."""+import pytest+import uuid+from typing import List, Dict, Any+from unittest.mock import Mock, MagicMock, patch+from flowsint_core.core.transform_base import Transform+++class MockTransform(Transform):+ """Mock transform for testing."""++ InputType = List[str]+ OutputType = List[str]++ @classmethod+ def name(cls) -> str:+ return "mock_transform"++ @classmethod+ def category(cls) -> str:+ return "Test"++ @classmethod+ def key(cls) -> str:+ return "test_key"++ @classmethod+ def get_params_schema(cls) -> List[Dict[str, Any]]:+ return [+ {+ "name": "TEST_API_KEY",+ "type": "vaultSecret",+ "description": "Test API key",+ "required": True,+ },+ {+ "name": "OPTIONAL_KEY",+ "type": "vaultSecret",+ "description": "Optional key",+ "required": False,+ "default": "default_value",+ },+ {+ "name": "NON_VAULT_PARAM",+ "type": "string",+ "description": "Non-vault parameter",+ "required": False,+ "default": "test",+ },+ ]++ async def scan(self, data: InputType) -> OutputType:+ return data+++def mock_vault():+ """Create a mock vault instance."""+ vault = Mock()+ vault.get_secret = Mock()+ return vault+++def sketch_id():+ """Create a test sketch ID."""+ return str(uuid.uuid4())+++def transform(mock_vault, sketch_id):+ """Create a MockTransform instance with vault."""+ return MockTransform(+ sketch_id=sketch_id,+ scan_id="scan_123",+ vault=mock_vault,+ params={},+ )+++class TestResolveParams:+ """Tests for resolve_params() method."""++ def test_resolve_vault_secret_by_name(self, transform, mock_vault):+ """Test resolving a vault secret by parameter name."""+ secret_value = "my-api-key-12345"+ mock_vault.get_secret.return_value = secret_value++ resolved = transform.resolve_params()++ # Should try to get by name "TEST_API_KEY"+ assert mock_vault.get_secret.called+ assert "TEST_API_KEY" in resolved+ assert resolved["TEST_API_KEY"] == secret_value++ def test_resolve_vault_secret_by_id(self, transform, mock_vault):+ """Test resolving a vault secret by vault ID."""+ secret_value = "my-api-key-12345"+ vault_id = str(uuid.uuid4())++ # Set params with a vault ID+ transform.params = {"TEST_API_KEY": vault_id}++ # First call (by ID) returns the secret+ mock_vault.get_secret.return_value = secret_value++ resolved = transform.resolve_params()++ # Should try to get by ID first+ mock_vault.get_secret.assert_called_with(vault_id)+ assert "TEST_API_KEY" in resolved+ assert resolved["TEST_API_KEY"] == secret_value++ def test_resolve_vault_secret_fallback_to_name(self, transform, mock_vault):+ """Test that if vault ID fails, it falls back to name lookup."""+ secret_value = "my-api-key-12345"+ vault_id = str(uuid.uuid4())++ # Set params with a vault ID+ transform.params = {"TEST_API_KEY": vault_id}++ # First call (by ID) returns None, second call (by name) returns the secret+ mock_vault.get_secret.side_effect = [None, secret_value]++ resolved = transform.resolve_params()++ # Should try both ID and name+ assert mock_vault.get_secret.call_count == 2+ assert "TEST_API_KEY" in resolved+ assert resolved["TEST_API_KEY"] == secret_value++ def test_resolve_vault_secret_not_found_required(self, transform, mock_vault):+ """Test that missing required vault secret logs error."""+ mock_vault.get_secret.return_value = None++ with patch("flowsint_core.core.transform_base.Logger") as mock_logger:+ resolved = transform.resolve_params()++ # Should log an error for missing required secret+ assert mock_logger.error.called+ error_message = mock_logger.error.call_args[0][1]["message"]+ assert "TEST_API_KEY" in error_message+ assert "missing" in error_message.lower()+ assert "Vault settings" in error_message++ # Should not be in resolved params+ assert "TEST_API_KEY" not in resolved++ def test_resolve_vault_secret_optional_with_default(self, transform, mock_vault):+ """Test that optional vault secret uses default if not found."""+ # Only return secret for TEST_API_KEY, not OPTIONAL_KEY+ mock_vault.get_secret.side_effect = lambda key: (+ "test-api-key" if key == "TEST_API_KEY" else None+ )++ resolved = transform.resolve_params()++ # Optional key should use default value+ assert "OPTIONAL_KEY" in resolved+ assert resolved["OPTIONAL_KEY"] == "default_value"++ def test_resolve_non_vault_param_from_params(self, transform):+ """Test that non-vault params are taken from params."""+ transform.params = {"NON_VAULT_PARAM": "custom_value"}++ resolved = transform.resolve_params()++ assert "NON_VAULT_PARAM" in resolved+ assert resolved["NON_VAULT_PARAM"] == "custom_value"++ def test_resolve_non_vault_param_uses_default(self, transform):+ """Test that non-vault params use default if not provided."""+ resolved = transform.resolve_params()++ assert "NON_VAULT_PARAM" in resolved+ assert resolved["NON_VAULT_PARAM"] == "test"++ def test_resolve_params_no_vault_instance(self, sketch_id):+ """Test that resolve_params works without a vault instance."""+ transform = MockTransform(+ sketch_id=sketch_id,+ scan_id="scan_123",+ vault=None, # No vault+ params={},+ )++ resolved = transform.resolve_params()++ # Should use defaults for optional params+ assert "OPTIONAL_KEY" in resolved+ assert resolved["OPTIONAL_KEY"] == "default_value"+ assert "NON_VAULT_PARAM" in resolved+ assert resolved["NON_VAULT_PARAM"] == "test"+++class TestGetSecret:+ """Tests for get_secret() method."""++ @pytest.mark.asyncio+ async def test_get_secret_found(self, transform, mock_vault):+ """Test get_secret when secret is in resolved params."""+ secret_value = "my-api-key-12345"+ mock_vault.get_secret.return_value = secret_value++ # Run async_init to resolve params+ await transform.async_init()++ # Get the secret+ result = transform.get_secret("TEST_API_KEY")++ assert result == secret_value++ @pytest.mark.asyncio+ async def test_get_secret_not_found_uses_default(self, transform, mock_vault):+ """Test get_secret returns default when secret not found."""+ mock_vault.get_secret.return_value = None++ # Run async_init to resolve params+ await transform.async_init()++ # Get the secret with default+ result = transform.get_secret("NONEXISTENT_KEY", "default")++ assert result == "default"++ @pytest.mark.asyncio+ async def test_get_secret_returns_none_when_not_found_no_default(+ self, transform, mock_vault+ ):+ """Test get_secret returns None when no default provided."""+ mock_vault.get_secret.return_value = None++ # Run async_init to resolve params+ await transform.async_init()++ # Get the secret without default+ result = transform.get_secret("NONEXISTENT_KEY")++ assert result is None+++class TestAsyncInit:+ """Tests for async_init() method."""++ @pytest.mark.asyncio+ async def test_async_init_calls_resolve_params(self, transform, mock_vault):+ """Test that async_init calls resolve_params."""+ secret_value = "my-api-key-12345"+ mock_vault.get_secret.return_value = secret_value++ # Run async_init+ await transform.async_init()++ # Params should be resolved and stored+ assert "TEST_API_KEY" in transform.params+ assert transform.params["TEST_API_KEY"] == secret_value++ @pytest.mark.asyncio+ async def test_async_init_always_runs_resolve_params(self, sketch_id, mock_vault):+ """Test that async_init runs resolve_params even with empty params."""+ transform = MockTransform(+ sketch_id=sketch_id,+ scan_id="scan_123",+ vault=mock_vault,+ params={}, # Empty params+ )++ secret_value = "my-api-key-12345"+ mock_vault.get_secret.return_value = secret_value++ # Run async_init+ await transform.async_init()++ # Should still resolve vault secrets by name+ assert mock_vault.get_secret.called+ assert "TEST_API_KEY" in transform.params++ @pytest.mark.asyncio+ async def test_async_init_pydantic_validation(self, transform, mock_vault):+ """Test that async_init validates params with Pydantic."""+ secret_value = "my-api-key-12345"+ mock_vault.get_secret.return_value = secret_value++ # Should not raise validation error+ await transform.async_init()++ # Params should be validated and stored+ assert isinstance(transform.params, dict)+ assert "TEST_API_KEY" in transform.params+++class TestTransformExecuteWithVault:+ """Tests for execute() method with vault integration."""++ @pytest.mark.asyncio+ async def test_execute_resolves_vault_secrets(self, transform, mock_vault):+ """Test that execute resolves vault secrets before scan."""+ secret_value = "my-api-key-12345"+ mock_vault.get_secret.return_value = secret_value++ # Execute the transform+ result = await transform.execute(["test"])++ # Vault secret should be resolved+ assert mock_vault.get_secret.called+ assert "TEST_API_KEY" in transform.params+ assert transform.params["TEST_API_KEY"] == secret_value++ @pytest.mark.asyncio+ async def test_execute_uses_resolved_secrets_in_scan(self, transform, mock_vault):+ """Test that scan can access resolved secrets."""+ secret_value = "my-api-key-12345"+ mock_vault.get_secret.return_value = secret_value++ # Create a transform that uses get_secret in scan+ class SecretUsingTransform(MockTransform):+ async def scan(self, data: List[str]) -> List[str]:+ api_key = self.get_secret("TEST_API_KEY")+ return [f"{item}_{api_key}" for item in data]++ transform = SecretUsingTransform(+ sketch_id=str(uuid.uuid4()),+ scan_id="scan_123",+ vault=mock_vault,+ params={},+ )++ # Execute+ result = await transform.execute(["test"])++ # Result should contain the secret value+ assert result == [f"test_{secret_value}"]diff --git a/flowsint-core/tests/test_vault.py b/flowsint-core/tests/test_vault.pynew file mode 100644index 00000000..536e66bd--- /dev/null+++ b/flowsint-core/tests/test_vault.py@@ -0,0 +1,234 @@+"""Tests for the Vault class and secret management."""+import pytest+import uuid+import os+from unittest.mock import Mock, MagicMock+from flowsint_core.core.vault import Vault+from flowsint_core.core.models import Key+++def mock_db():+ """Create a mock database session."""+ return Mock()+++def owner_id():+ """Create a test owner ID."""+ return uuid.uuid4()+++def vault(mock_db, owner_id):+ """Create a Vault instance with mocked database."""+ return Vault(db=mock_db, owner_id=owner_id)++[email protected](autouse=True)+def mock_master_key(monkeypatch):+ """Mock the master key environment variable."""+ # Use a base64-encoded 32-byte key+ test_key = "base64:qnHTmwYb+uoygIw9MsRMY22vS5YPchY+QOi/E79GAvM="+ monkeypatch.setenv("MASTER_VAULT_KEY_V1", test_key)+++class TestVaultInitialization:+ """Tests for Vault initialization."""++ def test_vault_requires_owner_id(self, mock_db):+ """Test that Vault requires an owner_id."""+ with pytest.raises(ValueError, match="owner_id is required"):+ Vault(db=mock_db, owner_id=None)++ def test_vault_initialization_success(self, mock_db, owner_id):+ """Test successful Vault initialization."""+ vault = Vault(db=mock_db, owner_id=owner_id)+ assert vault.db == mock_db+ assert vault.owner_id == str(owner_id)+ assert vault.version == "V1"+++class TestVaultSetSecret:+ """Tests for Vault.set_secret() method."""++ def test_set_secret_creates_key(self, vault, mock_db):+ """Test that set_secret creates a new Key in the database."""+ vault_ref = "TEST_API_KEY"+ plain_key = "my-secret-api-key-12345"++ vault.set_secret(vault_ref, plain_key)++ # Verify that db.add, db.commit, and db.refresh were called+ assert mock_db.add.called+ assert mock_db.commit.called+ assert mock_db.refresh.called++ # Get the Key object that was added+ added_key = mock_db.add.call_args[0][0]+ assert isinstance(added_key, Key)+ assert added_key.name == vault_ref+ assert added_key.owner_id == vault.owner_id+ assert added_key.key_version == "V1"+ assert added_key.iv is not None+ assert added_key.salt is not None+ assert added_key.ciphertext is not None++ def test_set_secret_encrypts_data(self, vault, mock_db):+ """Test that set_secret properly encrypts the secret."""+ vault_ref = "TEST_API_KEY"+ plain_key = "my-secret-api-key-12345"++ vault.set_secret(vault_ref, plain_key)++ added_key = mock_db.add.call_args[0][0]++ # Ciphertext should not contain the plaintext+ assert plain_key.encode() not in added_key.ciphertext+ # IV and salt should be different lengths (12 and 16 bytes)+ assert len(added_key.iv) == 12+ assert len(added_key.salt) == 16+++class TestVaultGetSecret:+ """Tests for Vault.get_secret() method."""++ def test_get_secret_by_name_found(self, vault, mock_db, owner_id):+ """Test getting a secret by name when it exists."""+ vault_ref = "TEST_API_KEY"+ plain_key = "my-secret-api-key-12345"++ # Set a secret first to get encrypted data+ real_vault = Vault(db=MagicMock(), owner_id=owner_id)+ encrypted_data = real_vault._encrypt_key(plain_key)++ # Create a mock Key object+ mock_key = Mock()+ mock_key.name = vault_ref+ mock_key.id = uuid.uuid4()+ mock_key.owner_id = str(owner_id)+ mock_key.salt = encrypted_data["salt"]+ mock_key.iv = encrypted_data["iv"]+ mock_key.ciphertext = encrypted_data["ciphertext"]++ # Mock the database query+ mock_result = Mock()+ mock_result.scalars().first.return_value = mock_key+ mock_db.execute.return_value = mock_result++ # Get the secret+ result = vault.get_secret(vault_ref)++ assert result == plain_key+ assert mock_db.execute.called++ def test_get_secret_by_uuid_found(self, vault, mock_db, owner_id):+ """Test getting a secret by UUID when it exists."""+ key_id = uuid.uuid4()+ plain_key = "my-secret-api-key-12345"++ # Set a secret first to get encrypted data+ real_vault = Vault(db=MagicMock(), owner_id=owner_id)+ encrypted_data = real_vault._encrypt_key(plain_key)++ # Create a mock Key object+ mock_key = Mock()+ mock_key.name = "TEST_API_KEY"+ mock_key.id = key_id+ mock_key.owner_id = str(owner_id)+ mock_key.salt = encrypted_data["salt"]+ mock_key.iv = encrypted_data["iv"]+ mock_key.ciphertext = encrypted_data["ciphertext"]++ # Mock the database query+ mock_result = Mock()+ mock_result.scalars().first.return_value = mock_key+ mock_db.execute.return_value = mock_result++ # Get the secret by UUID+ result = vault.get_secret(str(key_id))++ assert result == plain_key+ assert mock_db.execute.called++ def test_get_secret_not_found(self, vault, mock_db):+ """Test getting a secret that doesn't exist."""+ vault_ref = "NONEXISTENT_KEY"++ # Mock the database query to return None+ mock_result = Mock()+ mock_result.scalars().first.return_value = None+ mock_db.execute.return_value = mock_result++ result = vault.get_secret(vault_ref)++ assert result is None++ def test_get_secret_wrong_owner(self, vault, mock_db):+ """Test that secrets from other owners cannot be accessed."""+ vault_ref = "TEST_API_KEY"++ # Mock the database query to return None (no key found for this owner)+ mock_result = Mock()+ mock_result.scalars().first.return_value = None+ mock_db.execute.return_value = mock_result++ result = vault.get_secret(vault_ref)++ assert result is None+++class TestVaultEncryptionDecryption:+ """Tests for encryption and decryption methods."""++ def test_encrypt_decrypt_roundtrip(self, vault):+ """Test that encryption and decryption work correctly."""+ plaintext = "my-secret-api-key-12345"++ # Encrypt+ encrypted_data = vault._encrypt_key(plaintext)++ assert "ciphertext" in encrypted_data+ assert "iv" in encrypted_data+ assert "salt" in encrypted_data+ assert plaintext.encode() not in encrypted_data["ciphertext"]++ # Decrypt+ decrypted = vault._decrypt_key(encrypted_data)++ assert decrypted == plaintext++ def test_different_salts_produce_different_ciphertexts(self, vault):+ """Test that the same plaintext with different salts produces different ciphertexts."""+ plaintext = "my-secret-api-key-12345"++ encrypted1 = vault._encrypt_key(plaintext)+ encrypted2 = vault._encrypt_key(plaintext)++ # Different salts and IVs+ assert encrypted1["salt"] != encrypted2["salt"]+ assert encrypted1["iv"] != encrypted2["iv"]+ # Different ciphertexts+ assert encrypted1["ciphertext"] != encrypted2["ciphertext"]++ def test_master_key_derivation(self, vault):+ """Test that master key is properly derived."""+ master_key = vault._get_master_key()++ assert isinstance(master_key, bytes)+ assert len(master_key) == 32 # 256 bits++ def test_invalid_master_key_length(self, vault, monkeypatch):+ """Test that invalid master key length raises error."""+ # Set an invalid master key (wrong length)+ monkeypatch.setenv("MASTER_VAULT_KEY_V1", "base64:invalid")++ with pytest.raises(ValueError, match="Master key must be 32 bytes"):+ vault._get_master_key()++ def test_missing_master_key(self, vault, monkeypatch):+ """Test that missing master key raises error."""+ monkeypatch.delenv("MASTER_VAULT_KEY_V1", raising=False)++ with pytest.raises(ValueError, match="Missing master key"):+ vault._get_master_key()