perms-system-server/internal/server/permserver.go

package server

import (
	"context"
	"errors"
	"fmt"
	"net"
	"time"

	"perms-system-server/internal/consts"
	authHelper "perms-system-server/internal/logic/auth"
	pub "perms-system-server/internal/logic/pub"
	"perms-system-server/internal/middleware"
	userModel "perms-system-server/internal/model/user"
	"perms-system-server/internal/svc"
	"perms-system-server/pb"

	"github.com/zeromicro/go-zero/core/limit"
	"github.com/zeromicro/go-zero/core/logx"
	"golang.org/x/crypto/bcrypt"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/peer"
	"google.golang.org/grpc/status"
)

// unknownPeerBucket 当无法解析对端 IP 时共享的限流桶 key。
// 生产环境 gRPC-over-TCP 必然有 peer.Addr，正常流量不会落到这里；此常量仅为 in-process/socket
// 等边缘路径兜底，避免 M-7 审计指出的"按 p.Addr.String() 取完整 host:port 导致限流形同虚设"的
// 随端口漂移问题。共享同一个 key 会放大 DoS 面（所有未知 peer 共用一个计数器），但在此类路径
// 不走真实业务流量的前提下收益足够。
const unknownPeerBucket = "unknown"

// extractClientIP 从 gRPC context 中提取对端 IP。显式剥离端口号（M-7）：gRPC 的 p.Addr.String()
// 形如 "1.2.3.4:54321"，端口每次连接都变，若直接作为限流 key 相当于没限流。
// 解析失败返回 error，由上层按场景决定是 fail-close（RefreshToken 敏感路径）还是降级到 unknown 桶
// （VerifyToken 契约层约束不允许返回 error）。
func extractClientIP(ctx context.Context) (string, error) {
	p, ok := peer.FromContext(ctx)
	if !ok || p == nil || p.Addr == nil {
		return "", errors.New("peer not identifiable")
	}
	host, _, err := net.SplitHostPort(p.Addr.String())
	if err != nil || host == "" {
		return "", errors.New("peer address invalid")
	}
	return host, nil
}

// PermServer 权限管理系统 gRPC 服务实现，供接入产品的服务端调用。
type PermServer struct {
	svcCtx *svc.ServiceContext
	pb.UnimplementedPermServiceServer
}

func NewPermServer(svcCtx *svc.ServiceContext) *PermServer {
	return &PermServer{svcCtx: svcCtx}
}

// SyncPermissions 同步权限声明。产品服务端通过 appKey/appSecret 认证后批量同步权限定义（新增/更新/禁用不在列表中的权限）。
func (s *PermServer) SyncPermissions(ctx context.Context, req *pb.SyncPermissionsReq) (*pb.SyncPermissionsResp, error) {
	// 审计 M-R11-1：appKey 维度入口限流。此处不在有效性校验前做拦截是有意的——
	// 桶 key 走 `req.AppKey` 的字面值，恶意方若只为耗配额而瞎填 AppKey，最多能把若干"不存在产品"
	// 的计数器打到上限；对真实产品不构成放大。bcrypt.Compare(appSecret) 的 CPU 成本与事务级 X
	// 锁（LockByCodeTx）都在限流之后才发生，恶意重放会被 OverQuota 提前截断。
	if s.svcCtx.GrpcSyncLimiter != nil && req.AppKey != "" {
		code, _ := s.svcCtx.GrpcSyncLimiter.Take(fmt.Sprintf("grpc:sync:%s", req.AppKey))
		if code == limit.OverQuota {
			return nil, status.Error(codes.ResourceExhausted, "请求过于频繁，请稍后再试")
		}
	}

	items := make([]pub.SyncPermItem, len(req.Perms))
	for i, p := range req.Perms {
		items[i] = pub.SyncPermItem{Code: p.Code, Name: p.Name, Remark: p.Remark}
	}

	result, err := pub.ExecuteSyncPerms(ctx, s.svcCtx, req.AppKey, req.AppSecret, items)
	if err != nil {
		if se, ok := err.(*pub.SyncPermsError); ok {
			// 审计 M-2：404 是 tx 内 LockByCodeTx 命中 sqlx.ErrNotFound（产品行被并发删除）
			// 的语义，先于 400/401 前的前置校验放行后才可能出现。接入方 SDK 对 NotFound 一般
			// 配置"按业务未命中处理/不重试"，若在这里落到 default 分支被统一成 codes.Internal，
			// 接入方会把一次正常的"产品不存在"当作系统故障 page 值班，扭曲重试与告警语义。
			switch se.Code {
			case 400:
				return nil, status.Error(codes.InvalidArgument, se.Message)
			case 401:
				return nil, status.Error(codes.Unauthenticated, se.Message)
			case 403:
				return nil, status.Error(codes.PermissionDenied, se.Message)
			case 404:
				return nil, status.Error(codes.NotFound, se.Message)
			case 409:
				return nil, status.Error(codes.Aborted, se.Message)
			default:
				return nil, status.Error(codes.Internal, se.Message)
			}
		}
		return nil, status.Error(codes.Internal, "同步权限失败")
	}

	return &pb.SyncPermissionsResp{Added: result.Added, Updated: result.Updated, Disabled: result.Disabled}, nil
}

