AM-D3 deny: a user's subscribe deny is written, compared and kept
The grants part composes a subscribe deny where a node's tool runner does not honour the approval mark; the user list must carry it to the bus, and an added deny is a narrowing the user-list guard lets pass as no right lost. Builds: design 46 7 §6 (Permissions.SubscribeDeny, User subscribe_deny, comparison and differences, the guard's narrowing) Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h
This commit is contained in:
@@ -1265,6 +1265,10 @@ func TestGrants(t *testing.T) {
|
||||
for i := range readable {
|
||||
readable[i].PublishDeny = []string{}
|
||||
}
|
||||
// A subscribe the shadow withholds (design 46 approval mark §6) where the loaded list withholds none, as on the first
|
||||
// composition after the release: a narrowing, no right lost. Its reverse, a node gaining approval-mark/1: a right added.
|
||||
withheld := slices.Clone(shadow)
|
||||
withheld[x].SubscribeDeny = []string{"mesh.mod.m.tool.execute", "mesh.mod.m.tool.execute.*"}
|
||||
// The live comparison the operator's yes was refused on, 2026-10-27 21:19 UTC (issue 1945): 41 users differ, every
|
||||
// difference an added right. Read whole; a row's mutate makes one of the cases that must still refuse.
|
||||
var live struct {
|
||||
@@ -1309,6 +1313,8 @@ func TestGrants(t *testing.T) {
|
||||
{"only a right added", fewer, nil, nil, nil, []string{"a.mod-x"}, false, nil, nil, 1},
|
||||
{"a deny added refuses", readable, nil, nil, nil, []string{"a.mod-x"}, false, nil, []string{"a.mod-x"}, 1},
|
||||
{"a deny the loaded list cannot say refuses a user whose grants differ", fewer, nil, nil, nil, []string{"a.mod-x"}, false, nil, []string{"a.mod-x"}, 1},
|
||||
{"a subscribe withheld passes as no right lost", shadow, nil, nil, nil, []string{"a.mod-x"}, false, nil, nil, 0},
|
||||
{"a subscribe no longer withheld is a right added", withheld, nil, nil, nil, []string{"a.mod-x"}, false, nil, nil, 1},
|
||||
{"captured 21:19: only added rights", nil, nil, nil, nil, nil, false, captured(nil), nil, 41},
|
||||
{"captured, a right removed", nil, nil, nil, nil, nil, false, captured(func(c *grants.Comparison) {
|
||||
nodeAce(c).SubscribeDropped = []string{"mesh.mod.mesh-vault.event.secret-changed"}
|
||||
@@ -1333,6 +1339,9 @@ func TestGrants(t *testing.T) {
|
||||
if strings.Contains(row.name, "deny") {
|
||||
from = denied
|
||||
}
|
||||
if strings.Contains(row.name, "withheld passes") {
|
||||
from = withheld
|
||||
}
|
||||
c = grants.Compare(from, row.loaded, grants.Placed(in))
|
||||
var differ []string
|
||||
for _, d := range c.Differ {
|
||||
|
||||
@@ -601,6 +601,12 @@ func TestTheCopiedComposerComposesAsTheControllers(t *testing.T) {
|
||||
if err != nil || perr != nil || !strings.Contains(list, " users = [\n"+AccountsEntry(filled[0].Username(), "$2a$11$h", perms)+" ]\n") {
|
||||
t.Errorf("the accounts entry is not ComposeAccounts' own: %v %v\n%s", err, perr, list)
|
||||
}
|
||||
// A subscribe deny (design 46 approval mark §6) is written as the server's deny beside its allow, and outranks it.
|
||||
withheld := Permissions{Publish: []string{"a"}, Subscribe: []string{"mesh.mod.m.tool.>"}, SubscribeDeny: []string{"mesh.mod.m.tool.execute"}}
|
||||
if entry := AccountsEntry("u", "h", withheld); !strings.Contains(entry, `subscribe: { allow: ["mesh.mod.m.tool.>"], deny: ["mesh.mod.m.tool.execute"] }`) ||
|
||||
MaySubscribe(withheld, "mesh.mod.m.tool.execute") || !MaySubscribe(withheld, "mesh.mod.m.tool.read") {
|
||||
t.Errorf("a subscribe deny is written as %s", entry)
|
||||
}
|
||||
c, _ := ConsumerFor(Principal{Kind: KindModule, Node: "a", Module: "m", Consumes: []string{"x.happened"}})
|
||||
cfg := ConsumerConfig(c)
|
||||
if cfg.Durable != "a_m" || cfg.AckPolicy != jetstream.AckExplicitPolicy || cfg.AckWait != 30*time.Second ||
|
||||
|
||||
@@ -388,8 +388,14 @@ func MayPublish(perms Permissions, subject string) bool {
|
||||
return false
|
||||
}
|
||||
|
||||
// MaySubscribe says whether a principal with these permissions may subscribe to (and so answer) a subject.
|
||||
// MaySubscribe says whether a principal with these permissions may subscribe to (and so answer) a subject: an allow
|
||||
// covers it and no deny does.
|
||||
func MaySubscribe(perms Permissions, subject string) bool {
|
||||
for _, d := range perms.SubscribeDeny {
|
||||
if SubjectsOverlap(d, subject) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
for _, a := range perms.Subscribe {
|
||||
if SubjectsOverlap(a, subject) {
|
||||
return true
|
||||
@@ -595,6 +601,10 @@ type Permissions struct {
|
||||
// denied to everybody whose grant is wide enough to reach them. The server's deny outranks its allow.
|
||||
PublishDeny []string
|
||||
Subscribe []string
|
||||
// SubscribeDeny are subjects the principal may not subscribe to although an allow covers them (design 46 approval
|
||||
// mark §6): every marked subject of a module its runtime carries, where the node's tool runner does not honour the mark.
|
||||
// The server's deny outranks its allow of `mesh.mod.<module>.tool.>`.
|
||||
SubscribeDeny []string
|
||||
// AllowResponses lets a principal reply to a request it received, on the reply subject that
|
||||
// request carried, once.
|
||||
//
|
||||
@@ -1562,7 +1572,11 @@ func AccountsEntry(user, passwordHash string, perms Permissions) string {
|
||||
} else {
|
||||
fmt.Fprintf(&b, " publish: { allow: [%s] }\n", quoted(perms.Publish))
|
||||
}
|
||||
fmt.Fprintf(&b, " subscribe: { allow: [%s] }\n", quoted(perms.Subscribe))
|
||||
if len(perms.SubscribeDeny) > 0 {
|
||||
fmt.Fprintf(&b, " subscribe: { allow: [%s], deny: [%s] }\n", quoted(perms.Subscribe), quoted(perms.SubscribeDeny))
|
||||
} else {
|
||||
fmt.Fprintf(&b, " subscribe: { allow: [%s] }\n", quoted(perms.Subscribe))
|
||||
}
|
||||
if perms.AllowResponses {
|
||||
fmt.Fprintf(&b, " allow_responses: { max: 1, ttl: \"%dm\" }\n", int(ResponseTTL/time.Minute))
|
||||
}
|
||||
|
||||
@@ -75,6 +75,7 @@ func GrantWaits(accounts []string, composed, loaded map[string]User, unknown str
|
||||
if l.PublishDeny != nil {
|
||||
n += len(minus(l.PublishDeny, c.PublishDeny))
|
||||
}
|
||||
n += len(minus(l.SubscribeDeny, c.SubscribeDeny))
|
||||
if n > 0 {
|
||||
adds = append(adds, fmt.Sprintf("%s (%d permissions)", user, n))
|
||||
}
|
||||
|
||||
@@ -60,7 +60,8 @@ func KeepLoaded(composed, loaded []User, inForce map[string]User) map[string]Use
|
||||
// Every deny any list says is kept: a deny the composer drops while it composes part of the mesh would widen the
|
||||
// user (the composer gives every composed user a deny, empty or not, so an intersection would drop the list in
|
||||
// force's).
|
||||
u := User{User: name, Publish: c.Publish, Subscribe: c.Subscribe, AllowResponses: c.AllowResponses, PublishDeny: c.PublishDeny}
|
||||
u := User{User: name, Publish: c.Publish, Subscribe: c.Subscribe, AllowResponses: c.AllowResponses, PublishDeny: c.PublishDeny,
|
||||
SubscribeDeny: c.SubscribeDeny}
|
||||
for _, o := range from {
|
||||
u.Publish = set(append(slices.Clone(u.Publish), o.Publish...))
|
||||
u.Subscribe = set(append(slices.Clone(u.Subscribe), o.Subscribe...))
|
||||
@@ -68,6 +69,9 @@ func KeepLoaded(composed, loaded []User, inForce map[string]User) map[string]Use
|
||||
if o.PublishDeny != nil || u.PublishDeny != nil {
|
||||
u.PublishDeny = set(append(slices.Clone(u.PublishDeny), o.PublishDeny...))
|
||||
}
|
||||
if o.SubscribeDeny != nil || u.SubscribeDeny != nil {
|
||||
u.SubscribeDeny = set(append(slices.Clone(u.SubscribeDeny), o.SubscribeDeny...))
|
||||
}
|
||||
}
|
||||
if u.Publish == nil {
|
||||
u.Publish = []string{}
|
||||
@@ -94,6 +98,11 @@ func Losses(now, had User) []string {
|
||||
if had.AllowResponses && !now.AllowResponses {
|
||||
out = append(out, "responses")
|
||||
}
|
||||
// A subscribe deny now adds is a narrowing and no word of had lost (design 46 approval mark §6); one had held that now
|
||||
// drops widens the user past it.
|
||||
for _, s := range minus(had.SubscribeDeny, now.SubscribeDeny) {
|
||||
out = append(out, "subscribe deny dropped "+s)
|
||||
}
|
||||
if had.PublishDeny != nil {
|
||||
for _, s := range minus(now.PublishDeny, had.PublishDeny) {
|
||||
out = append(out, "deny "+s)
|
||||
|
||||
@@ -39,7 +39,7 @@ func ComposeEach(r buscompose.Records) ([]User, map[string]string, error) {
|
||||
continue
|
||||
}
|
||||
out = append(out, User{User: p.Username(), Publish: set(perms.Publish), Subscribe: set(perms.Subscribe),
|
||||
AllowResponses: perms.AllowResponses, PublishDeny: set(perms.PublishDeny)})
|
||||
AllowResponses: perms.AllowResponses, PublishDeny: set(perms.PublishDeny), SubscribeDeny: set(perms.SubscribeDeny)})
|
||||
}
|
||||
sort.Slice(out, func(i, j int) bool { return out[i].User < out[j].User })
|
||||
return out, refused, nil
|
||||
@@ -81,7 +81,7 @@ func withKept(users []User, kept map[string]User) []User {
|
||||
// (buscompose.AccountsEntry), so the bus reads it as it read the list in force.
|
||||
func keptEntry(u User, hash string) string {
|
||||
return buscompose.AccountsEntry(u.User, hash, buscompose.Permissions{Publish: u.Publish, PublishDeny: u.PublishDeny,
|
||||
Subscribe: u.Subscribe, AllowResponses: u.AllowResponses})
|
||||
Subscribe: u.Subscribe, SubscribeDeny: u.SubscribeDeny, AllowResponses: u.AllowResponses})
|
||||
}
|
||||
|
||||
// withEntries puts entries at the end of the accounts block's users, before it closes.
|
||||
|
||||
@@ -24,6 +24,9 @@ type User struct {
|
||||
// PublishDeny is what the user may not publish though an allow reaches it (buscompose's ControllerOnly). The bus
|
||||
// module's nats_users answers none today, so a loaded user's is nil, read as unknown; empty and not nil once it says.
|
||||
PublishDeny []string `json:"publish_deny,omitempty"`
|
||||
// SubscribeDeny is what the user may not subscribe to though an allow reaches it: the marked subjects withheld from a
|
||||
// runtime whose tool runner does not honour the mark (design 46 approval mark §6). Nil and empty are both none.
|
||||
SubscribeDeny []string `json:"subscribe_deny,omitempty"`
|
||||
// Hash is the bcrypt hash the vault holds for the user (WithHashes): in memory alone, never in a digest, a compare
|
||||
// or the part's state, and empty for a loaded user.
|
||||
Hash string `json:"-"`
|
||||
@@ -227,11 +230,17 @@ type UserDiff struct {
|
||||
// none): it cannot be compared, so it is no added right either (ADR 0562 §2).
|
||||
DenyAdded []string `json:"deny_added,omitempty"`
|
||||
DenyUnread []string `json:"deny_unread,omitempty"`
|
||||
// SubscribeDenyAdded is what the shadow list withholds from the user's subscriptions and the loaded list does not: a
|
||||
// narrowing, which loses no right and passes the guard at once (design 46 approval mark §6). SubscribeDenyDropped is
|
||||
// what the loaded list withholds and the shadow list no longer does: a right added.
|
||||
SubscribeDenyAdded []string `json:"subscribe_deny_added,omitempty"`
|
||||
SubscribeDenyDropped []string `json:"subscribe_deny_dropped,omitempty"`
|
||||
}
|
||||
|
||||
// same says the user's grants agree in both lists.
|
||||
func (d UserDiff) same() bool {
|
||||
return len(d.PublishAdded)+len(d.PublishDropped)+len(d.SubscribeAdded)+len(d.SubscribeDropped)+len(d.DenyAdded) == 0 && d.Responses == ""
|
||||
return len(d.PublishAdded)+len(d.PublishDropped)+len(d.SubscribeAdded)+len(d.SubscribeDropped)+len(d.DenyAdded)+
|
||||
len(d.SubscribeDenyAdded)+len(d.SubscribeDenyDropped) == 0 && d.Responses == ""
|
||||
}
|
||||
|
||||
// Comparison is the shadow list against the loaded list.
|
||||
@@ -320,11 +329,12 @@ func (c Comparison) Removing() []string {
|
||||
func (c Comparison) AddedRights() []UserDiff {
|
||||
var out []UserDiff
|
||||
for _, d := range c.Differ {
|
||||
a := UserDiff{User: d.User, PublishAdded: d.PublishAdded, SubscribeAdded: d.SubscribeAdded}
|
||||
a := UserDiff{User: d.User, PublishAdded: d.PublishAdded, SubscribeAdded: d.SubscribeAdded,
|
||||
SubscribeDenyDropped: d.SubscribeDenyDropped}
|
||||
if !d.responsesLost() {
|
||||
a.Responses = d.Responses
|
||||
}
|
||||
if len(a.PublishAdded)+len(a.SubscribeAdded) > 0 || a.Responses != "" {
|
||||
if len(a.PublishAdded)+len(a.SubscribeAdded)+len(a.SubscribeDenyDropped) > 0 || a.Responses != "" {
|
||||
out = append(out, a)
|
||||
}
|
||||
}
|
||||
@@ -355,6 +365,8 @@ func Compare(shadow, loaded []User, placed func(user string) bool) Comparison {
|
||||
if l.PublishDeny != nil {
|
||||
d.DenyAdded = minus(s.PublishDeny, l.PublishDeny)
|
||||
}
|
||||
// A loaded list that says no subscribe deny withholds none: the bus holds none it was not given.
|
||||
d.SubscribeDenyAdded, d.SubscribeDenyDropped = minus(s.SubscribeDeny, l.SubscribeDeny), minus(l.SubscribeDeny, s.SubscribeDeny)
|
||||
if d.same() {
|
||||
// The same allows compose the same deny: one composer derives it from them.
|
||||
c.Same++
|
||||
|
||||
Reference in New Issue
Block a user