Web 框架集成

package authz

import (
	"net/http"

	"github.com/casbin/casbin/v3"
	"github.com/gin-gonic/gin"
)

func NewAuthz(e *casbin.SyncedEnforcer) gin.HandlerFunc {
	return func(c *gin.Context) {
		// 1. sub：由前置的 JWT 中间件放入 Context
		sub, exists := c.Get("userID")
		if !exists {
			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"msg": "未登录"})
			return
		}

		// 2. obj / act：URL 路径与 HTTP 方法
		obj := c.Request.URL.Path // 不含 query string，避免 keyMatch 踩坑
		act := c.Request.Method

		// 3. 判定
		ok, err := e.Enforce(sub.(string), obj, act)
		if err != nil {
			// 模型/参数错误属于服务端问题，不能吞成 403
			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"msg": "权限系统错误"})
			return
		}
		if !ok {
			c.AbortWithStatusJSON(http.StatusForbidden, gin.H{"msg": "无权访问"})
			return
		}
		c.Next()
	}
}

// 路由注册：认证在前，授权在后
r := gin.Default()
api := r.Group("/api")
api.Use(jwtAuth())            // 解析 token → c.Set("userID", claims.Sub)
api.Use(authz.NewAuthz(e))    // Casbin 判定
{
	api.GET("/articles/:id", getArticle)
	api.POST("/articles", createArticle)
}

// 方案 B：token 里带角色，直接用角色做 sub
roles := claims.Roles // ["editor", "viewer"]
allowed := false
for _, role := range roles {
	if ok, _ := e.Enforce(role, obj, act); ok {
		allowed = true
		break
	}
}

import "github.com/gin-contrib/authz"

r.Use(authz.NewAuthorizer(e)) // 内部：sub 取 HTTP Basic Auth 用户名

func updateArticle(c *gin.Context) {
	article := mustGetArticle(c) // 查出文章
	userID := c.GetString("userID")

	// 对象级判定：ABAC，article 作为结构体传入
	ok, err := enforcer.Enforce(userID, article, "edit")
	if err != nil || !ok {
		c.JSON(http.StatusForbidden, gin.H{"msg": "不能编辑他人文章"})
		return
	}
	// ... 执行更新
}

import (
	"context"

	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

func AuthzInterceptor(e *casbin.SyncedEnforcer) grpc.UnaryServerInterceptor {
	return func(ctx context.Context, req any, info *grpc.UnaryServerInfo,
		handler grpc.UnaryHandler) (any, error) {

		userID, err := userFromContext(ctx) // 从 metadata 的 token 解析
		if err != nil {
			return nil, status.Error(codes.Unauthenticated, "未登录")
		}

		// obj 用 gRPC 全方法名，如 /pkg.ArticleService/CreateArticle
		ok, err := e.Enforce(userID, info.FullMethod, "call")
		if err != nil {
			return nil, status.Error(codes.Internal, "权限系统错误")
		}
		if !ok {
			return nil, status.Error(codes.PermissionDenied, "无权调用")
		}
		return handler(ctx, req)
	}
}

// 注册
s := grpc.NewServer(grpc.ChainUnaryInterceptor(authInterceptor, AuthzInterceptor(e)))

p, role:editor, /pkg.ArticleService/*, call
p, role:viewer, /pkg.ArticleService/GetArticle, call

// GET /admin/roles/:role/permissions —— 查看角色权限
func getRolePerms(c *gin.Context) {
	perms, _ := e.GetFilteredPolicy(0, c.Param("role"))
	c.JSON(200, perms)
}

// PUT /admin/users/:id/roles —— 重设用户角色
func setUserRoles(c *gin.Context) {
	var req struct{ Roles []string `json:"roles"` }
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(400, gin.H{"msg": err.Error()})
		return
	}
	user := "user:" + c.Param("id")
	e.DeleteRolesForUser(user)             // 先清后设
	e.AddRolesForUser(user, req.Roles)
	c.Status(204)
}