// Login 产品端登录。产品成员通过用户名密码 + productCode 登录，返回 JWT 令牌对及用户权限信息。受 IP 维度限流保护。
func (s *PermServer) Login(ctx context.Context, req *pb.LoginReq) (*pb.LoginResp, error) {
	clientIP, ipErr := extractClientIP(ctx)
	if ipErr != nil {
		// 审计 M-7 的核心修复是"把 host:port 剥成 host，避免端口漂移让限流失效"；
		// 生产环境 gRPC 必有 peer，这里走不到；in-process/单测等边缘路径回落到共享 unknown 桶，
		// 上层仍会继续执行用户名级的 UsernameLoginLimit，不会造成防护真空。
		clientIP = unknownPeerBucket
	}
	if s.svcCtx.GrpcLoginLimiter != nil {
		code, _ := s.svcCtx.GrpcLoginLimiter.Take(fmt.Sprintf("grpc:login:%s", clientIP))
		if code == limit.OverQuota {
			return nil, status.Error(codes.ResourceExhausted, "请求过于频繁，请稍后再试")
		}
	}

	if req.ProductCode == "" {
		return nil, status.Error(codes.InvalidArgument, "productCode不能为空")
	}

	result, err := pub.ValidateProductLogin(ctx, s.svcCtx, req.Username, req.Password, req.ProductCode, clientIP)
	if err != nil {
		if le, ok := err.(*pub.LoginError); ok {
			switch le.Code {
			case 400:
				return nil, status.Error(codes.InvalidArgument, le.Message)
			case 401:
				return nil, status.Error(codes.Unauthenticated, le.Message)
			case 403:
				return nil, status.Error(codes.PermissionDenied, le.Message)
			case 429:
				return nil, status.Error(codes.ResourceExhausted, le.Message)
			}
		}
		return nil, status.Error(codes.Internal, "登录失败")
	}

	ud := result.UserDetails
	return &pb.LoginResp{
		AccessToken:  result.AccessToken,
		RefreshToken: result.RefreshToken,
		Expires:      time.Now().Unix() + s.svcCtx.Config.Auth.AccessExpire,
		UserId:       ud.UserId,
		Username:     ud.Username,
		Nickname:     ud.Nickname,
		MemberType:   ud.MemberType,
		Perms:        ud.Perms,
	}, nil
}

