一次收口 2026-11-06 的九项能力(CHANGELOG 1.5.4 → 1.8.0): - 自检探针(readiness.go):check_readiness / check_answerable 两个只读探针,把 「本体里没有」「我没权限看」「模型没抽全」三种空结果原因拆开 - 读路径语义钉死(scope.go):标记与分级的可见范围统一由 Scope 产出,实例分级 为空时继承类型默认级(fail-closed),列表与详情口径一致 - 行级可改性轴(object_owner.go):归属只收窄不宽于 grants,所有对象写路径统一 走 canWriteObject,归属查询失败即拒绝 - 公理第 6 类 certification:认证位保护人工策展内容,AI 重摄取不再覆盖已认证条目 - 跨版本结构 diff(schema_diff.go):schema_snapshots 全量快照 + diff 端点,机器 事实与人工策展分组呈现 - 分区维度 zone:分区绑类型、命中任一即可见,读路径一律带 zone 条件 - 统一分页信封(pagination.go):列表回包统一 count/total/limit/offset/has_more/ truncated,total 与 items 同源 - MCP 长任务进度(mcp_progress.go):客户端带 progressToken 才走 SSE 进度帧 - 本体 schema 导入(ontology_import.go):Turtle 导入 + 四道 fail-fast 闸门 + 整事务 + (source, external_id) 幂等 + IRI 往返不变式 MCP 工具清单并入单一注册表(mcp_registry.go),对外声明与实际可调不再各说各话; 工具数 42 → 54(只读 27 / 写入 27),注册表与分发 case 的双向漂移由 AST 单测拦截。 CHANGELOG 编号整理:新「认证位 + 行级归属」条目由 1.6.0 改为 1.5.6(1.6.x 留给 分区与结构 diff),2026-09-20 的 GB/T 规划稿改标「规划稿·未发布」——该能力已并入 v1.5.1,避免与正式发布的版本号重复。 Co-Authored-By: Claude Code <[email protected]>
236 lines
7.3 KiB
Go
236 lines
7.3 KiB
Go
package main
|
||
|
||
// 行级可改性轴(object_owners):谁可以改这一行。
|
||
//
|
||
// 与 clearance(可见性轴)正交,两轴各管一件事:
|
||
//
|
||
// clearance / marking —— 「看不看得到」 (object_markings + principal_clearances)
|
||
// owner —— 「能不能改」 (object_owners)
|
||
//
|
||
// 判定口径(刻意不与 grants 重叠):
|
||
//
|
||
// - grants 表是「能做什么动作」的唯一真源(read/write/delete/apply…);
|
||
// - owner 是在 grant 之上的一层**收窄**:对象设有归属时,非归属方即便持有该类型的
|
||
// 写授权,也不能改这一行;
|
||
// - 对象**未设归属**(无 owner 行)→ 不收窄,历史行为一字不变(向后兼容);
|
||
// - manager 不受归属限制(与 CanRead / CanWrite 的 manager 豁免一致);
|
||
// - 组归属:组成员获得该行的可改性,**且仅限该行**——不扩大任何全局权限。
|
||
//
|
||
// 「归属只收窄、不放宽」是刻意的:若归属本身就能授予写权限,那么「谁拥有写权限」
|
||
// 就散落在 grants 表之外,Access Control 界面看到的授权清单将不等于实际权限。
|
||
// 归属的职责是回答「这一行归谁管」,不是回答「谁能写」。
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
"sort"
|
||
"strings"
|
||
)
|
||
|
||
// 归属种类。
|
||
const (
|
||
OwnerKindPrincipal = "principal" // 主体(账号)
|
||
OwnerKindGroup = "group" // 组
|
||
)
|
||
|
||
// ObjectOwner 归属条目:某行的归属方。
|
||
type ObjectOwner struct {
|
||
Kind string `json:"kind"` // principal | group
|
||
Name string `json:"name"`
|
||
}
|
||
|
||
// loadObjectOwners 取某对象的归属集合(无归属返回空切片,非 nil)。
|
||
func (a *app) loadObjectOwners(ctx context.Context, objType, objPK string) ([]ObjectOwner, error) {
|
||
rows, err := a.pool.Query(ctx,
|
||
`SELECT owner_kind, owner_name FROM object_owners
|
||
WHERE object_type=$1 AND object_pk=$2 ORDER BY owner_kind, owner_name`, objType, objPK)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
out := []ObjectOwner{}
|
||
for rows.Next() {
|
||
var o ObjectOwner
|
||
if err := rows.Scan(&o.Kind, &o.Name); err == nil {
|
||
out = append(out, o)
|
||
}
|
||
}
|
||
return out, rows.Err()
|
||
}
|
||
|
||
// principalGroupNames 取某主体所属的全部组。
|
||
func (a *app) principalGroupNames(ctx context.Context, principal string) (map[string]bool, error) {
|
||
out := map[string]bool{}
|
||
if principal == "" {
|
||
return out, nil
|
||
}
|
||
rows, err := a.pool.Query(ctx, `SELECT group_name FROM principal_groups WHERE principal=$1`, principal)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
for rows.Next() {
|
||
var g string
|
||
if err := rows.Scan(&g); err == nil {
|
||
out[g] = true
|
||
}
|
||
}
|
||
return out, rows.Err()
|
||
}
|
||
|
||
// ownerDecision 归属判定(纯函数,不触库,便于单测)。
|
||
//
|
||
// 返回 (isOwner, hasOwners):
|
||
// - hasOwners=false:该行未设归属 → 不限制任何人(isOwner 恒为 true);
|
||
// - hasOwners=true:只有归属方(本人或所属组)才是 owner。
|
||
func ownerDecision(owners []ObjectOwner, principal string, groups map[string]bool) (isOwner bool, hasOwners bool) {
|
||
if len(owners) == 0 {
|
||
return true, false
|
||
}
|
||
for _, o := range owners {
|
||
switch o.Kind {
|
||
case OwnerKindPrincipal:
|
||
if o.Name == principal {
|
||
return true, true
|
||
}
|
||
case OwnerKindGroup:
|
||
if groups[o.Name] {
|
||
return true, true
|
||
}
|
||
}
|
||
}
|
||
return false, true
|
||
}
|
||
|
||
// principalOwnsObject 判定 principal 是否持有该行的可改性。
|
||
func (a *app) principalOwnsObject(ctx context.Context, principal, objType, objPK string) (bool, bool, error) {
|
||
owners, err := a.loadObjectOwners(ctx, objType, objPK)
|
||
if err != nil {
|
||
return false, true, err
|
||
}
|
||
if len(owners) == 0 {
|
||
return true, false, nil
|
||
}
|
||
groups, err := a.principalGroupNames(ctx, principal)
|
||
if err != nil {
|
||
return false, true, err
|
||
}
|
||
isOwner, hasOwners := ownerDecision(owners, principal, groups)
|
||
return isOwner, hasOwners, nil
|
||
}
|
||
|
||
// canWriteObject 写权限判定 = grant 授权 ∧ 行级归属允许。
|
||
//
|
||
// 这是**唯一的写权限收敛点**:所有对象写路径(create/update/delete/restore/
|
||
// batch/action/链接)都改走本函数,不各自散落判据。
|
||
//
|
||
// fail-closed:归属查询失败 → 拒绝(读不到归属 ≠ 可以改)。
|
||
// manager 豁免归属(与 CanWrite/CanRead 的 manager 特例一致)。
|
||
func (a *app) canWriteObject(ctx context.Context, authz *Authz, action, objType, objPK string) bool {
|
||
if authz == nil {
|
||
return false
|
||
}
|
||
if authz.Principal == "manager" {
|
||
return true
|
||
}
|
||
if !authz.CanWrite(action, objType, objPK) {
|
||
return false
|
||
}
|
||
isOwner, _, err := a.principalOwnsObject(ctx, authz.Principal, objType, objPK)
|
||
if err != nil {
|
||
return false
|
||
}
|
||
return isOwner
|
||
}
|
||
|
||
// normalizeOwners 校验并归一化归属条目:种类合法、去重、保序。
|
||
// 空名单合法(= 清空归属)。
|
||
func normalizeOwners(in []ObjectOwner) ([]ObjectOwner, error) {
|
||
out := []ObjectOwner{}
|
||
seen := map[string]bool{}
|
||
for _, o := range in {
|
||
kind := strings.TrimSpace(o.Kind)
|
||
if kind == "" {
|
||
kind = OwnerKindPrincipal
|
||
}
|
||
if kind != OwnerKindPrincipal && kind != OwnerKindGroup {
|
||
return nil, fmt.Errorf("owner.kind 只支持 principal 或 group,收到 %q", o.Kind)
|
||
}
|
||
name := strings.TrimSpace(o.Name)
|
||
if name == "" {
|
||
return nil, fmt.Errorf("owner.name 必填")
|
||
}
|
||
k := kind + "|" + name
|
||
if seen[k] {
|
||
continue
|
||
}
|
||
seen[k] = true
|
||
out = append(out, ObjectOwner{Kind: kind, Name: name})
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
// ownerWritableAdvisory 检查归属方当前是否真的持有写授权,
|
||
// 返回「其实改不动」的归属方名单(纯提示,不阻断赋值)。
|
||
//
|
||
// 归属只收窄不放宽,所以一个没有 write 授权的归属方拿到行也改不动——
|
||
// 这在「先设归属、后发授权」的编排下很常见,因此只提示不拒绝。
|
||
func (a *app) ownerWritableAdvisory(ctx context.Context, owners []ObjectOwner, objType, objPK string) []string {
|
||
var blind []string
|
||
for _, o := range owners {
|
||
switch o.Kind {
|
||
case OwnerKindPrincipal:
|
||
if !a.principalCanWrite(ctx, o.Name, objType, objPK) {
|
||
blind = append(blind, o.Name)
|
||
}
|
||
case OwnerKindGroup:
|
||
members, err := a.groupMembers(ctx, o.Name)
|
||
if err != nil || len(members) == 0 {
|
||
blind = append(blind, o.Name+"(组内无成员或查询失败)")
|
||
continue
|
||
}
|
||
any := false
|
||
for _, m := range members {
|
||
if a.principalCanWrite(ctx, m, objType, objPK) {
|
||
any = true
|
||
break
|
||
}
|
||
}
|
||
if !any {
|
||
blind = append(blind, o.Name+"(组内无成员持有写授权)")
|
||
}
|
||
}
|
||
}
|
||
sort.Strings(blind)
|
||
return blind
|
||
}
|
||
|
||
// principalCanWrite 查某主体是否持有对该对象的写授权(不含归属判定)。
|
||
func (a *app) principalCanWrite(ctx context.Context, principal, objType, objPK string) bool {
|
||
if principal == "manager" {
|
||
return true
|
||
}
|
||
az, err := a.loadAuthz(ctx, principal, true)
|
||
if err != nil || az == nil {
|
||
return false
|
||
}
|
||
return az.CanWrite("write", objType, objPK)
|
||
}
|
||
|
||
// groupMembers 取某组成员(有序)。
|
||
func (a *app) groupMembers(ctx context.Context, group string) ([]string, error) {
|
||
rows, err := a.pool.Query(ctx, `SELECT principal FROM principal_groups WHERE group_name=$1 ORDER BY principal`, group)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
out := []string{}
|
||
for rows.Next() {
|
||
var p string
|
||
if err := rows.Scan(&p); err == nil {
|
||
out = append(out, p)
|
||
}
|
||
}
|
||
return out, rows.Err()
|
||
}
|