2026-11-13 18:14:17 +00:00
from __future__ import annotations
import functools
import json
import time
from unittest import mock
from hub_case import HubCase
from hub_support import ASK , PRESENT , key , signing , verifier
2026-11-14 21:29:42 +00:00
from kvb_orchestrator import batches , firewall , requesting , rules
2026-11-13 18:14:17 +00:00
HOME_FILE = "/home/op/.claude/settings.json"
PROJECT_FILE = "/home/op/Repositories/demo/.claude/settings.json"
SHA = "ab" * 32
PERMISSIONS = {
"allow" : [ "Bash(make test:*)" , "Bash(make lint:*)" , "Bash(git status:*)" , "WebFetch(domain:example.org)" , "mcp__memory__search" ],
"ask" : [ "Bash(git push:*)" ],
"deny" : [ "Read(~/.ssh/**)" , 7 ],
}
SANDBOX = { "enabled" : True , "filesystem" : { "allowWrite" : [ "/tmp" , "~/Repositories" ]}, "network" : { "allowLocalBinding" : False }}
ADD = { "list" : "permissions.allow" , "op" : "add" , "entry" : "Bash(make build:*)" }
class TestHubFirewall ( HubCase ):
def setUp ( self ):
super () . setUp ()
self . claim ( "s1" , "Skills" )
self . claim ( "s2" , "Stage" )
self . snapshot ()
def view ( self , files : list [ dict ]) -> None :
( self . state / "firewall" / "view.json" ) . write_text ( json . dumps ({ "written" : time . time (), "files" : files }), encoding = "utf-8" )
def home_view ( self ) -> dict :
return { "path" : HOME_FILE , "exists" : True , "sha256" : SHA , "error" : "" , "settings" : { "permissions" : PERMISSIONS , "sandbox" : SANDBOX , "env" : { "EXAMPLE_FLAG" : "fixture-value-not-a-secret" }}}
def firewall ( self ) -> dict :
status , _ , body = self . get ( "/api/firewall" )
self . assertEqual ( status , 200 , body )
return json . loads ( body )
def post ( self , path : str , payload : object ) -> tuple [ int , bytes ]:
status , _ , body = self . post_json ( path , payload , self . guard ( self . host ))
return status , body
def test_the_firewall_groups_the_settings_by_tool_and_prefix_and_lists_the_deny_patterns ( self ):
self . assertEqual ( self . firewall ()[ "files" ], [])
self . assertIn ( "kvb-orchestrator-firewall" , self . firewall ()[ "error" ])
self . view ([ self . home_view (), { "path" : PROJECT_FILE , "exists" : False , "sha256" : "" , "error" : "" , "settings" : {}}, { "path" : "/x" , "exists" : "yes" , "sha256" : "" , "settings" : {}}])
found = self . firewall ()
self . assertEqual ([ entry [ "path" ] for entry in found [ "files" ]], [ HOME_FILE , PROJECT_FILE ])
groups = [( group [ "tool" ], group [ "prefix" ], [( entry [ "list" ], entry [ "entry" ]) for entry in group [ "entries" ]]) for group in found [ "files" ][ 0 ][ "groups" ]]
self . assertEqual ( groups , [
( "Bash" , "git" , [( "allow" , "Bash(git status:*)" ), ( "ask" , "Bash(git push:*)" )]),
( "Bash" , "make" , [( "allow" , "Bash(make test:*)" ), ( "allow" , "Bash(make lint:*)" )]),
( "Read" , "~/.ssh/**" , [( "deny" , "Read(~/.ssh/**)" )]),
( "WebFetch" , "domain" , [( "allow" , "WebFetch(domain:example.org)" )]),
( "mcp__memory__search" , "" , [( "allow" , "mcp__memory__search" )]),
])
self . assertEqual ( found [ "files" ][ 0 ][ "sandbox" ], [{ "key" : "sandbox.enabled" , "value" : True }, { "key" : "sandbox.filesystem.allowWrite" , "values" : [ "/tmp" , "~/Repositories" ]}, { "key" : "sandbox.network.allowLocalBinding" , "value" : False }])
self . assertEqual ( found [ "lists" ], list ( signing . SETTINGS_LISTS ))
self . assertEqual ([ pattern [ "label" ] for pattern in found [ "patterns" ]][: len ( signing . WARNINGS )], [ label for label , _ in signing . WARNINGS ])
self . assertNotIn ( "fixture-value-not-a-secret" , json . dumps ( found ))
for path in ( "/api/firewall/preview" , "/api/firewall/settings" , "/api/firewall/groups" , "/api/firewall/sets" , "/api/firewall/groups/0123456789abcdef/delete" ):
with self . subTest ( path = path ):
self . assertEqual ( self . get ( path )[ 0 ], 405 )
self . assertEqual ( self . get ( "/api/firewall/settings/0123456789abcdef" )[ 0 ], 404 )
2026-11-14 21:29:42 +00:00
def test_the_rule_table_counts_hits_of_the_last_seven_days_from_the_ask_ledger_with_the_dry_run_matcher ( self ):
permissions = { "allow" : [ "Bash(make deploy:*)" ], "ask" : [ "Bash(make deploy:*)" , "Bash(git push:*)" , "Bash(make clean:*)" , "Bash" ], "deny" : [ "Bash(make deploy --prod:*)" ]}
self . view ([{ ** self . home_view (), "settings" : { "permissions" : permissions , "sandbox" : SANDBOX }}])
for command , session in (( "make deploy" , "s1" ), ( "make deploy --dry" , "s1" ), ( "make deploy" , "s2" ), ( "make deploy && rm -rf /" , "s1" ), ( "git push origin main" , "s1" ), ( "make test" , "s1" )):
self . create_ask ({ ** ASK , "command" : command , "session" : session })
old = self . create_ask ({ ** ASK , "command" : "make deploy" })
self . httpd . hub . asks . change ( old , { "created_ts" : time . time () - 8 * 86400 })
signer = self . pin ()
later = time . time () + 3600
mine = self . signed_rule ( signer , { "kind" : "ask" , "tool" : "Bash" , "pattern" : "make deploy*" , "scope" : "/repo*" , "expires" : later , "agents" : [ "s1" ]})
elsewhere = self . signed_rule ( signer , { "kind" : "ask" , "tool" : "Bash" , "pattern" : "make deploy*" , "scope" : "/elsewhere*" , "expires" : later })
pushing = self . signed_rule ( signer , { "kind" : "ask" , "tool" : "Bash" , "pattern" : "git push *" , "scope" : "*" , "expires" : later })
review = self . signed_rule ( signer , { "kind" : "review" , "tool" : "" , "pattern" : "feature/*" , "scope" : "/repo/*" , "expires" : later })
self . assertEqual ( self . call ( "POST" , f "/api/rules/ { mine [ 'id' ] } /disable" , b "" , self . guard ( self . host ))[ 0 ], 200 )
found = self . firewall ()
entries = {( entry [ "list" ], entry [ "entry" ]): ( entry [ "spec" ], entry [ "hits" ], entry [ "never" ]) for group in found [ "files" ][ 0 ][ "groups" ] for entry in group [ "entries" ]}
self . assertEqual ( entries , {
( "allow" , "Bash(make deploy:*)" ): ( "make deploy:*" , None , "" ),
( "ask" , "Bash(make deploy:*)" ): ( "make deploy:*" , 3 , "" ),
( "ask" , "Bash(git push:*)" ): ( "git push:*" , None , "pushes" ),
( "ask" , "Bash(make clean:*)" ): ( "make clean:*" , 0 , "" ),
( "ask" , "Bash" ): ( "" , 4 , "" ),
( "deny" , "Bash(make deploy --prod:*)" ): ( "make deploy --prod:*" , None , "" ),
})
self . assertEqual ( found [ "days" ], requesting . RECENT_DAYS )
self . assertEqual ( found [ "rules" ], { mine [ "id" ]: { "hits" : 2 , "never" : "" }, elsewhere [ "id" ]: { "hits" : 0 , "never" : "" }, pushing [ "id" ]: { "hits" : None , "never" : "pushes" }, review [ "id" ]: { "hits" : None , "never" : "" }})
def test_an_entry_becomes_the_rule_the_dry_run_matcher_counts_and_a_hit_needs_the_rule_to_match ( self ):
now = time . time ()
for entry , rule in (
( "Bash(make test:*)" , { "kind" : "ask" , "tool" : "Bash" , "pattern" : "make test*" , "scope" : "*" }),
( "Bash(npm run *)" , { "kind" : "ask" , "tool" : "Bash" , "pattern" : "npm run *" , "scope" : "*" }),
( "Bash" , { "kind" : "ask" , "tool" : "Bash" , "pattern" : "*" , "scope" : "*" }),
( "mcp__memory__search" , { "kind" : "ask" , "tool" : "mcp__memory__search" , "pattern" : "*" , "scope" : "*" }),
):
with self . subTest ( entry = entry ):
self . assertEqual ( firewall . entry_rule ( entry ), rule )
asks = [ rules . subject_of ( "ask" , { "id" : "0123456789abcdef" , "tool" : "Bash" , "command" : command , "cwd" : "/repo" , "session" : "s1" }, set ()) for command in ( "make test" , "make test-unit" , "make lint" )]
self . assertEqual ( firewall . hits ( firewall . entry_rule ( "Bash(make test:*)" ), asks , now ), { "hits" : 2 , "never" : "" })
self . assertEqual ( firewall . hits ( firewall . entry_rule ( "Bash(make build:*)" ), asks , now ), { "hits" : 0 , "never" : "" })
self . assertEqual ( firewall . hits ( firewall . entry_rule ( "Bash(make test | sh:*)" ), asks , now ), { "hits" : None , "never" : "pipes into a shell" })
self . assertEqual ( firewall . hits ( firewall . entry_rule ( "Bash(make test; make lint)" ), asks , now ), { "hits" : None , "never" : firewall . CHAINED })
with mock . patch . object ( requesting , "rule_matches" , return_value = False ):
self . assertEqual ( firewall . hits ( firewall . entry_rule ( "Bash(make test:*)" ), asks , now ), { "hits" : 0 , "never" : "" })
2026-11-13 18:14:17 +00:00
def test_a_settings_change_is_previewed_signed_and_queued_for_the_host ( self ):
self . view ([ self . home_view ()])
item = { "kind" : "settings" , "file" : HOME_FILE , "base" : SHA , "changes" : [ ADD , { "list" : "permissions.ask" , "op" : "remove" , "entry" : "Bash(git push:*)" }]}
status , body = self . post ( "/api/firewall/preview" , { "items" : [ item ]})
self . assertEqual ( status , 200 , body )
diff = json . loads ( body )[ "diffs" ][ 0 ][ "diff" ]
changed = [ line for line in diff . splitlines () if line [: 1 ] in "+-" and line [: 3 ] not in ( "+++" , "---" )]
self . assertEqual ([ line [ 0 ] + line [ 1 :] . strip () for line in changed ], [ '-"mcp__memory__search"' , '+"mcp__memory__search",' , '+"Bash(make build:*)"' , '-"ask": [' , '-"Bash(git push:*)"' , '-],' , '+"ask": [],' ])
self . assertNotIn ( "EXAMPLE_FLAG" , diff )
signed = signing . settings_item ( HOME_FILE , SHA , item [ "changes" ])
self . assertEqual ( self . prepare ([ item ])[ "payload" ][ "items" ], [ signing . item_hash ( signed )])
signer = self . pin ()
proof = signer . proof ( self . prepare ([ item ])[ "payload" ], self . origin )
for name , items , proven , expected in (
( "no proof" , [ item ], None , 400 ),
( "forged" , [ item ], key ( - 7 , "intruder" ) . proof ( self . prepare ([ item ])[ "payload" ], self . origin ), 400 ),
( "stale base" , [{ ** item , "base" : "cd" * 32 }], proof , 409 ),
( "unlisted file" , [{ ** item , "file" : PROJECT_FILE }], proof , 400 ),
( "hooks list" , [{ ** item , "changes" : [{ ** ADD , "list" : "hooks.Stop" }]}], proof , 400 ),
( "added twice" , [{ ** item , "changes" : [{ ** ADD , "entry" : "Bash(make test:*)" }]}], proof , 400 ),
( "two items for one file" , [ item , item ], proof , 400 ),
( "other item signed" , [{ ** item , "changes" : [ ADD ]}], proof , 400 ),
):
with self . subTest ( name = name ):
self . assertEqual ( self . post ( "/api/firewall/settings" , { "items" : items , "proof" : proven })[ 0 ], expected )
self . assertEqual ( self . post_json ( "/api/firewall/settings" , { "items" : [ item ], "proof" : proof }, { "Host" : self . host })[ 0 ], 403 )
self . assertEqual ( list (( self . state / "firewall" / "jobs" ) . iterdir ()), [])
status , body = self . post ( "/api/firewall/settings" , { "items" : [ item ], "proof" : proof })
self . assertEqual ( status , 202 , body )
job_id = json . loads ( body )[ "id" ]
written = self . state / "firewall" / "jobs" / f " { job_id } .json"
job = json . loads ( written . read_text ( encoding = "utf-8" ))
self . assertEqual (( sorted ( job ), job [ "items" ], job [ "proof" ]), ([ "created" , "id" , "items" , "proof" , "v" ], [{ name : signed [ name ] for name in signing . SETTINGS_KEYS }], proof ))
self . assertEqual ( written . stat () . st_mode & 0o777 , 0o600 )
self . assertEqual ( self . post ( "/api/firewall/settings" , { "items" : [ item ], "proof" : proof })[ 0 ], 400 )
self . assertEqual ( json . loads ( self . get ( f "/api/firewall/settings/ { job_id } " )[ 2 ])[ "status" ], "queued" )
result = { "id" : job_id , "finished" : time . time (), "items" : [{ ** job [ "items" ][ 0 ], "status" : "done" , "reason" : "" }]}
( self . state / "firewall" / "results" / f " { job_id } .json" ) . write_text ( json . dumps ( result ), encoding = "utf-8" )
self . assertEqual ( json . loads ( self . get ( f "/api/firewall/settings/ { job_id } " )[ 2 ])[ "status" ], "done" )
def test_a_settings_entry_or_path_with_an_invisible_format_character_is_refused_before_it_reaches_a_prompt ( self ):
self . view ([ self . home_view ()])
for name , item , code in (
( "bidi override in an entry" , { "kind" : "settings" , "file" : HOME_FILE , "base" : SHA , "changes" : [{ ** ADD , "entry" : f "Bash(make build { chr ( 0x202E ) } :*)" }]}, "U+202E" ),
( "zero-width space in an entry" , { "kind" : "settings" , "file" : HOME_FILE , "base" : SHA , "changes" : [{ ** ADD , "entry" : f "Bash(make { chr ( 0x200B ) } build:*)" }]}, "U+200B" ),
( "no-break space in a deny entry" , { "kind" : "settings" , "file" : HOME_FILE , "base" : SHA , "changes" : [{ "list" : "permissions.deny" , "op" : "add" , "entry" : f "Bash(rm { chr ( 0xA0 ) } -r:*)" }]}, "U+00A0" ),
( "ideographic space in a deny entry" , { "kind" : "settings" , "file" : HOME_FILE , "base" : SHA , "changes" : [{ "list" : "permissions.deny" , "op" : "add" , "entry" : f "Bash(rm { chr ( 0x3000 ) } -r:*)" }]}, "U+3000" ),
( "Hangul filler in an entry" , { "kind" : "settings" , "file" : HOME_FILE , "base" : SHA , "changes" : [{ ** ADD , "entry" : f "Bash(make { chr ( 0x3164 ) } build:*)" }]}, "U+3164" ),
( "grapheme joiner in an entry" , { "kind" : "settings" , "file" : HOME_FILE , "base" : SHA , "changes" : [{ ** ADD , "entry" : f "Bash(make { chr ( 0x34F ) } build:*)" }]}, "U+034F" ),
( "variation selector in an entry" , { "kind" : "settings" , "file" : HOME_FILE , "base" : SHA , "changes" : [{ ** ADD , "entry" : f "Bash(make build { chr ( 0xE0100 ) } :*)" }]}, "U+E0100" ),
( "Hangul filler in a path" , { "kind" : "settings" , "file" : f "/home/op { chr ( 0xFFA0 ) } /.claude/settings.json" , "base" : SHA , "changes" : [ ADD ]}, "U+FFA0" ),
):
with self . subTest ( name = name ):
for path in ( "/api/firewall/preview" , "/api/sign" ):
status , body = self . post ( path , { "items" : [ item ]})
self . assertEqual ( status , 400 )
self . assertIn ( code , body . decode ( "utf-8" ))
self . assertIn ( "U+2067" , signing . settings_problem ({ "file" : f "/home/op { chr ( 0x2067 ) } /.claude/settings.json" , "base" : SHA , "changes" : [ ADD ]}))
self . assertIn ( "U+FEFF" , signing . settings_problem ({ "file" : HOME_FILE , "base" : SHA , "changes" : [{ ** ADD , "entry" : f " { chr ( 0xFEFF ) } Bash(make build:*)" }]}))
self . assertIsNone ( signing . settings_problem ({ "file" : HOME_FILE , "base" : SHA , "changes" : [ ADD ]}))
self . assertEqual ( self . post ( "/api/firewall/preview" , { "items" : [{ "kind" : "settings" , "file" : HOME_FILE , "base" : SHA , "changes" : [ ADD ]}]})[ 0 ], 200 )
def test_removing_a_settings_entry_with_a_hidden_character_is_offered_and_adding_one_is_not ( self ):
hidden = f "Bash(make { chr ( 0x202E ) } build:*)"
self . view ([{ ** self . home_view (), "settings" : { "permissions" : { ** PERMISSIONS , "allow" : [ * PERMISSIONS [ "allow" ], hidden ]}, "sandbox" : SANDBOX }}])
removal = { "kind" : "settings" , "file" : HOME_FILE , "base" : SHA , "changes" : [{ "list" : "permissions.allow" , "op" : "remove" , "entry" : hidden }]}
addition = { ** removal , "changes" : [{ "list" : "permissions.ask" , "op" : "add" , "entry" : hidden }]}
for path in ( "/api/firewall/preview" , "/api/sign" ):
with self . subTest ( path = path ):
self . assertEqual ( self . post ( path , { "items" : [ removal ]})[ 0 ], 200 )
status , body = self . post ( path , { "items" : [ addition ]})
self . assertEqual ( status , 400 )
self . assertIn ( "U+202E" , body . decode ( "utf-8" ))
self . assertIsNone ( signing . hidden_problem ( removal [ "changes" ][ 0 ], "change" ))
for name , value in (
( "no list" , { "op" : "remove" , "entry" : hidden }),
( "extra key" , { ** removal [ "changes" ][ 0 ], "note" : "x" }),
( "unknown list" , { ** removal [ "changes" ][ 0 ], "list" : "permissions.other" }),
( "an ask with op remove" , { "kind" : "ask" , "op" : "remove" , "entry" : hidden }),
( "nested in an item" , { "kind" : "review" , "branch" : { "op" : "remove" , "entry" : hidden }}),
):
with self . subTest ( name = name ):
self . assertIn ( "U+202E" , signing . hidden_problem ( value , "item" ))
def test_a_group_set_addressee_legacy_rule_or_pattern_with_a_hidden_character_is_never_offered_for_a_signature ( self ):
rlo = chr ( 0x202E )
signer = self . pin ()
rule = self . signed_rule ( signer , { "kind" : "ask" , "tool" : "Bash" , "pattern" : "make *" , "scope" : "/repo*" , "expires" : time . time () + 3600 , "agents" : [ "s1" ]})
for path , payload in (( "/api/firewall/groups" , { "name" : f "ci { rlo } " , "members" : [ "s1" ]}), ( "/api/firewall/sets" , { "name" : f "ci { rlo } " , "days" : 7 , "rules" : [ rule [ "id" ]]})):
with self . subTest ( path = path ):
status , body = self . post ( path , payload )
self . assertEqual ( status , 400 )
self . assertIn ( "U+202E" , body . decode ( "utf-8" ))
for code in ( 0x2028 , 0x2029 , 0x85 , 0x0B , 0x0D , 0x34F , 0xFE0F , 0xE0100 , 0x3164 , 0x1160 , 0xA0 , 0x3000 ):
with self . subTest ( code = code ):
status , body = self . post ( "/api/rules/sign" , { "kind" : "ask" , "tool" : "Bash" , "pattern" : f "make test { chr ( code ) } in /safe" , "scope" : "/repo*" , "expires" : time . time () + 3600 })
self . assertEqual ( status , 400 )
self . assertIn ( f "U+ { code : 04X } " , body . decode ( "utf-8" ))
stored = self . httpd . hub . rules . get ( rule [ "id" ])
legacy = { key : value for key , value in stored [ "proof" ][ "payload" ] . items () if key != signing . TARGET }
self . httpd . hub . rules . change ( rule [ "id" ], { "enabled" : False , "proof" : { ** stored [ "proof" ], "payload" : { ** legacy , "pattern" : f "make test { rlo } *" }}})
status , body = self . post ( "/api/sign" , { "items" : [{ "kind" : "enable" , "rule" : rule [ "id" ]}]})
self . assertEqual ( status , 400 )
self . assertIn ( "U+202E" , body . decode ( "utf-8" ))
self . claim ( "s1" , f "Skills { rlo } " )
ask_id = self . create_ask ( ASK )
shown = next ( item for item in self . snapshot ()[ "inbox" ] if item [ "id" ] == ask_id )
self . assertIn ( rlo , shown [ "to" ])
status , body = self . post ( "/api/sign" , { "items" : [{ ** self . entry ( "ask" , ask_id , "" , "" ), "verb" : "reject" , "channel" : "post" , "reason" : "no" , "to" : shown [ "to" ]}]})
self . assertEqual ( status , 400 )
self . assertIn ( "U+202E" , body . decode ( "utf-8" ))
self . assertEqual ( self . post ( "/api/sign" , { "items" : [ self . entry ( "ask" , ask_id , "" , "" )]})[ 0 ], 200 )
def test_the_hub_keeps_only_permissions_and_sandbox_and_refuses_a_view_unsafe_to_copy ( self ):
self . view ([ self . home_view ()])
files , _ = self . httpd . hub . settings_files ()
self . assertEqual ( sorted ( files [ 0 ][ "settings" ]), [ "permissions" , "sandbox" ])
domain = { "kind" : "settings" , "file" : HOME_FILE , "base" : SHA , "changes" : [{ "list" : "sandbox.network.allowedDomains" , "op" : "add" , "entry" : "example.org" }]}
status , body = self . post ( "/api/firewall/preview" , { "items" : [ domain ]})
self . assertEqual ( status , 200 , body )
self . assertNotIn ( '"env"' , json . loads ( body )[ "diffs" ][ 0 ][ "diff" ])
deep = functools . reduce ( lambda inner , _ : { "x" : inner }, range ( 600 ), {})
for name , extra , reason in (( "600 levels" , deep , "nests deeper than 64" ), ( "lone surrogate" , " \ud800 " , "lone surrogate" )):
with self . subTest ( name = name ):
self . view ([{ ** self . home_view (), "settings" : { "permissions" : { ** PERMISSIONS , "extra" : extra }, "sandbox" : SANDBOX }}])
status , body = self . post ( "/api/firewall/preview" , { "items" : [{ ** domain , "changes" : [ ADD ]}]})
self . assertEqual ( status , 400 , body )
self . assertIn ( reason , body . decode ( "utf-8" ))
def test_groups_and_rule_sets_hold_known_agents_and_stored_rules ( self ):
for name , payload , expected in (
( "unknown session" , { "name" : "builders" , "members" : [ "s1" , "s9" ]}, 400 ),
( "every agent" , { "name" : "builders" , "members" : [ "*" ]}, 400 ),
( "unsorted" , { "name" : "builders" , "members" : [ "s2" , "s1" ]}, 400 ),
( "empty name" , { "name" : " " , "members" : [ "s1" ]}, 400 ),
( "extra key" , { "name" : "builders" , "members" : [ "s1" ], "rule" : "x" }, 400 ),
):
with self . subTest ( name = name ):
self . assertEqual ( self . post ( "/api/firewall/groups" , payload )[ 0 ], expected )
status , body = self . post ( "/api/firewall/groups" , { "name" : "builders" , "members" : [ "s1" , "s2" ]})
self . assertEqual ( status , 201 , body )
group = json . loads ( body )
self . assertEqual ( self . post ( "/api/firewall/groups" , { "name" : "builders" , "members" : [ "s1" ]})[ 0 ], 409 )
self . assertEqual ([( entry [ "name" ], entry [ "members" ]) for entry in self . firewall ()[ "groups" ]], [( "builders" , [ "s1" , "s2" ])])
signer = self . pin ()
rule = self . signed_rule ( signer , { "kind" : "ask" , "tool" : "Bash" , "pattern" : "make *" , "scope" : "/repo*" , "expires" : time . time () + 3600 , "agents" : [ "s1" ]})
for name , payload in (( "no days" , { "name" : "ci" , "days" : 0 , "rules" : [ rule [ "id" ]]}), ( "unknown rule" , { "name" : "ci" , "days" : 7 , "rules" : [ "0123456789abcdef" ]}), ( "no rules" , { "name" : "ci" , "days" : 7 , "rules" : []})):
with self . subTest ( name = name ):
self . assertEqual ( self . post ( "/api/firewall/sets" , payload )[ 0 ], 400 )
status , body = self . post ( "/api/firewall/sets" , { "name" : "ci" , "days" : 7 , "rules" : [ rule [ "id" ]]})
self . assertEqual ( status , 201 , body )
stored = json . loads ( body )
self . assertEqual (( stored [ "days" ], stored [ "rules" ]), ( 7 , [{ "kind" : "ask" , "tool" : "Bash" , "pattern" : "make *" , "scope" : "/repo*" }]))
for path , ident in (( "groups" , group [ "id" ]), ( "sets" , stored [ "id" ])):
with self . subTest ( path = path ):
self . assertEqual ( self . call ( "POST" , f "/api/firewall/ { path } / { ident } /delete" , b "" , self . guard ( self . host ))[ 0 ], 200 )
self . assertEqual ( self . call ( "POST" , f "/api/firewall/ { path } / { ident } /delete" , b "" , self . guard ( self . host ))[ 0 ], 404 )
def signed_rule ( self , signer , fields : dict ) -> dict :
status , _ , body = self . post_json ( "/api/rules/sign" , fields , self . guard ( self . host ))
self . assertEqual ( status , 200 , body )
payload = json . loads ( body )[ "payload" ]
status , _ , body = self . post_json ( "/api/rules" , { "rule" : payload , "assertion" : signer . assertion ( payload , self . origin , "localhost" , PRESENT , 0 ), "enabled" : True }, self . guard ( self . host ))
self . assertEqual ( status , 201 , body )
return json . loads ( body )
def test_a_rule_applies_to_one_agent_a_group_or_every_agent ( self ):
signer = self . pin ()
now = time . time ()
base = { "kind" : "ask" , "tool" : "Bash" , "scope" : "/repo*" , "expires" : now + 3600 }
for name , agents in (( "unknown agent" , [ "s9" ]), ( "unsorted group" , [ "s2" , "s1" ]), ( "pseudo agent" , [ "name:Docs" ]), ( "empty" , [])):
with self . subTest ( name = name ):
self . assertEqual ( self . post_json ( "/api/rules/sign" , { ** base , "pattern" : "make *" , "agents" : agents }, self . guard ( self . host ))[ 0 ], 400 )
self . assertEqual ( self . post_json ( "/api/rules/sign" , { "kind" : "review" , "tool" : "" , "pattern" : "feature/*" , "scope" : "/repo/*" , "expires" : now + 3600 , "agents" : [ "s1" ]}, self . guard ( self . host ))[ 0 ], 400 )
one = self . signed_rule ( signer , { ** base , "pattern" : "make one" , "agents" : [ "s1" ]})
group = self . signed_rule ( signer , { ** base , "pattern" : "make group" , "agents" : [ "s1" , "s2" ]})
every = self . signed_rule ( signer , { ** base , "pattern" : "make every" })
self . assertEqual (( one [ "agents" ], group [ "agents" ], every [ "agents" ]), ([ "s1" ], [ "s1" , "s2" ], [ "*" ]))
self . assertEqual ( one [ "proof" ][ "payload" ][ "agents" ], [ "s1" ])
with mock . patch . object ( batches , "UNDO" , 0.05 ):
asks = {( command , session ): self . create_ask ({ ** ASK , "command" : command , "session" : session }) for command in ( "make one" , "make group" , "make every" ) for session in ( "s1" , "s2" , "s3" )}
time . sleep ( 0.6 )
statuses = { pair : self . ask_status ( ask_id , "0" ) for pair , ask_id in asks . items ()}
self . assertEqual ( statuses , {
( "make one" , "s1" ): "allowed" , ( "make one" , "s2" ): "pending" , ( "make one" , "s3" ): "pending" ,
( "make group" , "s1" ): "allowed" , ( "make group" , "s2" ): "allowed" , ( "make group" , "s3" ): "pending" ,
( "make every" , "s1" ): "allowed" , ( "make every" , "s2" ): "allowed" , ( "make every" , "s3" ): "allowed" ,
})
hook = verifier . Trust ( approvers = self . approvers , replay = self . replay / "hook.json" , origin = self . origin )
relayed = json . loads ( self . get ( f "/api/asks/ { asks [( 'make one' , 's1' )] } ?wait=0" )[ 2 ])[ "proof" ]
verifier . check ( relayed , signing . ask_item ( asks [( "make one" , "s1" )], "Bash" , "make one" , "/repo" , "s1" ), "" , hook , time . time ())
with self . assertRaisesRegex ( signing . Refused , "does not match" ):
verifier . check ( relayed , signing . ask_item ( asks [( "make one" , "s2" )], "Bash" , "make one" , "/repo" , "s2" ), "" , hook , time . time ())
def test_a_decision_rule_scoped_to_an_agent_decides_only_decisions_under_the_name_it_holds_now ( self ):
for session , name in (( "s1" , "Docs" ), ( "s1" , "Main" ), ( "s1" , "Skills" ), ( "s2" , "Main" )):
time . sleep ( 1.1 )
self . claim ( session , name )
self . snapshot ()
held = {( entry [ "session" ], entry [ "name" ]) for entry in self . httpd . hub . names . listed ()}
self . assertLessEqual ({( "s1" , "Docs" ), ( "s1" , "Main" ), ( "s1" , "Skills" ), ( "s2" , "Main" )}, held )
signer = self . pin ()
self . signed_rule ( signer , { "kind" : "decision" , "tool" : "" , "pattern" : "*" , "scope" : "*" , "expires" : time . time () + 3600 , "agents" : [ "s1" ]})
options = [{ "label" : "Yes" , "description" : "" }, { "label" : "No" , "description" : "" }]
with mock . patch . object ( batches , "UNDO" , 0.05 ):
asked = { name : self . tool ( "decision_request" , { "question" : "Merge?" , "options" : options , "agent" : name , "recommended" : "Yes" })[ "structuredContent" ][ "id" ] for name in ( "Skills" , "Main" , "Docs" , "Stage" )}
self . settle ( lambda : self . choice ( asked [ "Skills" ]) == "Yes" )
time . sleep ( 0.3 )
self . assertEqual ({ name : self . choice ( decision ) for name , decision in asked . items ()}, { "Skills" : "Yes" , "Main" : None , "Docs" : None , "Stage" : None })
self . claim ( "s3" , "Skills" )
self . snapshot ()
with mock . patch . object ( batches , "UNDO" , 0.05 ):
shared = self . tool ( "decision_request" , { "question" : "Merge?" , "options" : options , "agent" : "Skills" , "recommended" : "Yes" })[ "structuredContent" ][ "id" ]
time . sleep ( 0.6 )
self . assertIsNone ( self . choice ( shared ))
def test_turning_a_rule_on_needs_a_fresh_passkey_signature_and_turning_it_off_none ( self ):
signer = self . pin ()
rule = self . signed_rule ( signer , { "kind" : "ask" , "tool" : "Bash" , "pattern" : "make *" , "scope" : "/repo*" , "expires" : time . time () + 3600 })
other = self . signed_rule ( signer , { "kind" : "ask" , "tool" : "Bash" , "pattern" : "make other" , "scope" : "/repo*" , "expires" : time . time () + 3600 })
enable = f "/api/rules/ { rule [ 'id' ] } /enable"
self . assertEqual ( self . call ( "POST" , f "/api/rules/ { rule [ 'id' ] } /disable" , b "" , self . guard ( self . host ))[ 0 ], 200 )
unsigned = (( "no body" , b "" ), ( "no proof" , b '{"proof": null}' ), ( "the rule's own signature" , json . dumps ({ "proof" : rule [ "proof" ]}) . encode ()))
for name , body in unsigned :
with self . subTest ( name = name ):
self . assertEqual ( self . call ( "POST" , enable , body , self . guard ( self . host ))[ 0 ], 400 )
self . assertFalse ( self . httpd . hub . rules . get ( rule [ "id" ])[ "enabled" ])
offer = self . prepare ([{ "kind" : "enable" , "rule" : rule [ "id" ]}])
self . assertEqual (( offer [ "enables" ], offer [ "payload" ][ "items" ]), ( rule [ "proof" ][ "payload" ], [ signing . item_hash ( signing . enable_item ( rule [ "proof" ][ "payload" ]))]))
self . assertEqual ( self . post ( "/api/sign" , { "items" : [{ "kind" : "enable" , "rule" : "0123456789abcdef" }]})[ 0 ], 404 )
proof = signer . proof ( offer [ "payload" ], self . origin )
foreign = signer . proof ( self . prepare ([{ "kind" : "enable" , "rule" : other [ "id" ]}])[ "payload" ], self . origin )
for name , body in (( "forged" , { "proof" : key ( - 7 , "intruder" ) . proof ( offer [ "payload" ], self . origin )}), ( "another rule's approval" , { "proof" : foreign })):
with self . subTest ( name = name ):
self . assertEqual ( self . post ( enable , body )[ 0 ], 400 )
self . assertFalse ( self . httpd . hub . rules . get ( rule [ "id" ])[ "enabled" ])
with mock . patch . object ( batches , "UNDO" , 0.05 ):
waiting = self . create_ask ({ ** ASK , "command" : "make x" , "session" : "s1" })
time . sleep ( 0.6 )
self . assertEqual ( self . ask_status ( waiting , "0" ), "pending" )
status , body = self . post ( enable , { "proof" : proof })
self . assertEqual (( status , json . loads ( body )[ "enabled" ]), ( 200 , True ), body )
self . assertEqual ( self . call ( "POST" , f "/api/rules/ { rule [ 'id' ] } /disable" , b "" , self . guard ( self . host ))[ 0 ], 200 )
self . assertEqual ( self . post ( enable , { "proof" : proof })[ 0 ], 400 )
self . assertFalse ( self . httpd . hub . rules . get ( rule [ "id" ])[ "enabled" ])
def test_a_deleted_rule_never_comes_back_with_its_old_proof_and_a_fresh_signature_does ( self ):
signer = self . pin ()
fields = { "kind" : "ask" , "tool" : "Bash" , "pattern" : "make *" , "scope" : "/repo*" , "expires" : time . time () + 3600 }
rule = self . signed_rule ( signer , fields )
old = { "rule" : rule [ "proof" ][ "payload" ], "assertion" : rule [ "proof" ][ "assertion" ], "enabled" : True }
self . assertEqual ( self . post ( "/api/rules" , old )[ 0 ], 409 )
self . assertEqual ( self . call ( "POST" , f "/api/rules/ { rule [ 'id' ] } /delete" , b "" , self . guard ( self . host ))[ 0 ], 200 )
self . assertEqual ( self . post ( "/api/rules" , old )[ 0 ], 409 )
self . assertIsNone ( self . httpd . hub . rules . get ( rule [ "id" ]))
unsigned = json . loads ( self . post ( "/api/rules/sign" , fields )[ 1 ])[ "payload" ]
object . __setattr__ ( self . httpd . hub , "offers" , rules . Offers ())
self . assertEqual ( self . post ( "/api/rules" , { "rule" : unsigned , "assertion" : signer . assertion ( unsigned , self . origin , "localhost" , PRESENT , 0 ), "enabled" : True })[ 0 ], 409 )
fresh = self . signed_rule ( signer , fields )
self . assertEqual ([ stored [ "id" ] for stored in self . httpd . hub . rules . listed ()], [ fresh [ "id" ]])
with mock . patch . object ( batches , "UNDO" , 0.05 ):
asked = self . create_ask ({ ** ASK , "command" : "make x" , "session" : "s1" })
time . sleep ( 0.6 )
self . assertEqual ( self . ask_status ( asked , "0" ), "allowed" )
def test_a_group_changed_after_signing_grants_nothing_beyond_the_signed_members ( self ):
self . claim ( "s3" , "Evil" )
self . snapshot ()
signer = self . pin ()
group = json . loads ( self . post ( "/api/firewall/groups" , { "name" : "builders" , "members" : [ "s1" , "s2" ]})[ 1 ])
self . signed_rule ( signer , { "kind" : "ask" , "tool" : "Bash" , "pattern" : "make *" , "scope" : "/repo*" , "expires" : time . time () + 3600 , "agents" : group [ "members" ]})
self . assertEqual ( self . call ( "POST" , f "/api/firewall/groups/ { group [ 'id' ] } /delete" , b "" , self . guard ( self . host ))[ 0 ], 200 )
self . assertEqual ( self . post ( "/api/firewall/groups" , { "name" : "builders" , "members" : [ "s1" , "s2" , "s3" ]})[ 0 ], 201 )
with mock . patch . object ( batches , "UNDO" , 0.05 ):
asks = { session : self . create_ask ({ ** ASK , "command" : "make x" , "session" : session }) for session in ( "s1" , "s3" )}
time . sleep ( 0.6 )
self . assertEqual ({ session : self . ask_status ( ask_id , "0" ) for session , ask_id in asks . items ()}, { "s1" : "allowed" , "s3" : "pending" })
def test_the_signed_target_decides_and_an_untargeted_rule_reaches_every_agent ( self ):
now = time . time ()
plain = signing . rule_payload ( "0123456789abcdef" , [ "ask" ], "Bash" , "make *" , "*" , int ( now ) + 600 )
item = signing . ask_item ( "fedcba9876543210" , "Bash" , "make x" , "/repo" , "s2" )
self . assertTrue ( signing . rule_allows ( plain , item , "" , now ))
self . assertTrue ( signing . rule_allows ( signing . targeted ( plain , [ "*" ]), item , "" , now ))
self . assertTrue ( signing . rule_allows ( signing . targeted ( plain , [ "s1" , "s2" ]), item , "" , now ))
self . assertFalse ( signing . rule_allows ( signing . targeted ( plain , [ "s1" ]), item , "" , now ))
review = signing . rule_payload ( "0123456789abcdef" , [ "review" ], "" , "*" , "*" , int ( now ) + 600 )
commit = signing . review_item ( "fedcba9876543210" , "/repo/.git" , "/repo" , "feature/x" , "0" * 40 )
self . assertTrue ( signing . rule_allows ( review , commit , "pass" , now ))
self . assertFalse ( signing . rule_allows ( signing . targeted ( review , [ "s1" ]), commit , "pass" , now ))
for agents in ([], [ "s2" , "s1" ], [ "s1" , "s1" ], [ "*" , "s1" ], "s1" , [ 3 ]):
with self . subTest ( agents = agents ), self . assertRaises ( signing . Refused ):
signing . checked_rule ( signing . targeted ( plain , agents ), now )
subject = { "recommended" : "Yes" , "agent" : "Skills" , "sessions" : { "s1" }}
stored = { "kind" : "decision" , "pattern" : "*" , "enabled" : True , "expires" : now + 600 }
targeted = { ** stored , "proof" : { "payload" : signing . targeted ( review , [ "s2" ])}}
self . assertFalse ( rules . rule_matches ( targeted , "decision" , subject , now ))
self . assertTrue ( rules . rule_matches ({ ** stored , "proof" : { "payload" : signing . targeted ( review , [ "s1" ])}}, "decision" , subject , now ))