// RefreshToken 刷新令牌。使用有效的 refreshToken 换取新的令牌对，同时原子 CAS 递增 tokenVersion
// 使旧令牌即时失效（单会话轮转）。受 IP 维度限流保护，防止签名爆破和并发刷新被用于会话劫持。
func (s *PermServer) RefreshToken(ctx context.Context, req *pb.RefreshTokenReq) (*pb.RefreshTokenResp, error) {
	clientIP, ipErr := extractClientIP(ctx)
	if ipErr != nil {
		// 和 Login 相同，IP 解析失败走共享 unknown 桶；后续 CAS（IncrementTokenVersionIfMatch）
		// 和 per-user TokenOpLimiter 仍然兜底 session 劫持路径。
		clientIP = unknownPeerBucket
	}
	if s.svcCtx.GrpcRefreshLimiter != nil {
		code, _ := s.svcCtx.GrpcRefreshLimiter.Take(fmt.Sprintf("grpc:refresh:%s", clientIP))
		if code == limit.OverQuota {
			return nil, status.Error(codes.ResourceExhausted, "请求过于频繁，请稍后再试")
		}
	}

	claims, err := authHelper.ParseRefreshToken(req.RefreshToken, s.svcCtx.Config.Auth.RefreshSecret)
	if err != nil {
		return nil, status.Error(codes.Unauthenticated, "refreshToken无效或已过期")
	}

	productCode := claims.ProductCode
	if req.ProductCode != "" && req.ProductCode != productCode {
		return nil, status.Error(codes.InvalidArgument, "刷新令牌不允许切换产品")
	}

	ud, err := s.svcCtx.UserDetailsLoader.Load(ctx, claims.UserId, productCode)
	if err != nil {
		// 与"用户已删除"区分：基础设施短时不可用走 Unavailable，token 不作废让客户端重试
		// （见审计 M-1）。
		return nil, status.Error(codes.Unavailable, "服务暂时不可用，请稍后重试")
	}
	if ud.Username == "" {
		return nil, status.Error(codes.Unauthenticated, "用户不存在或已被删除")
	}

	if ud.Status != consts.StatusEnabled {
		return nil, status.Error(codes.PermissionDenied, "账号已被冻结")
	}

	if productCode != "" && ud.ProductStatus != consts.StatusEnabled {
		return nil, status.Error(codes.PermissionDenied, "该产品已被禁用")
	}

	if productCode != "" && !ud.IsSuperAdmin && ud.MemberType == "" {
		return nil, status.Error(codes.PermissionDenied, "您已不是该产品的成员")
	}

	if claims.TokenVersion != ud.TokenVersion {
		return nil, status.Error(codes.Unauthenticated, "登录状态已失效，请重新登录")
	}

	if s.svcCtx.TokenOpLimiter != nil {
		code, _ := s.svcCtx.TokenOpLimiter.Take(fmt.Sprintf("grpc-refresh-u:%d", claims.UserId))
		if code == limit.OverQuota {
			return nil, status.Error(codes.ResourceExhausted, "刷新操作过于频繁，请稍后再试")
		}
	}

	// 审计 L-R11-5：两条 RefreshToken 路径复用 authHelper.RotateRefreshToken，避免"试签 → CAS →
	// Clean → forensic 比对"四步重复两次。gRPC 侧只做错误到 status code 的映射。
	tokens, err := authHelper.RotateRefreshToken(ctx, s.svcCtx, claims, ud)
	if err != nil {
		if errors.Is(err, userModel.ErrTokenVersionMismatch) {
			return nil, status.Error(codes.Unauthenticated, "登录状态已失效，请重新登录")
		}
		return nil, status.Error(codes.Internal, "刷新token失败")
	}

	return &pb.RefreshTokenResp{
		AccessToken:  tokens.AccessToken,
		RefreshToken: tokens.RefreshToken,
		Expires:      time.Now().Unix() + s.svcCtx.Config.Auth.AccessExpire,
	}, nil
}

