Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
"""Unit tests for the Vaults service final grant-id/tag model."""
from __future__ import annotations
import concurrent.futures
import json
import threading
from datetime import datetime, timedelta, timezone
import pytest
from sqlalchemy import event, select
from sqlalchemy.exc import IntegrityError
from storage import vault_service as vs, vault_webauthn
from storage.db import create_sqlite_engine
from storage.models import (
agent_sessions,
metadata,
state_meta,
vault_audit,
vault_auth_factors,
vault_grants,
vault_requests,
vault_secrets,
)
from storage import message_deliveries
from storage.vault_crypto import Sealed
from tests.vault_webauthn_helpers import WebAuthnTestCredential
@pytest.fixture
def vault(tmp_path):
vs.GRANT_RUNTIME_CACHE.clear()
engine = create_sqlite_engine(tmp_path / "vault_test.sqlite")
metadata.create_all(engine)
return engine
def _sealed(suffix: str = "1") -> Sealed:
return Sealed(ciphertext=f"ct-{suffix}", nonce=f"n-{suffix}", wrap_meta=f"wm-{suffix}")
def _create(engine, **kw):
with engine.begin() as conn:
return vs.create_secret(conn, sealed=_sealed(kw.get("name", "x").lower()), **kw)
def _establish_protected_secret(conn, name: str, credential: WebAuthnTestCredential | None = None) -> tuple[WebAuthnTestCredential, dict]:
credential = credential or WebAuthnTestCredential()
options = vs.create_webauthn_registration_options(
conn,
rp_id=credential.rp_id,
origin=credential.origin,
)
vs.create_secret(
conn,
name=name,
protection="protected",
sealed=_sealed(name.lower()),
establishing_vmk=True,
authz_factor_registration=credential.registration_payload(
challenge_id=options["challenge_id"],
challenge_b64=options["webauthn"]["challenge"],
),
authz_factor_origin=credential.origin,
)
factor = conn.execute(
select(vault_auth_factors).where(vault_auth_factors.c.credential_id == credential.credential_id_b64)
).mappings().one()
return credential, dict(factor)
def _grant_from_request(
conn,
request: dict,
*,
cache_ready: bool = True,
ttl_seconds: int | None = None,
expires_at: str | None = None,
) -> dict:
option = request["card"]["grant_options"][0]
return vs.create_grant(
conn,
member_names=option["member_snapshot"],
source_selector=option["source_selector"],
purpose=option["purpose"],
request_id=request["id"],
ttl_seconds=ttl_seconds,
expires_at=expires_at,
cache_ready=cache_ready,
)
def test_secret_metadata_is_global_name_plus_tags(vault):
meta = _create(vault, name="OPENAI_API_KEY", description="key", tags=["prod", "skill:deploy"])
assert meta["name"] == "OPENAI_API_KEY"
assert meta["tags"] == ["prod", "skill:deploy"]
assert "group" not in meta
assert "preview" not in meta
assert meta["default_field"] == "value"
assert meta["fields"] == ["value"]
assert meta["last_used_at"] is None
assert meta["policy"] == {}
with vault.connect() as conn:
row = conn.execute(select(vault_secrets).where(vault_secrets.c.name == "OPENAI_API_KEY")).mappings().one()
assert row["ciphertext"] == "ct-openai_api_key"
assert json.loads(row["public_meta"]) == {"description": "key"}
assert vs.list_secrets(conn, tag="prod")[0]["name"] == "OPENAI_API_KEY"
def test_secret_names_preserve_case_and_reject_case_only_duplicates(vault):
meta = _create(vault, name="openAiKey", description="key")
assert meta["name"] == "openAiKey"
with vault.connect() as conn:
assert vs.get_secret_meta(conn, "openAiKey")["name"] == "openAiKey"
with pytest.raises(vs.SecretNotFoundError):
vs.get_secret_meta(conn, "OPENAIKEY")
with pytest.raises(vs.SecretNameCaseConflictError) as exc:
_create(vault, name="OpenAIKey")
assert exc.value.existing_name == "openAiKey"
def test_secret_name_case_uniqueness_is_enforced_by_database(vault):
_create(vault, name="openAiKey")
with vault.begin() as conn:
with pytest.raises(IntegrityError):
conn.execute(
vault_secrets.insert().values(
id="vlt_case_race",
name="OpenAIKey",
kind="static",
protection="standard",
source="manual",
ciphertext="ct",
nonce="nonce",
wrap_meta="wrap",
use_count=0,
created_at="now",
updated_at="now",
)
)
def test_provision_request_rejects_case_only_duplicate_secret(vault):
_create(vault, name="OpenAIKey")
with vault.begin() as conn:
fulfilled = vs.create_provision_request(conn, "OpenAIKey")
with pytest.raises(vs.SecretNameCaseConflictError) as exc:
vs.create_provision_request(conn, "openAIKey")
assert fulfilled["status"] == "fulfilled"
assert exc.value.existing_name == "OpenAIKey"
def test_provision_request_uses_active_turn_as_plain_claude_anchor(vault):
now = "2026-08-08T00:00:00+00:00"
session_id = "ses_claude_anchor"
delivery_id = "del_claude_anchor"
turn_id = "turn_claude_anchor"
with vault.begin() as conn:
conn.execute(
agent_sessions.insert().values(
id=session_id,
scope_id=None,
agent_id=None,
agent_name="claude",
agent_backend="claude",
agent_variant="claude",
model=None,
reasoning_effort=None,
session_anchor=session_id,
workdir="/tmp",
native_session_id="",
title=None,
status="active",
visibility="foreground",
pinned=0,
agent_status="busy",
composer_draft_text=None,
composer_draft_updated_at=None,
metadata_json="{}",
created_at=now,
updated_at=now,
last_active_at=now,
)
)
delivery = message_deliveries.insert_delivery(
conn,
delivery_id=delivery_id,
session_id=session_id,
priority="p0",
state="reserved",
snapshot=message_deliveries.message_snapshot(
scope_id=None,
session_id=session_id,
platform="avibe",
author="user",
source="user",
text="request a key",
),
dispatch_text="request a key",
now=now,
)
message_deliveries.claim_start_batch(
conn,
turn_id=turn_id,
session_id=session_id,
backend="claude",
deliveries=[delivery],
dispatch_text="request a key",
)
request = vs.create_provision_request(
conn,
"CLAUDE_KEY",
requester={"source": "agent-cli", "session_id": session_id},
)
assert request["status"] == "pending"
row = request
assert row["id"]
with vault.connect() as conn:
stored = conn.execute(select(vault_requests).where(vault_requests.c.id == row["id"])).mappings().one()
assert stored["message_id"] is None
assert json.loads(stored["requester"])["turn_id"] == turn_id
def test_provision_request_does_not_store_derived_delivery_as_reply_anchor(vault, monkeypatch):
monkeypatch.setattr(
vs,
"_active_session_turn_anchor",
lambda conn, session_id: ("msg_initial_delivery", "turn_active"),
)
with vault.begin() as conn:
request = vs.create_provision_request(
conn,
"DERIVED_KEY",
requester={"source": "agent-cli", "session_id": "ses_active"},
)
stored = conn.execute(
select(vault_requests).where(vault_requests.c.id == request["id"])
).mappings().one()
assert stored["message_id"] is None
assert json.loads(stored["requester"])["turn_id"] == "turn_active"
def test_provision_request_rejects_case_only_duplicate_pending_request(vault):
with vault.begin() as conn:
pending = vs.create_provision_request(conn, "openAiKey")
with pytest.raises(vs.SecretNameCaseConflictError) as exc:
vs.create_provision_request(conn, "OpenAIKey")
rows = (
conn.execute(select(vault_requests).where(vault_requests.c.request_type == "provision"))
.mappings()
.all()
)
assert pending["status"] == "pending"
assert exc.value.existing_name == "openAiKey"
assert [row["secret_name"] for row in rows] == ["openAiKey"]
def test_provision_request_case_guard_is_database_enforced(vault):
with vault.begin() as conn:
conn.execute(
vault_requests.insert().values(
id="vrq_a",
request_type="provision",
secret_name="openAiKey",
status="pending",
delivery="{}",
created_at="now",
)
)
conn.execute(
vault_requests.insert().values(
id="vrq_exact_duplicate",
request_type="provision",
secret_name="openAiKey",
status="pending",
delivery="{}",
created_at="now",
)
)
with pytest.raises(IntegrityError):
conn.execute(
vault_requests.insert().values(
id="vrq_b",
request_type="provision",
secret_name="OpenAIKey",
status="pending",
delivery="{}",
created_at="now",
)
)
def test_create_secret_rejects_case_only_duplicate_pending_request(vault):
with vault.begin() as conn:
pending = vs.create_provision_request(conn, "openAiKey")
with pytest.raises(vs.SecretNameCaseConflictError) as exc:
vs.create_secret(conn, name="OpenAIKey", sealed=_sealed("case"))
secrets = conn.execute(select(vault_secrets.c.name)).scalars().all()
requests = (
conn.execute(select(vault_requests.c.secret_name, vault_requests.c.status))
.mappings()
.all()
)
assert pending["status"] == "pending"
assert exc.value.existing_name == "openAiKey"
assert secrets == []
assert [dict(row) for row in requests] == [{"secret_name": "openAiKey", "status": "pending"}]
def test_skill_links_are_stored_as_skill_tags(vault):
_create(vault, name="GH_PAT", tags=["github"])
with vault.begin() as conn:
vs.link_secret_to_skills(conn, "GH_PAT", ["github-release", "github-release"])
meta = vs.get_secret_meta(conn, "GH_PAT")
assert meta["tags"] == ["github", "skill:github-release"]
@pytest.mark.parametrize(
"value",
["", "value ", " value", "Value", "value-name", "value.name", "a" * 65, None],
)
def test_validate_field_name_is_strict(value):
with pytest.raises(vs.InvalidFieldNameError):
vs.validate_field_name(value)
def test_provision_field_spec_contains_only_valid_distinct_labels():
assert vs.normalize_provision_spec({"fields": ["username", "password"]}) == {
"fields": ["username", "password"], "default_field": "username",
}
assert vs.normalize_provision_spec({
"fields": ["username", "password"], "default_field": "password",
})["default_field"] == "password"
for invalid in [
{"default_field": "password"},
{"fields": []},
{"fields": ["password", "password"]},
{"fields": ["username"], "default_field": "password"},
{"fields": ["password "]},
{"fields": [{"name": "password", "value": "plaintext"}]},
]:
with pytest.raises(vs.VaultServiceError):
vs.normalize_provision_spec(invalid)
def test_fields_use_canonical_records_and_default_label_fallback(vault):
_create(
vault,
name="lowerSecret",
default_field="password",
fields=[{"name": "username", "sealed": _sealed("username")}],
)
with vault.begin() as conn:
meta = vs.get_secret_meta(conn, "lowerSecret")
default_ref = vs.get_secret_record_meta(conn, "lowerSecret.password")
extra_ref = vs.get_secret_record_meta(conn, "lowerSecret.username")
assert meta["default_field"] == "password"
assert meta["fields"] == ["password", "username"]
assert vs.secret_record_names(meta) == ["lowerSecret", "lowerSecret.username"]
assert default_ref["record_name"] == "lowerSecret"
assert default_ref["field"] == "password"
assert extra_ref["record_name"] == "lowerSecret.username"
assert all(key not in json.dumps(meta) for key in ("ciphertext", "nonce", "wrap_meta"))
assert vs.get_envelope(conn, "lowerSecret") == _sealed("lowersecret")
assert vs.get_envelope(conn, "lowerSecret.username") == _sealed("username")
conn.execute(
vault_secrets.update()
.where(vault_secrets.c.name == "lowerSecret")
.values(public_meta=json.dumps({"default_field": "INVALID"}))
)
assert vs.get_secret_meta(conn, "lowerSecret")["default_field"] == "value"
@pytest.mark.parametrize("protection", ["standard", "protected"])
def test_default_rename_is_metadata_only_and_collision_safe(vault, protection):
_create(
vault,
name="LOGIN",
protection=protection,
default_field="password",
fields=[{"name": "username", "sealed": _sealed("username")}],
policy={"always_ask": True},
)
with vault.begin() as conn:
request = vs.create_access_request(conn, "LOGIN")
grant = _grant_from_request(conn, request)
pending = vs.create_access_request(conn, "LOGIN")
pending_versions = pending["card"]["grant_options"][0]["member_versions"]
before = vs.get_secret_meta(conn, "LOGIN")
get_envelope = vs.get_protected_envelope if protection == "protected" else vs.get_envelope
default_envelope = get_envelope(conn, "LOGIN")
renamed = vs.update_secret_metadata(conn, "LOGIN", default_field="credential")
after = vs.get_secret_meta(conn, "LOGIN")
assert renamed["default_field"] == "credential"
assert renamed["fields"] == ["credential", "username"]
assert renamed["policy"] == {"always_ask": True}
assert after["updated_at"] == before["updated_at"]
hydrated = vs.get_request(conn, pending["id"])
assert hydrated["status"] == "pending"
assert hydrated["card"]["grant_options"][0]["member_versions"] == pending_versions
assert hydrated["card"]["grant_options"][0]["member_fields"] == [
{"name": "LOGIN", "kind": "static", "default_field": "credential", "fields": ["credential", "username"]}
]
# The persisted authorization snapshot is unchanged; only its UI projection is current.
stored = conn.execute(select(vault_requests.c.delivery).where(vault_requests.c.id == pending["id"])).scalar_one()
assert json.loads(stored)["card"]["grant_options"][0]["member_fields"][0]["default_field"] == "password"
assert _grant_from_request(conn, pending)["status"] == "active"
assert vs.get_grant_created_by_request(conn, grant["request_id"])["status"] == "active"
assert get_envelope(conn, "LOGIN") == default_envelope
with pytest.raises(vs.RecordMismatchError):
vs.update_secret_field(
conn, "LOGIN", "password", _sealed("stale-default"), record="LOGIN",
expected_updated_at=before["updated_at"],
)
with pytest.raises(vs.FieldExistsError):
vs.update_secret_metadata(conn, "LOGIN", default_field="username")
assert get_envelope(conn, "LOGIN") == default_envelope
@pytest.mark.parametrize("malformed", ["invalid_json", "non_array", "bad_entry", "duplicate", "default_collision"])
@pytest.mark.parametrize("protection", ["standard", "protected"])
def test_corrupt_fields_disable_mutations_without_losing_bytes(vault, caplog, malformed, protection):
_create(vault, name="LOGIN", protection=protection, fields=[{"name": "username", "sealed": _sealed("username")}])
with vault.begin() as conn:
stored = conn.execute(select(vault_secrets.c.fields).where(vault_secrets.c.name == "LOGIN")).scalar_one()
valid = json.loads(stored)
damaged = {
"invalid_json": '{"unparseable":',
"non_array": '{"name":"username"}',
"bad_entry": json.dumps([*valid, {"name": "password", "ciphertext": "must-not-disappear"}]),
"duplicate": json.dumps([*valid, valid[0]]),
"default_collision": json.dumps([*valid, {**valid[0], "name": "value"}]),
}[malformed]
conn.execute(vault_secrets.update().where(vault_secrets.c.name == "LOGIN").values(fields=damaged))
caplog.clear()
meta = vs.get_secret_meta(conn, "LOGIN")
assert meta["fields"] == ["value"]
assert meta["fields_state"] == "corrupt"
assert vs.list_secrets(conn)[0]["fields_state"] == "corrupt"
get_envelope = vs.get_protected_record_envelope if protection == "protected" else vs.get_envelope
assert get_envelope(conn, "LOGIN") == _sealed("login")
assert get_envelope(conn, "LOGIN.value") == _sealed("login")
assert sum("corrupt fields" in entry.message.lower() for entry in caplog.records) == 1
assert "must-not-disappear" not in caplog.text
before = dict(conn.execute(select(vault_secrets).where(vault_secrets.c.name == "LOGIN")).mappings().one())
with pytest.raises(vs.FieldsCorruptError):
get_envelope(conn, "LOGIN.username")
operations = [
lambda: vs.update_secret_field(conn, "LOGIN", "totp", _sealed("new"), record="LOGIN.totp"),
lambda: vs.update_secret_field(conn, "LOGIN", "username", _sealed("new"), record="LOGIN.username"),
lambda: vs.update_secret_field(conn, "LOGIN", "value", _sealed("new"), record="LOGIN"),
lambda: vs.remove_secret_field(conn, "LOGIN", "username"),
lambda: vs.update_secret_metadata(conn, "LOGIN", default_field="password"),
lambda: vs.rotate_secret(conn, "LOGIN", _sealed("new")),
]
for operation in operations:
with pytest.raises(vs.FieldsCorruptError):
operation()
after = dict(conn.execute(select(vault_secrets).where(vault_secrets.c.name == "LOGIN")).mappings().one())
assert after == before
assert after["fields"] == damaged
assert not list(conn.execute(select(vault_audit.c.id).where(vault_audit.c.event == "updated")))
def test_ordinary_metadata_preserves_approval_and_policy_edits_expire_it(vault):
_create(
vault, name="LOGIN", protection="protected", description="old",
policy={"always_ask": True, "allowed_hosts": ["example.com"]},
)
with vault.begin() as conn:
before = vs.get_secret_meta(conn, "LOGIN")
request = vs.create_access_request(conn, "LOGIN")
edited = vs.update_secret_metadata(conn, "LOGIN", description="new", tags=["new"])
assert edited["updated_at"] == before["updated_at"]
hydrated = vs.get_request(conn, request["id"])
assert hydrated["card"]["grant_options"][0]["unlock_material"][0]["name"] == "LOGIN"
grant = _grant_from_request(conn, request)
scopes = []
updated = vs.update_secret_metadata(
conn, "LOGIN", policy={"allowed_hosts": ["new.example.com"]}, release_scopes=scopes,
)
assert updated["policy"] == {"always_ask": True, "allowed_hosts": ["new.example.com"]}
assert vs.get_grant_created_by_request(conn, grant["request_id"])["status"] == "expired"
assert scopes == [{"grant_id": grant["id"]}]
@pytest.mark.parametrize("operation", ["add", "replace_default", "replace_extra", "remove"])
def test_field_write_cas_without_explicit_version_has_no_conflict_side_effects(vault, monkeypatch, operation):
_create(
vault, name="LOGIN", protection="protected",
fields=[{"name": "username", "sealed": _sealed("username")}],
)
with vault.begin() as conn:
grant = _grant_from_request(conn, vs.create_access_request(conn, "LOGIN"))
pending = vs.create_access_request(conn, "LOGIN")
require_management = vs._require_secret_resource_management
raced = False
def write_after_snapshot(conn, row, context):
nonlocal raced
snapshot = require_management(conn, row, context)
if not raced:
raced = True
with vault.begin() as winner:
vs.update_secret_field(winner, "LOGIN", "other", _sealed("winner"), record="LOGIN.other")
return snapshot
monkeypatch.setattr(vs, "_require_secret_resource_management", write_after_snapshot)
release_scopes = []
with vault.begin() as conn:
with pytest.raises(vs.SecretConflictError):
if operation == "remove":
vs.remove_secret_field(conn, "LOGIN", "username", release_scopes=release_scopes)
else:
field = {"add": "totp", "replace_default": "value", "replace_extra": "username"}[operation]
record = "LOGIN" if field == "value" else f"LOGIN.{field}"
vs.update_secret_field(conn, "LOGIN", field, _sealed("loser"), record=record, release_scopes=release_scopes)
assert vs.get_secret_meta(conn, "LOGIN")["fields"] == ["value", "username", "other"]
assert vs.get_protected_envelope(conn, "LOGIN") == _sealed("login")
assert vs.get_protected_envelope(conn, "LOGIN.username") == _sealed("username")
assert vs.get_protected_envelope(conn, "LOGIN.other") == _sealed("winner")
# Only the winning write changed authorization and produced a field audit.
assert vs.get_grant_created_by_request(conn, grant["request_id"])["status"] == "expired"
assert vs.get_request(conn, pending["id"])["status"] == "expired"
assert vs.GRANT_RUNTIME_CACHE.covered_names(grant["id"]) == []
updates = list(conn.execute(select(vault_audit.c.delivery).where(vault_audit.c.event == "updated")).scalars())
assert [json.loads(payload)["field"] for payload in updates] == ["other"]
assert release_scopes == []
@pytest.mark.parametrize("field,record", [("value", "LOGIN"), ("password", "LOGIN.password")])
def test_protected_field_write_rejects_rename_after_record_resolution(vault, monkeypatch, field, record):
_create(vault, name="LOGIN", protection="protected")
with vault.begin() as conn:
grant = _grant_from_request(conn, vs.create_access_request(conn, "LOGIN"))
pending = vs.create_access_request(conn, "LOGIN")
before = vs.get_secret_meta(conn, "LOGIN")
original = vs._require_secret_resource_management
raced = False
def rename_after_snapshot(conn, row, context):
nonlocal raced
snapshot = original(conn, row, context)
if not raced:
raced = True
with vault.begin() as winner:
vs.update_secret_metadata(winner, "LOGIN", default_field="password")
return snapshot
monkeypatch.setattr(vs, "_require_secret_resource_management", rename_after_snapshot)
release_scopes = []
with vault.begin() as conn:
with pytest.raises(vs.RecordMismatchError):
vs.update_secret_field(conn, "LOGIN", field, _sealed("loser"), record=record, release_scopes=release_scopes)
assert vs.get_protected_envelope(conn, "LOGIN") == _sealed("login")
after = vs.get_secret_meta(conn, "LOGIN")
assert after["updated_at"] == before["updated_at"]
assert after["fields"] == ["password"]
assert vs.get_grant_created_by_request(conn, grant["request_id"])["status"] == "active"
assert vs.get_request(conn, pending["id"])["status"] == "pending"
assert release_scopes == []
@pytest.mark.parametrize("operation", ["rename", "pin", "rotate"])
def test_metadata_writers_do_not_overwrite_a_concurrent_description(vault, monkeypatch, operation):
_create(vault, name="LOGIN", description="old")
original = vs._require_secret_resource_management
raced = False
def edit_after_snapshot(conn, row, context):
nonlocal raced
snapshot = original(conn, row, context)
if not raced:
raced = True
with vault.begin() as winner:
vs.update_secret_metadata(winner, "LOGIN", description="concurrent")
return snapshot
monkeypatch.setattr(vs, "_require_secret_resource_management", edit_after_snapshot)
with vault.begin() as conn:
with pytest.raises(vs.SecretConflictError):
if operation == "rename":
vs.update_secret_metadata(conn, "LOGIN", default_field="password")
elif operation == "pin":
vs.store_pubkey_pin(conn, "LOGIN", {"public_key": "public", "fingerprint": "fingerprint"})
else:
vs.rotate_secret(conn, "LOGIN", _sealed("loser"))
assert vs.get_secret_meta(conn, "LOGIN")["description"] == "concurrent"
assert vs.get_envelope(conn, "LOGIN") == _sealed("login")
def test_field_writes_replace_add_remove_with_versioned_cas(vault):
_create(vault, name="LOGIN")
with vault.begin() as conn:
original = vs.get_secret_meta(conn, "LOGIN")
added = vs.update_secret_field(
conn,
"LOGIN",
"username",
_sealed("username"),
record="LOGIN.username",
expected_updated_at=original["updated_at"],
)
replaced = vs.update_secret_field(
conn,
"LOGIN",
"value",
_sealed("replacement"),
record="LOGIN",
expected_updated_at=added["updated_at"],
)
assert replaced["updated_at"] > added["updated_at"]
assert vs.get_envelope(conn, "LOGIN") == _sealed("replacement")
with pytest.raises(vs.SecretConflictError):
vs.update_secret_field(
conn,
"LOGIN",
"username",
_sealed("stale"),
record="LOGIN.username",
expected_updated_at=original["updated_at"],
)
assert vs.get_secret_meta(conn, "LOGIN")["fields"] == ["value", "username"]
removed = vs.remove_secret_field(
conn,
"LOGIN",
"username",
expected_updated_at=replaced["updated_at"],
)
assert removed["fields"] == ["value"]
assert removed["updated_at"] > replaced["updated_at"]
with pytest.raises(vs.SecretConflictError):
vs.remove_secret_field(
conn,
"LOGIN",
"username",
expected_updated_at=replaced["updated_at"],
)
def test_field_limits_duplicates_and_version_monotonicity(vault):
with vault.begin() as conn:
with pytest.raises(vs.VaultServiceError, match="fields must be an array"):
vs.create_secret(conn, name="INVALID", sealed=_sealed(), fields={})
with pytest.raises(vs.FieldsNotSupportedError):
vs.create_secret(
conn, name="INVALID", sealed=_sealed(), kind="keypair",
fields=[{"name": "username", "sealed": _sealed()}],
)
for names in [["password"], ["username", "username"]]:
with pytest.raises(vs.FieldExistsError):
vs.create_secret(
conn, name="INVALID", sealed=_sealed(), default_field="password",
fields=[{"name": name, "sealed": _sealed()} for name in names],
)
with pytest.raises(vs.TooManyFieldsError):
vs.create_secret(
conn, name="INVALID", sealed=_sealed(),
fields=[{"name": f"field{i}", "sealed": _sealed()} for i in range(32)],
)
vs.create_secret(
conn, name="LOGIN", sealed=_sealed(),
fields=[{"name": f"field{i}", "sealed": _sealed()} for i in range(31)],
)
with pytest.raises(vs.TooManyFieldsError):
vs.update_secret_field(conn, "LOGIN", "overflow", _sealed(), record="LOGIN.overflow")
with pytest.raises(vs.InvalidRequestError, match="default field"):
vs.remove_secret_field(conn, "LOGIN", "value")
with pytest.raises(vs.FieldNotFoundError, match="fields: value, field0"):
vs.get_envelope(conn, "LOGIN.unknown")
# A persisted future timestamp models a clock that moved backwards.
future = "2100-01-01T00:00:00+00:00"
conn.execute(vault_secrets.update().where(vault_secrets.c.name == "LOGIN").values(updated_at=future))
replaced = vs.update_secret_field(conn, "LOGIN", "field0", _sealed("replacement"), record="LOGIN.field0")
assert replaced["updated_at"] == "2100-01-01T00:00:00.000001+00:00"
removed = vs.remove_secret_field(conn, "LOGIN", "field0")
assert removed["updated_at"] == "2100-01-01T00:00:00.000002+00:00"
assert vs.get_envelope(conn, "LOGIN.field1") == _sealed()
def test_keypair_field_refs_and_mutations_are_rejected(vault):
_create(vault, name="SIGNING_KEY", kind="keypair", signer_kind="local")
with vault.begin() as conn:
with pytest.raises(vs.FieldsNotSupportedError):
vs.get_secret_record_meta(conn, "SIGNING_KEY.value")
with pytest.raises(vs.FieldsNotSupportedError):
vs.update_secret_field(conn, "SIGNING_KEY", "value", _sealed("replacement"), record="SIGNING_KEY")
with pytest.raises(vs.FieldsNotSupportedError):
vs.remove_secret_field(conn, "SIGNING_KEY", "value")
def test_selector_records_preserve_secret_case_and_reject_empty_alias(vault):
_create(
vault,
name="lowerSecret",
protection="protected",
tags=["deploy"],
fields=[{"name": "username", "sealed": _sealed("username")}],
)
with vault.begin() as conn:
expanded = vs.expand_value_delivery_selector(conn, env=["lowerSecret.username"])
assert expanded["secrets"] == [
{
"name": "lowerSecret",
"field": "username",
"record": "lowerSecret.username",
"env": "lowerSecret_USERNAME",
"kind": "static",
"protection": "protected",
}
]
tagged = vs.expand_value_delivery_selector(conn, tags=["deploy"])
assert [item["env"] for item in tagged["secrets"]] == [
"lowerSecret",
"lowerSecret_USERNAME",
]
with pytest.raises(vs.InvalidRequestError):
vs.expand_value_delivery_selector(conn, env=["=lowerSecret"])
default_ref = vs.expand_value_delivery_selector(conn, env=["lowerSecret.value"])
assert default_ref["secrets"][0]["record"] == "lowerSecret"
assert default_ref["secrets"][0]["env"] == "lowerSecret_VALUE"
for conflict in [
["lowerSecret", "lowerSecret.value"],
["SAME=lowerSecret", "SAME=lowerSecret.username"],
]:
with pytest.raises(vs.InvalidRequestError):
vs.expand_value_delivery_selector(conn, env=conflict)
def test_access_request_deduplicates_secret_members_and_exposes_field_metadata(vault):
_create(
vault,
name="PROTECTED_LOGIN",
protection="protected",
default_field="password",
fields=[{"name": "username", "sealed": _sealed("username")}],
)
with vault.begin() as conn:
request = vs.create_access_request(
conn,
source_selector={"env": ["PROTECTED_LOGIN", "PROTECTED_LOGIN.username"]},
)
option = request["card"]["grant_options"][0]
assert option["member_snapshot"] == ["PROTECTED_LOGIN"]
assert option["member_fields"] == [
{
"name": "PROTECTED_LOGIN",
"kind": "static",
"default_field": "password",
"fields": ["password", "username"],
}
]
assert [item["name"] for item in option["unlock_material"]] == [
"PROTECTED_LOGIN",
"PROTECTED_LOGIN.username",
]
assert request["card"]["secret_unlock_material"] == {
"name": "PROTECTED_LOGIN",
"kind": "static",
"envelope": {
"ciphertext": "ct-protected_login",
"nonce": "n-protected_login",
"wrap_meta": "wm-protected_login",
},
}
agent_payload = vs.get_request(conn, request["id"], audience=vs.REQUEST_AUDIENCE_AGENT)
persisted = json.loads(conn.execute(
select(vault_requests.c.delivery).where(vault_requests.c.id == request["id"])
).scalar_one())
for payload in [agent_payload, persisted]:
encoded = json.dumps(payload)
assert "ciphertext" not in encoded
assert "unlock_material" not in encoded
assert payload["card"]["grant_options"][0]["member_fields"] == option["member_fields"]
# Legacy binding issues one approval per record. Retain the default
# approval while the next field receives its own release context.
for name in ["PROTECTED_LOGIN", "PROTECTED_LOGIN.username"]:
recorded = vs.record_request_agent_binding_approvals(
conn, request["id"],
{"grant_id": option["grant_id"], "items": [{"name": name}]},
)
assert [
item["items"][0]["name"]
for item in recorded["delivery"]["agent_binding_approvals"]
] == ["PROTECTED_LOGIN", "PROTECTED_LOGIN.username"]
grant = _grant_from_request(conn, request)
resolved = vs.resolve_secret_access(conn, "PROTECTED_LOGIN.username")
assert resolved["grant"]["member_snapshot"] == ["PROTECTED_LOGIN"]
assert resolved["envelope"] == _sealed("username")
scopes = []
vs.update_secret_field(conn, "PROTECTED_LOGIN", "username", _sealed("new"), record="PROTECTED_LOGIN.username", release_scopes=scopes)
assert vs.get_grant_created_by_request(conn, grant["request_id"])["status"] == "expired"
assert scopes == [{"grant_id": grant["id"]}]
next_grant = _grant_from_request(conn, vs.create_access_request(conn, "PROTECTED_LOGIN"))
pending = vs.create_access_request(conn, "PROTECTED_LOGIN")
scopes.clear()
vs.remove_secret_field(conn, "PROTECTED_LOGIN", "username", release_scopes=scopes)
assert vs.get_request(conn, pending["id"])["status"] == "expired"
assert vs.get_grant_created_by_request(conn, next_grant["request_id"])["status"] == "expired"
assert scopes == [{"grant_id": next_grant["id"]}]
def test_standard_ask_card_persists_fields_and_field_access_uses_secret_members(vault):
_create(
vault, name="LOGIN", policy={"always_ask": True},
fields=[{"name": "username", "sealed": _sealed("username")}],
)
with vault.begin() as conn:
request = vs.create_access_request(conn, "LOGIN.username", audience=vs.REQUEST_AUDIENCE_AGENT)
option = request["card"]["grant_options"][0]
assert request["secret_name"] == "LOGIN"
assert option["member_snapshot"] == ["LOGIN"]
assert option["member_fields"] == [
{"name": "LOGIN", "kind": "static", "default_field": "value", "fields": ["value", "username"]}
]
assert "unlock_material" not in json.dumps(request)
def test_delivery_use_count_is_per_secret_and_audit_lists_fields(vault):
_create(vault, name="LOGIN", fields=[{"name": "username", "sealed": _sealed("username")}])
with vault.begin() as conn:
identities = vs.capture_delivery_identities(conn, ["LOGIN", "LOGIN.username"])
vs.record_deliveries(conn, identities, mode="run")
meta = vs.get_secret_meta(conn, "LOGIN")
events = conn.execute(
select(vs.vault_audit.c.delivery).where(
vs.vault_audit.c.secret_name == "LOGIN",
vs.vault_audit.c.event == "delivered",
)
).scalars().all()
assert meta["use_count"] == 1
assert len(events) == 1
assert json.loads(events[0])["fields"] == ["value", "username"]
def test_selector_expansion_unions_env_tags_and_skills(vault):
_create(vault, name="A_KEY", protection="protected", tags=["deploy"])
_create(vault, name="B_KEY", protection="standard", tags=["deploy", "skill:release"])
_create(vault, name="C_KEY", protection="standard", tags=["other"])
with vault.begin() as conn:
expanded = vs.expand_value_delivery_selector(
conn,
env=["LOCAL_C=C_KEY"],
tags=["deploy"],
skills=["release"],
)
assert expanded["source_selector"] == {"env": ["LOCAL_C=C_KEY"], "tags": ["deploy", "skill:release"]}
assert expanded["secrets"] == [
{
"name": "C_KEY",
"field": "value",
"record": "C_KEY",
"env": "LOCAL_C",
"kind": "static",
"protection": "standard",
},
{
"name": "A_KEY",
"field": "value",
"record": "A_KEY",
"env": "A_KEY",
"kind": "static",
"protection": "protected",
},
{
"name": "B_KEY",
"field": "value",
"record": "B_KEY",
"env": "B_KEY",
"kind": "static",
"protection": "standard",
},
]
def test_selector_rejects_env_conflicts_and_keypairs(vault):
_create(vault, name="A_KEY", tags=["deploy"])
_create(vault, name="SIGNING_KEY", kind="keypair", signer_kind="local", tags=["deploy"])
with vault.begin() as conn:
with pytest.raises(vs.InvalidRequestError):
vs.expand_value_delivery_selector(conn, env=["ONE=A_KEY", "TWO=A_KEY"])
with pytest.raises(vs.KeypairNotValueDeliverableError):
vs.expand_value_delivery_selector(conn, tags=["deploy"])
def test_selector_allows_shell_env_alias_for_secret(vault):
_create(vault, name="PROTECTED_KEY", protection="protected")
with vault.begin() as conn:
expanded = vs.expand_value_delivery_selector(conn, env=["api_key=PROTECTED_KEY"])
assert expanded["source_selector"] == {"env": ["api_key=PROTECTED_KEY"]}
assert expanded["secrets"] == [
{
"name": "PROTECTED_KEY",
"field": "value",
"record": "PROTECTED_KEY",
"env": "api_key",
"kind": "static",
"protection": "protected",
}
]
def test_access_request_for_tag_selector_freezes_protected_subset_only(vault):
_create(vault, name="PROTECTED_A", protection="protected", tags=["deploy"])
_create(vault, name="STANDARD_B", protection="standard", tags=["deploy"])
with vault.begin() as conn:
expanded = vs.expand_value_delivery_selector(conn, tags=["deploy"])
request = vs.create_access_request(
conn,
source_selector=expanded["source_selector"],
purpose="run",
requester={"session_id": "ses_1"},
delivery={"session_id": "ses_1", "command": "python deploy.py"},
)
card = request["card"]
assert card["source_selector"] == {"tags": ["deploy"]}
assert card["protected_secret_names"] == ["PROTECTED_A"]
assert card["grant_options"][0]["grant_id"].startswith("vgr_")
assert card["grant_options"][0]["member_snapshot"] == ["PROTECTED_A"]
assert "STANDARD_B" not in json.dumps(card["grant_options"])
def test_tag_edits_do_not_mutate_existing_grant_snapshot(vault):
_create(vault, name="A_KEY", protection="protected", tags=["deploy"])
with vault.begin() as conn:
req = vs.create_access_request(conn, "A_KEY", requester={"session_id": "ses_1"}, delivery={"session_id": "ses_1"})
grant = _grant_from_request(conn, req)
vs.create_secret(conn, name="B_KEY", protection="protected", sealed=_sealed("b"), tags=["deploy"])
vs.update_secret_tags(conn, "B_KEY", ["deploy", "new-tag"])
row = conn.execute(select(vault_grants).where(vault_grants.c.id == grant["id"])).mappings().one()
assert json.loads(row["member_snapshot"]) == ["A_KEY"]
assert grant["member_snapshot"] == ["A_KEY"]
def test_create_grant_stores_final_fields_and_readiness_by_grant_id(vault):
_create(vault, name="A_KEY", protection="protected", tags=["deploy"])
with vault.begin() as conn:
req = vs.create_access_request(
conn,
source_selector={"tags": ["deploy"]},
purpose="inject",
requester={"session_id": "ses_1"},
delivery={"session_id": "ses_1"},
)
grant = _grant_from_request(conn, req)
ready = vs.mark_grant_agent_ready(conn, grant["id"], ttl_seconds=300)
release_refs = vs.agent_release_scopes_after_rows(
conn,
[dict(conn.execute(select(vault_grants).where(vault_grants.c.id == grant["id"])).mappings().one())],
)
assert ready["source_selector"] == {"tags": ["deploy"]}
assert ready["id"] == req["card"]["grant_options"][0]["grant_id"]
assert ready["purpose"] == "inject"
assert ready["request_id"] == req["id"]
assert ready["delivery_ready"] is True
assert release_refs == [{"grant_id": grant["id"]}]
def test_create_grant_rejects_removed_ttl_options(vault):
_create(vault, name="A_KEY", protection="protected", tags=["deploy"])
with vault.begin() as conn:
req = vs.create_access_request(conn, source_selector={"tags": ["deploy"]})
with pytest.raises(vs.InvalidGrantError):
_grant_from_request(conn, req, ttl_seconds=86_400)
def test_create_grant_one_time_uses_short_one_shot_window(vault):
_create(vault, name="A_KEY", protection="protected", tags=["deploy"])
with vault.begin() as conn:
req = vs.create_access_request(conn, source_selector={"tags": ["deploy"]}, requester={"session_id": "ses_1"})
option = req["card"]["grant_options"][0]
grant = vs.create_grant(
conn,
member_names=option["member_snapshot"],
source_selector=option["source_selector"],
purpose=option["purpose"],
request_id=req["id"],
grant_duration="one-time",
)
settings = vs.get_vault_settings(conn)
created = datetime.fromisoformat(grant["created_at"])
expires = datetime.fromisoformat(grant["expires_at"])
assert expires - created == timedelta(seconds=60)
assert grant["one_shot"] is True
assert grant["session_id"] == "ses_1"
assert settings["last_grant_ttl"] == "one-time"
def test_save_vault_settings_first_write_is_atomic_under_concurrency(vault):
barrier = threading.Barrier(6)
def save_settings(index: int) -> dict:
with vault.begin() as conn:
barrier.wait(timeout=5)
return vs.save_vault_settings(conn, {"last_grant_ttl": 300 if index % 2 else 900})
with concurrent.futures.ThreadPoolExecutor(max_workers=6) as executor:
results = list(executor.map(save_settings, range(6)))
with vault.connect() as conn:
rows = list(conn.execute(select(state_meta).where(state_meta.c.key == vs.VAULT_SETTINGS_META_KEY)).mappings())
assert len(rows) == 1
assert {result["last_grant_ttl"] for result in results}.issubset({300, 900})
def test_protected_vault_establishment_is_atomic_under_concurrency(vault, monkeypatch):
init_lock_key = vs.PROTECTED_VAULT_ESTABLISHMENT_LOCK_META_KEY
monkeypatch.setattr(vs, "register_webauthn_factor", lambda *_args, **_kwargs: None)
lock_barrier = threading.Barrier(2)
pre_guard_barrier = threading.Barrier(2)
post_guard_barrier = threading.Barrier(2)
lock_seen = threading.Event()
database_access_before_lock = threading.Event()
thread_state = threading.local()
def is_init_lock(statement: str, parameters) -> bool:
return statement.lstrip().upper().startswith("INSERT INTO STATE_META") and init_lock_key in parameters
def is_protected_guard(statement: str) -> bool:
normalized = " ".join(statement.upper().split())
return "FROM VAULT_SECRETS" in normalized and "WHERE VAULT_SECRETS.PROTECTION =" in normalized
def synchronize_before_guard(_conn, _cursor, statement, parameters, _context, _executemany):
if is_init_lock(statement, parameters):
thread_state.init_lock_seen = True
lock_seen.set()
lock_barrier.wait(timeout=5)
else:
if not getattr(thread_state, "init_lock_seen", False):
database_access_before_lock.set()
if not lock_seen.is_set() and is_protected_guard(statement):
# On the unfixed implementation, force both deferred transactions
# through the empty-vault read before either reaches its first write.
pre_guard_barrier.wait(timeout=5)
def synchronize_after_guard(_conn, _cursor, statement, _parameters, _context, _executemany):
if not lock_seen.is_set() and is_protected_guard(statement):
post_guard_barrier.wait(timeout=5)
event.listen(vault, "before_cursor_execute", synchronize_before_guard)
event.listen(vault, "after_cursor_execute", synchronize_after_guard)
def establish(index: int):
try:
with vault.begin() as conn:
return vs.create_secret(
conn,
name="CONCURRENT_PROTECTED",
sealed=_sealed(f"concurrent-{index}"),
protection="protected",
establishing_vmk=True,
authz_factor_registration={},
)
except vs.VaultServiceError as exc:
return exc
try:
with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
results = list(executor.map(establish, range(2)))
finally:
event.remove(vault, "before_cursor_execute", synchronize_before_guard)
event.remove(vault, "after_cursor_execute", synchronize_after_guard)
successes = [result for result in results if isinstance(result, dict)]
failures = [result for result in results if isinstance(result, vs.VaultServiceError)]
assert len(successes) == 1
assert len(failures) == 1
assert isinstance(failures[0], vs.VaultAlreadyInitializedError)
assert not database_access_before_lock.is_set()
with vault.connect() as conn:
protected_names = list(
conn.execute(select(vault_secrets.c.name).where(vault_secrets.c.protection == "protected")).scalars()
)
lock_row = conn.execute(select(state_meta).where(state_meta.c.key == init_lock_key)).mappings().one()
assert protected_names == [successes[0]["name"]]
assert lock_row["value_json"] == "{}"
def test_sibling_approval_requires_matching_purpose(vault):
_create(vault, name="A_KEY", protection="protected", tags=["deploy"])
with vault.begin() as conn:
run_req = vs.create_access_request(
conn,
source_selector={"tags": ["deploy"]},
purpose="run",
requester={"session_id": "ses_1"},
delivery={"session_id": "ses_1"},
)
fetch_req = vs.create_access_request(
conn,
source_selector={"tags": ["deploy"]},
purpose="fetch",
requester={"session_id": "ses_1"},
delivery={"session_id": "ses_1"},
)
_grant_from_request(conn, run_req)
fetch_row = conn.execute(select(vault_requests).where(vault_requests.c.id == fetch_req["id"])).mappings().one()
assert fetch_row["status"] == "pending"
def test_secret_delete_rotate_and_classification_changes_expire_covering_grants(vault):
_create(vault, name="A_KEY", protection="protected")
_create(vault, name="B_KEY", protection="protected")
_create(vault, name="C_KEY", protection="protected")
with vault.begin() as conn:
grant_a = _grant_from_request(conn, vs.create_access_request(conn, "A_KEY"))
grant_b = _grant_from_request(conn, vs.create_access_request(conn, "B_KEY"))
grant_c = _grant_from_request(conn, vs.create_access_request(conn, "C_KEY"))
vs.rotate_secret(conn, "A_KEY", _sealed("rotated"))
vs.delete_secret(conn, "B_KEY")
vs.update_secret_classification(conn, "C_KEY", protection="standard")
statuses = {
row["id"]: row["status"]
for row in conn.execute(select(vault_grants).where(vault_grants.c.id.in_([grant_a["id"], grant_b["id"], grant_c["id"]]))).mappings()
}
assert statuses == {grant_a["id"]: "expired", grant_b["id"]: "expired", grant_c["id"]: "expired"}
def test_delete_request_deduplicates_and_keeps_value_free_card(vault):
_create(vault, name="DELETE_ME", protection="protected", description="old credential", tags=["prod"])
with vault.begin() as conn:
first, first_created = vs.create_delete_request(
conn,
"DELETE_ME",
reason="rotated",
requester={"source": "agent-cli", "session_id": "ses_delete"},
return_created=True,
)
second, second_created = vs.create_delete_request(
conn,
"DELETE_ME",
reason="different reason",
requester={"source": "agent-cli", "session_id": "ses_other"},
return_created=True,
)
rows = list(conn.execute(select(vault_requests).where(vault_requests.c.request_type == "delete")).mappings())
events = vs.list_audit(conn, secret_name="DELETE_ME")
assert second["id"] == first["id"]
assert first_created is True
assert second_created is False
assert len(rows) == 1
assert first["card"] == {
"card_type": "approval",
"request_type": "delete",
"secret_name": "DELETE_ME",
"name": "DELETE_ME",
"default_field": "value",
"fields": ["value"],
"kind": "static",
"protection": "protected",
"description": "old credential",
"tags": ["prod"],
"session_id": "ses_delete",
"reason": "rotated",
}
assert "ciphertext" not in json.dumps(first)
assert "unlock_material" not in json.dumps(first)
assert any(event["event"] == "delete_requested" for event in events)
def test_delete_request_approve_expires_grants_and_arms_callback(vault):
_create(vault, name="DELETE_APPROVE", protection="protected")
with vault.begin() as conn:
access = vs.create_access_request(conn, "DELETE_APPROVE", requester={"session_id": "ses_access"})
grant = _grant_from_request(conn, access)
request = vs.create_delete_request(conn, "DELETE_APPROVE", requester={"session_id": "ses_delete"})
release_scopes: list[dict[str, str]] = []
approved = vs.approve_delete_request(conn, request["id"], release_scopes=release_scopes)
grant_row = dict(conn.execute(select(vault_grants).where(vault_grants.c.id == grant["id"])).mappings().one())
callback = vs.resolve_request_callback(dict(conn.execute(select(vault_requests).where(vault_requests.c.id == request["id"])).mappings().one()))
assert approved["status"] == "approved"
assert grant_row["status"] == "expired"
assert release_scopes == [{"grant_id": grant["id"]}]
assert callback is not None
assert callback.message == "The user approved deleting the secret 'DELETE_APPROVE'; it has been deleted. Continue the task."
with vault.connect() as conn:
with pytest.raises(vs.SecretNotFoundError):
vs.get_secret_meta(conn, "DELETE_APPROVE")
def test_delete_request_deleted_elsewhere_is_fulfilled(vault):
_create(vault, name="DELETE_ELSEWHERE")
with vault.begin() as conn:
request = vs.create_delete_request(conn, "DELETE_ELSEWHERE", requester={"session_id": "ses_delete"})
vs.delete_secret(conn, "DELETE_ELSEWHERE")
row = dict(conn.execute(select(vault_requests).where(vault_requests.c.id == request["id"])).mappings().one())
assert row["status"] == "fulfilled"
callback = vs.resolve_request_callback(row)
assert callback is not None
assert callback.message == "The user approved deleting the secret 'DELETE_ELSEWHERE'; it has been deleted. Continue the task."
def test_direct_delete_expires_overdue_delete_request(vault):
_create(vault, name="DELETE_OVERDUE")
past = (datetime.now(timezone.utc) - timedelta(minutes=1)).isoformat()
with vault.begin() as conn:
request = vs.create_delete_request(conn, "DELETE_OVERDUE", requester={"session_id": "ses_delete"})
conn.execute(vault_requests.update().where(vault_requests.c.id == request["id"]).values(expires_at=past))
vs.delete_secret(conn, "DELETE_OVERDUE")
row = dict(conn.execute(select(vault_requests).where(vault_requests.c.id == request["id"])).mappings().one())
assert row["status"] == "expired"
callback = vs.resolve_request_callback(row)
assert callback is not None
assert "expired" in callback.message.lower()
def test_delete_request_expiry_and_deny_callbacks(vault):
_create(vault, name="DELETE_EXPIRE")
past = (datetime.now(timezone.utc) - timedelta(minutes=1)).isoformat()
with vault.begin() as conn:
request = vs.create_delete_request(conn, "DELETE_EXPIRE", requester={"session_id": "ses_delete"})
conn.execute(vault_requests.update().where(vault_requests.c.id == request["id"]).values(expires_at=past))
expired = vs.get_request(conn, request["id"])
raw_expired = dict(conn.execute(select(vault_requests).where(vault_requests.c.id == request["id"])).mappings().one())
assert expired["status"] == "expired"
assert "expired" in (vs.resolve_request_callback(raw_expired).message if vs.resolve_request_callback(raw_expired) else "")
_create(vault, name="DELETE_DENY")
with vault.begin() as conn:
request = vs.create_delete_request(conn, "DELETE_DENY", requester={"session_id": "ses_delete"})
denied = vs.deny_request(conn, request["id"])
callback = vs.resolve_request_callback(dict(conn.execute(select(vault_requests).where(vault_requests.c.id == request["id"])).mappings().one()))
assert denied["status"] == "denied"
assert callback is not None
assert callback.message == "The user declined deleting the secret 'DELETE_DENY'. Do not retry — keep the secret and ask the user if needed."
def test_protected_delete_does_not_require_authz_at_chokepoint(vault):
_create(vault, name="PROTECTED_KEY", protection="protected")
with vault.begin() as conn:
vs.delete_secret(conn, "PROTECTED_KEY")
with pytest.raises(vs.SecretNotFoundError):
vs.get_secret_meta(conn, "PROTECTED_KEY")
def test_standard_delete_does_not_require_authz(vault):
_create(vault, name="STANDARD_KEY", protection="standard")
with vault.begin() as conn:
vs.delete_secret(conn, "STANDARD_KEY")
with pytest.raises(vs.SecretNotFoundError):
vs.get_secret_meta(conn, "STANDARD_KEY")
def test_webauthn_factor_registration_stores_public_key(vault):
credential = WebAuthnTestCredential()
with vault.begin() as conn:
_credential, factor = _establish_protected_secret(conn, "PROTECTED_KEY", credential)
row = conn.execute(select(vault_auth_factors).where(vault_auth_factors.c.id == factor["id"])).mappings().one()
assert factor["credential_id"] == credential.credential_id_b64
assert row["public_key"]
assert row["alg"] == -7
assert json.loads(row["transports"]) == ["internal"]
def test_sandbox_cross_origin_webauthn_registration_and_assertion_accept_allowed_parent(vault):
credential = WebAuthnTestCredential(rp_id="sandbox.avibe.bot", origin="https://sandbox.avibe.bot")
with vault.begin() as conn:
options = vs.create_webauthn_registration_options(conn, rp_id=credential.rp_id, origin=credential.origin)
registration = credential.registration_payload(
challenge_id=options["challenge_id"],
challenge_b64=options["webauthn"]["challenge"],
cross_origin=True,
top_origin="http://localhost:5173",
)
factor = vs.register_webauthn_factor(conn, registration, rp_id=credential.rp_id, origin=credential.origin, establishment=True)[
"factor"
]
with vault.connect() as conn:
factor_row = conn.execute(select(vault_auth_factors).where(vault_auth_factors.c.id == factor["id"])).mappings().one()
public_key = factor_row["public_key"]
challenge = b"sandbox-cross-origin-challenge"
challenge_b64 = vault_webauthn.b64encode(challenge)
allowed_assertion = credential.assertion_authz(
challenge_id="vop_cross_origin",
factor_id=factor["id"],
challenge_b64=challenge_b64,
sign_count=2,
cross_origin=True,
top_origin="https://team.avibe.bot",
)["assertion"]
assert (
vault_webauthn.verify_assertion(
allowed_assertion,
credential_id=credential.credential_id_b64,
public_key=public_key,
alg=vault_webauthn.ALG_ES256,
stored_sign_count=1,
expected_challenge_hash=vault_webauthn.challenge_hash(challenge),
expected_origin=credential.origin,
rp_id=credential.rp_id,
).sign_count
== 2
)
safari_assertion = credential.assertion_authz(
challenge_id="vop_cross_origin",
factor_id=factor["id"],
challenge_b64=challenge_b64,
sign_count=3,
cross_origin=True,
)["assertion"]
assert (
vault_webauthn.verify_assertion(
safari_assertion,
credential_id=credential.credential_id_b64,
public_key=public_key,
alg=vault_webauthn.ALG_ES256,
stored_sign_count=2,
expected_challenge_hash=vault_webauthn.challenge_hash(challenge),
expected_origin=credential.origin,
rp_id=credential.rp_id,
).sign_count
== 3
)
def test_sandbox_cross_origin_webauthn_rejects_wrong_top_origin():
credential = WebAuthnTestCredential(rp_id="sandbox.avibe.bot", origin="https://sandbox.avibe.bot")
challenge = b"sandbox-cross-origin-challenge"
challenge_b64 = vault_webauthn.b64encode(challenge)
assertion = credential.assertion_authz(
challenge_id="vop_cross_origin",
factor_id="vaf_cross_origin",
challenge_b64=challenge_b64,
cross_origin=True,
top_origin="https://evil.example",
)["assertion"]
with pytest.raises(vault_webauthn.WebAuthnVerificationError, match="top origin"):
vault_webauthn.verify_assertion(
assertion,
credential_id=credential.credential_id_b64,
public_key=vault_webauthn.b64encode(credential.public_key_cose()),
alg=vault_webauthn.ALG_ES256,
stored_sign_count=0,
expected_challenge_hash=vault_webauthn.challenge_hash(challenge),
expected_origin=credential.origin,
rp_id=credential.rp_id,
)
def test_webauthn_counter_regression_rejects_zero_after_nonzero_counter():
credential = WebAuthnTestCredential()
challenge = b"counter-challenge"
challenge_b64 = vault_webauthn.b64encode(challenge)
public_key = vault_webauthn.b64encode(credential.public_key_cose())
zero_assertion = credential.assertion_authz(
challenge_id="vop_counter",
factor_id="vaf_counter",
challenge_b64=challenge_b64,
sign_count=0,
)["assertion"]
assert (
vault_webauthn.verify_assertion(
zero_assertion,
credential_id=credential.credential_id_b64,
public_key=public_key,
alg=vault_webauthn.ALG_ES256,
stored_sign_count=0,
expected_challenge_hash=vault_webauthn.challenge_hash(challenge),
expected_origin=credential.origin,
rp_id=credential.rp_id,
).sign_count
== 0
)
with pytest.raises(vault_webauthn.WebAuthnVerificationError):
vault_webauthn.verify_assertion(
zero_assertion,
credential_id=credential.credential_id_b64,
public_key=public_key,
alg=vault_webauthn.ALG_ES256,
stored_sign_count=1,
expected_challenge_hash=vault_webauthn.challenge_hash(challenge),
expected_origin=credential.origin,
rp_id=credential.rp_id,
)
increasing_assertion = credential.assertion_authz(
challenge_id="vop_counter",
factor_id="vaf_counter",
challenge_b64=challenge_b64,
sign_count=2,
)["assertion"]
assert (
vault_webauthn.verify_assertion(
increasing_assertion,
credential_id=credential.credential_id_b64,
public_key=public_key,
alg=vault_webauthn.ALG_ES256,
stored_sign_count=1,
expected_challenge_hash=vault_webauthn.challenge_hash(challenge),
expected_origin=credential.origin,
rp_id=credential.rp_id,
).sign_count
== 2
)
def test_webauthn_registration_invalid_cose_point_fails_closed(vault):
credential = WebAuthnTestCredential()
with vault.begin() as conn:
options = vs.create_webauthn_registration_options(
conn,
rp_id=credential.rp_id,
origin=credential.origin,
)
payload = credential.registration_payload(
challenge_id=options["challenge_id"],
challenge_b64=options["webauthn"]["challenge"],
public_key_cose=WebAuthnTestCredential.es256_public_key_cose(1, 1),
)
with pytest.raises(vs.InvalidProtectedAuthzError) as exc:
vs.register_webauthn_factor(conn, payload, rp_id=credential.rp_id, origin=credential.origin, establishment=True)
assert isinstance(exc.value.__cause__, vault_webauthn.WebAuthnVerificationError)
def test_standard_secret_does_not_create_access_request_unless_always_ask(vault):
_create(vault, name="STANDARD_KEY", protection="standard")
_create(vault, name="ASK_KEY", protection="standard", policy={"always_ask": True})
with vault.begin() as conn:
assert vs.resolve_secret_access(conn, "STANDARD_KEY")["status"] == "standard"
with pytest.raises(vs.NotGrantableError):
vs.create_access_request(conn, "STANDARD_KEY")
req = vs.create_access_request(conn, "ASK_KEY", requester={"session_id": "ses_1"}, delivery={"session_id": "ses_1"})
grant = _grant_from_request(conn, req)
reserved = vs.find_active_grant_for_secret(conn, "ASK_KEY", session_id="ses_1", reserve_one_shot=True)
assert req["card"]["one_shot"] is True
assert grant["one_shot"] is True
assert reserved["status"] == "reserved"
def test_multi_member_one_shot_grant_is_consumed_once(vault):
_create(vault, name="ASK_KEY", protection="standard", tags=["deploy"], policy={"always_ask": True})
_create(vault, name="PROTECTED_KEY", protection="protected", tags=["deploy"])
with vault.begin() as conn:
req = vs.create_access_request(conn, source_selector={"tags": ["deploy"]}, requester={"session_id": "ses_1"})
grant = _grant_from_request(conn, req)
reserved = vs.find_active_grant_for_secret(
conn,
"ASK_KEY",
session_id="ses_1",
reserve_one_shot=True,
)
releases = vs.consume_one_shot_grant(conn, grant["id"])
row = conn.execute(select(vault_grants).where(vault_grants.c.id == grant["id"])).mappings().one()
assert req["card"]["one_shot"] is True
assert grant["one_shot"] is True
assert reserved["status"] == "reserved"
assert row["status"] == "expired"
assert releases == [{"grant_id": grant["id"]}]
def test_create_grant_rejects_expired_binding_without_claiming_request(vault):
_create(vault, name="PROTECTED_KEY", protection="protected")
expired_at = (datetime.now(timezone.utc) - timedelta(seconds=1)).isoformat()
with vault.begin() as conn:
req = vs.create_access_request(conn, "PROTECTED_KEY", requester={"session_id": "ses_1"})
with pytest.raises(vs.InvalidGrantError, match="grant binding has expired"):
_grant_from_request(conn, req, expires_at=expired_at)
row = conn.execute(select(vault_requests).where(vault_requests.c.id == req["id"])).mappings().one()
grants = conn.execute(select(vault_grants).where(vault_grants.c.request_id == req["id"])).mappings().all()
assert row["status"] == "pending"
assert grants == []
def test_selector_request_expires_when_member_rotates(vault):
_create(vault, name="A_KEY", protection="protected", tags=["deploy"])
_create(vault, name="B_KEY", protection="protected", tags=["deploy"])
with vault.begin() as conn:
req = vs.create_access_request(conn, source_selector={"tags": ["deploy"]})
assert req["secret_name"] is None
expired = vs.rotate_secret(conn, "A_KEY", _sealed("rotated"))
row = conn.execute(select(vault_requests).where(vault_requests.c.id == req["id"])).mappings().one()
assert expired["name"] == "A_KEY"
assert row["status"] == "expired"
def test_selector_request_restores_after_failed_grant(vault):
_create(vault, name="A_KEY", protection="protected", tags=["deploy"])
_create(vault, name="B_KEY", protection="protected", tags=["deploy"])
with vault.begin() as conn:
req = vs.create_access_request(
conn,
source_selector={"tags": ["deploy"]},
requester={"session_id": "ses_1"},
delivery={"session_id": "ses_1"},
)
grant = _grant_from_request(conn, req, cache_ready=False)
restored = vs.restore_access_request_after_failed_grant(
conn,
request_id=req["id"],
member_names=grant["member_snapshot"],
session_id=grant["session_id"],
)
row = conn.execute(select(vault_requests).where(vault_requests.c.id == req["id"])).mappings().one()
assert restored == 1
assert row["status"] == "pending"
assert row["decided_at"] is None
def test_request_payload_hydrates_unlock_material_only_for_ui(vault):
_create(vault, name="PROTECTED_KEY", protection="protected")
with vault.begin() as conn:
req = vs.create_access_request(
conn,
"PROTECTED_KEY",
requester={"source": "agent-cli", "session_id": "ses_1"},
delivery={"session_id": "ses_1"},
)
agent_payload = vs.get_request(conn, req["id"], audience=vs.REQUEST_AUDIENCE_AGENT)
ui_payload = vs.get_request(conn, req["id"], audience=vs.REQUEST_AUDIENCE_UI)
assert "unlock_material" not in json.dumps(agent_payload)
assert ui_payload["card"]["grant_options"][0]["unlock_material"][0]["name"] == "PROTECTED_KEY"
def test_expired_request_cannot_create_grant(vault):
_create(vault, name="A_KEY", protection="protected")
expired_at = (datetime.now(timezone.utc) - timedelta(seconds=1)).isoformat()
with vault.begin() as conn:
req = vs.create_access_request(conn, "A_KEY", expires_at=expired_at)
with pytest.raises(vs.InvalidRequestError):
_grant_from_request(conn, req)
def test_get_grant_created_by_request_uses_request_id(vault):
_create(vault, name="A_KEY", protection="protected")
with vault.begin() as conn:
req = vs.create_access_request(conn, "A_KEY")
grant = _grant_from_request(conn, req)
fetched = vs.get_grant_created_by_request(conn, req["id"])
assert fetched["id"] == grant["id"]