Skip to content

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.py
index 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 resolution
try:
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 values
diff --git a/flowsint-core/src/flowsint_core/core/vault.py b/flowsint-core/src/flowsint_core/core/vault.py
index 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_key
def 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 None
diff --git a/flowsint-core/tests/__init__.py b/flowsint-core/tests/__init__.py
new file mode 100644
index 00000000..00c7cf48
--- /dev/null
+++ b/flowsint-core/tests/__init__.py
@@ -0,0 +1 @@
+# Tests for flowsint-core
diff --git a/flowsint-core/tests/conftest.py b/flowsint-core/tests/conftest.py
new file mode 100644
index 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 mock
diff --git a/flowsint-core/tests/test_transform_vault_integration.py b/flowsint-core/tests/test_transform_vault_integration.py
new file mode 100644
index 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.py
new file mode 100644
index 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()