// VerifyToken 验证令牌。校验 accessToken 的有效性（签名、过期、用户状态、产品状态、成员资格、tokenVersion），
// 有效时返回用户身份和权限信息。受 IP 维度限流保护，防止下游被攻破后把权限中心当作 token oracle 做爆破。
//
// 注意：本方法对外契约是"任何畸形/非法 token 都只返回 Valid=false，不返回 gRPC 错误"（见 fuzz 契约测试），
// 因此 IP 解析失败时不能走 fail-close，改为降级到共享 "unknown" 限流桶——仍然有限速，但不破坏上游产品网关
// 的稳定错误分类；真正过载时用 ResourceExhausted 响应。
func (s *PermServer) VerifyToken(ctx context.Context, req *pb.VerifyTokenReq) (*pb.VerifyTokenResp, error) {
	clientIP, ipErr := extractClientIP(ctx)
	if ipErr != nil {
		clientIP = "unknown"
	}
	if s.svcCtx.GrpcVerifyLimiter != nil {
		code, _ := s.svcCtx.GrpcVerifyLimiter.Take(fmt.Sprintf("grpc:verify:%s", clientIP))
		if code == limit.OverQuota {
			return nil, status.Error(codes.ResourceExhausted, "请求过于频繁，请稍后再试")
		}
	}

	token, err := middleware.ParseWithHMAC(req.AccessToken, s.svcCtx.Config.Auth.AccessSecret, &middleware.Claims{})
	if err != nil || !token.Valid {
		logx.WithContext(ctx).Infof("verifyToken fail reason=invalid_token")
		return &pb.VerifyTokenResp{Valid: false}, nil
	}

	claims, ok := token.Claims.(*middleware.Claims)
	if !ok || claims.TokenType != consts.TokenTypeAccess {
		logx.WithContext(ctx).Infof("verifyToken fail reason=bad_claims")
		return &pb.VerifyTokenResp{Valid: false}, nil
	}

	ud, err := s.svcCtx.UserDetailsLoader.Load(ctx, claims.UserId, claims.ProductCode)
	if err != nil {
		// VerifyToken 的对外契约是"任何 token 问题只回 Valid=false，不抛 gRPC 错误"。但基础设施
		// 故障不属于"token 问题"——同化为 Valid=false 会让下游把合法用户踢出登录（见审计 M-1）。
		// 走 Unavailable，由下游按瞬时故障重试而不是据此清 token。
		logx.WithContext(ctx).Errorf("verifyToken: load user details failed: %v", err)
		return nil, status.Error(codes.Unavailable, "服务暂时不可用，请稍后重试")
	}
	if ud.Username == "" {
		logx.WithContext(ctx).Infof("verifyToken fail userId=%d reason=user_not_found", claims.UserId)
		return &pb.VerifyTokenResp{Valid: false}, nil
	}
	if ud.Status != consts.StatusEnabled {
		logx.WithContext(ctx).Infof("verifyToken fail userId=%d reason=user_disabled", claims.UserId)
		return &pb.VerifyTokenResp{Valid: false}, nil
	}
	if claims.TokenVersion != ud.TokenVersion {
		logx.WithContext(ctx).Infof("verifyToken fail userId=%d reason=token_version_mismatch", claims.UserId)
		return &pb.VerifyTokenResp{Valid: false}, nil
	}
	if claims.ProductCode != "" && ud.ProductStatus != consts.StatusEnabled {
		logx.WithContext(ctx).Infof("verifyToken fail userId=%d reason=product_disabled product=%s", claims.UserId, claims.ProductCode)
		return &pb.VerifyTokenResp{Valid: false}, nil
	}
	if claims.ProductCode != "" && !ud.IsSuperAdmin && ud.MemberType == "" {
		logx.WithContext(ctx).Infof("verifyToken fail userId=%d reason=not_member product=%s", claims.UserId, claims.ProductCode)
		return &pb.VerifyTokenResp{Valid: false}, nil
	}

	return &pb.VerifyTokenResp{
		Valid:       true,
		UserId:      ud.UserId,
		Username:    ud.Username,
		MemberType:  ud.MemberType,
		Perms:       ud.Perms,
		ProductCode: claims.ProductCode,
	}, nil
}

// GetUserPerms 查询用户权限。产品服务端通过 appKey/appSecret 认证后查询指定用户在该产品下的成员类型和权限列表，用于产品侧的权限网关判定。
func (s *PermServer) GetUserPerms(ctx context.Context, req *pb.GetUserPermsReq) (*pb.GetUserPermsResp, error) {
	// 审计 M-R11-1：入口限流，双维度（appKey + 源 IP）叠加。
	//   - appKey 维度抵御"合法产品凭证泄露后遍历 userId 爆缓存/打穿 DB"；
	//   - IP 维度抵御"同一产品多后端实例被 DDoS 放大时把合法产品打过配额"；两者谁先过限都拒绝，
	//     以真实业务量级（单产品最多数千活跃成员、单 userId QPS 远低于 1k/min）来衡量不会误杀。
	if s.svcCtx.GrpcGetUserPermsLimiter != nil && req.AppKey != "" {
		code, _ := s.svcCtx.GrpcGetUserPermsLimiter.Take(fmt.Sprintf("grpc:perms:%s", req.AppKey))
		if code == limit.OverQuota {
			return nil, status.Error(codes.ResourceExhausted, "请求过于频繁，请稍后再试")
		}
	}
	if s.svcCtx.GrpcGetUserPermsLimiter != nil {
		clientIP, ipErr := extractClientIP(ctx)
		if ipErr != nil {
			clientIP = unknownPeerBucket
		}
		code, _ := s.svcCtx.GrpcGetUserPermsLimiter.Take(fmt.Sprintf("grpc:perms-ip:%s", clientIP))
		if code == limit.OverQuota {
			return nil, status.Error(codes.ResourceExhausted, "请求过于频繁，请稍后再试")
		}
	}

	product, err := s.svcCtx.SysProductModel.FindOneByAppKey(ctx, req.AppKey)
	if err != nil {
		return nil, status.Error(codes.Unauthenticated, "无效的appKey")
	}
	if err := bcrypt.CompareHashAndPassword([]byte(product.AppSecret), []byte(req.AppSecret)); err != nil {
		return nil, status.Error(codes.Unauthenticated, "appSecret验证失败")
	}
	if product.Status != consts.StatusEnabled {
		return nil, status.Error(codes.PermissionDenied, "产品已被禁用")
	}
	if product.Code != req.ProductCode {
		return nil, status.Error(codes.InvalidArgument, "appKey与productCode不匹配")
	}

	ud, err := s.svcCtx.UserDetailsLoader.Load(ctx, req.UserId, req.ProductCode)
	if err != nil {
		return nil, status.Error(codes.Unavailable, "服务暂时不可用，请稍后重试")
	}

	// 审计 L-R10-10：消除"userId 是否在全局 sys_user 中存在"的枚举 oracle。原实现在 Username=""
	// 时回 NotFound、在非成员时回 PermissionDenied，持合法 appKey 的产品服务端可遍历 userId 区分
	// "这个 userId 在全局 sys_user 里存在" vs "不在"。统一回 NotFound "用户不是该产品的有效成员"，
	// 与 REST 侧 RoleDetail 的修复口径对齐（M-N3）。
	// 保留"用户已被冻结"为显式 PermissionDenied：密码正确才能拿到合法 appKey 这一前提不成立时，
	// 这个状态已经是上层业务承诺披露的信息，不构成新增枚举面。
	if ud.Username == "" || (!ud.IsSuperAdmin && ud.MemberType == "") {
		logx.WithContext(ctx).Infof("getUserPerms not-found or non-member userId=%d productCode=%s", req.UserId, req.ProductCode)
		return nil, status.Error(codes.NotFound, "用户不是该产品的有效成员")
	}
	if ud.Status != consts.StatusEnabled {
		return nil, status.Error(codes.PermissionDenied, "用户已被冻结")
	}

	return &pb.GetUserPermsResp{
		MemberType: ud.MemberType,
		Perms:      ud.Perms,
	}, nil
}