用户模块实现教程

// 用户名/密码规则（商用标准）
var (
    usernameRegex = regexp.MustCompile(`^[a-zA-Z0-9_]{3,32}$`) // 3-32 位字母数字下划线
    emailRegex    = regexp.MustCompile(`^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}$`)
    reservedWords = map[string]bool{"admin": true, "root": true, "system": true} // 保留词黑名单
)

// Register 通过数据库唯一索引保证并发安全地创建新用户账户
func (uc *UserUsecase) Register(ctx context.Context, username, password, email, phone, nickname string) (*User, error) {
    // —— 参数校验阶段（修正点：补充用户名格式与保留词、密码强度、邮箱唯一）——
    if username == "" || password == "" {
        return nil, ErrUsernamePasswordRequired
    }
    if !usernameRegex.MatchString(username) {
        return nil, errors.BadRequest("USERNAME_INVALID", "用户名需为3-32位字母、数字或下划线")
    }
    if reservedWords[strings.ToLower(username)] {
        return nil, errors.BadRequest("USERNAME_RESERVED", "该用户名不可注册")
    }
    if len(password) < 10 { // 修正点：从 8 位提高到 10 位，生产可加复杂度规则
        return nil, errors.BadRequest("PASSWORD_TOO_SHORT", "密码不能少于10位")
    }
    if !passwordPolicyOK(password) { // 长度+大小写+数字+特殊字符
        return nil, errors.BadRequest("PASSWORD_WEAK", "密码需含大小写字母、数字与特殊字符")
    }
    if email == "" || !emailRegex.MatchString(email) {
        return nil, errors.BadRequest("EMAIL_INVALID", "邮箱格式不正确")
    }
    if len(email) > 128 {
        return nil, errors.BadRequest("EMAIL_TOO_LONG", "邮箱长度不能超过128个字符")
    }

    // —— 第一道防线：业务层查重（用户名）——
    existing, err := uc.repo.FindByUsername(ctx, username)
    if err != nil && !errors.IsNotFound(err) {
        return nil, err
    }
    if existing != nil && existing.ID > 0 {
        return nil, ErrUserAlreadyExists
    }
    // 修正点：邮箱唯一性也提前查（第二道靠 DB 唯一索引兜底）
    if e2, _ := uc.repo.FindByEmail(ctx, email); e2 != nil && e2.ID > 0 {
        return nil, ErrEmailAlreadyExists
    }

    // —— 密码慢哈希（Cost=12）——
    hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), 12)
    if err != nil {
        return nil, err
    }

    if nickname == "" {
        nickname = username
    }
    const defaultTotalStorage int64 = 10 * 1024 * 1024 * 1024

    user := &User{
        Username:      username,
        Password:      string(hashedPassword),
        Email:         email,
        Phone:         phone,
        Nickname:      nickname,
        Status:        1,
        EmailVerified: 0,                      // 修正点：未激活
        TokenVersion:  0,                      // 修正点：令牌版本号初始 0
        StorageQuota:  defaultTotalStorage,
        TotalStorage:  defaultTotalStorage,
    }

    // —— 第二道防线：数据库唯一索引（username + email）——
    created, err := uc.repo.Create(ctx, user)
    if err != nil {
        if errors.IsConflict(err) {
            return nil, ErrUserAlreadyExists // 或按冲突字段细分
        }
        return nil, err
    }

    // 修正点：发送邮箱验证邮件（签名时效 token，异步/消息队列更好）
    _ = uc.SendVerificationEmail(ctx, created)

    return created, nil
}

// Login 验证用户身份并返回 JWT 令牌
func (uc *UserUsecase) Login(ctx context.Context, username, password string) (*User, string, string, int64, error) {
    if username == "" || password == "" {
        return nil, "", "", 0, ErrUsernamePasswordRequired
    }

    // 修正点：先查账号锁定
    if locked, _ := uc.repo.IsLocked(ctx, username); locked {
        return nil, "", "", 0, errors.Forbidden("ACCOUNT_LOCKED", "账号已锁定，请15分钟后再试或找回密码")
    }

    user, err := uc.repo.FindByUsername(ctx, username)
    if err != nil {
        if errors.IsNotFound(err) {
            // 关键：用户不存在也返回"用户名或密码不正确"（防枚举）
            return nil, "", "", 0, ErrInvalidCredentials
        }
        return nil, "", "", 0, err
    }

    if user.Status == 0 {
        return nil, "", "", 0, errors.Forbidden("USER_DISABLED", "账号已被禁用")
    }
    // 修正点：未激活邮箱禁止登录
    if user.EmailVerified == 0 {
        return nil, "", "", 0, errors.Forbidden("EMAIL_NOT_VERIFIED", "请先完成邮箱验证")
    }

    if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(password)); err != nil {
        // 修正点：失败计数 + 锁定
        uc.repo.IncLoginFail(ctx, username)
        if uc.repo.LoginFailCount(ctx, username) >= 5 {
            uc.repo.LockAccount(ctx, username, 15*time.Minute)
        }
        return nil, "", "", 0, ErrInvalidCredentials
    }

    // 修正点：成功清零失败计数
    uc.repo.ResetLoginFail(ctx, username)

    // 签发双令牌：把当前 token_version 写进 claims
    accessToken, err := uc.token.GenerateAccessToken(user.ID, user.Username, user.TokenVersion)
    if err != nil {
        return nil, "", "", 0, err
    }
    refreshToken, err := uc.token.GenerateRefreshToken(user.ID, user.TokenVersion)
    if err != nil {
        return nil, "", "", 0, err
    }

    return user, accessToken, refreshToken, time.Now().Add(uc.token.GetExpire()).Unix(), nil
}

// Claims 自定义 JWT 载荷（修正点：新增 TokenVersion）
type Claims struct {
    UserID       uint64 `json:"user_id"`
    Username     string `json:"username"`
    TokenVersion int64  `json:"tv"`
    jwt.RegisteredClaims
}

// GenerateAccessToken 创建签名的 JWT 访问令牌
func (tm *TokenManager) GenerateAccessToken(userID uint64, username string, tokenVersion int64) (string, error) {
    now := time.Now()
    claims := &Claims{
        UserID:       userID,
        Username:     username,
        TokenVersion: tokenVersion, // 修正点：写入版本号
        RegisteredClaims: jwt.RegisteredClaims{
            Issuer:    "cloud-disk",
            Subject:   username,
            Audience:  jwt.ClaimStrings{"cloud-disk"},
            ExpiresAt: jwt.NewNumericDate(now.Add(tm.expire)),
            NotBefore: jwt.NewNumericDate(now),
            IssuedAt:  jwt.NewNumericDate(now),
            ID:        generateJTI(),
        },
    }
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    return token.SignedString(tm.secret)
}

// GenerateRefreshToken 创建签名的刷新令牌，更长有效期，只带 userID + 版本号
func (tm *TokenManager) GenerateRefreshToken(userID uint64, tokenVersion int64) (string, error) {
    now := time.Now()
    claims := jwt.RegisteredClaims{
        Issuer:    "cloud-disk",
        Subject:   fmt.Sprintf("%d", userID),
        ExpiresAt: jwt.NewNumericDate(now.Add(tm.refreshExpire)),
        NotBefore: jwt.NewNumericDate(now),
        IssuedAt:  jwt.NewNumericDate(now),
        ID:        generateJTI(),
    }
    // 修正点：refresh token 同样带版本号，使其可被统一吊销
    // 这里把版本号塞进标准 RegisteredClaims 之外的私有 claim 即可（自行封装）
    // 为简洁，改为使用自定义 Claims：
    rc := &Claims{UserID: userID, TokenVersion: tokenVersion, RegisteredClaims: claims}
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, rc)
    return token.SignedString(tm.secret)
}

// Login 验证用户身份并返回 JWT 令牌。
func (s *UserService) Login(ctx context.Context, req *v1.LoginRequest) (*v1.LoginReply, error) {
    user, accessToken, refreshToken, expiresAt, err := s.uc.Login(ctx, req.Username, req.Password)
    if err != nil {
        return nil, err
    }
    return &v1.LoginReply{
        User:         toUserInfo(user),
        AccessToken:  accessToken,
        RefreshToken: refreshToken,
        ExpiresAt:    expiresAt,
    }, nil
}

// 修正点：自定义 context key 类型，避免与其他包裸字符串 key 冲突
type ctxKey string

const (
    ctxKeyUserID   ctxKey = "user_id"
    ctxKeyUsername ctxKey = "username"
    ctxKeyToken    ctxKey = "token"
)

// JWTAuthMiddleware 返回一个验证 JWT token 的中间件。
func JWTAuthMiddleware(tokenManager *biz.TokenManager, whitelist ...string) middleware.Middleware {
    whitelistMap := make(map[string]bool, len(whitelist))
    for _, p := range whitelist {
        whitelistMap[p] = true
    }

    return func(handler middleware.Handler) middleware.Handler {
        return func(ctx context.Context, req interface{}) (interface{}, error) {
            if tr, ok := transport.FromServerContext(ctx); ok {
                op := tr.Operation()
                if whitelistMap[op] {
                    return handler(ctx, req)
                }
                if ht, ok := tr.(interface{ Request() *http.Request }); ok {
                    if whitelistMap[ht.Request().URL.Path] {
                        return handler(ctx, req)
                    }
                }
            }

            var tokenStr string
            if tr, ok := transport.FromServerContext(ctx); ok {
                header := tr.RequestHeader()
                auth := header.Get("Authorization")
                if strings.HasPrefix(auth, "Bearer ") {
                    tokenStr = strings.TrimPrefix(auth, "Bearer ")
                }
            }
            if tokenStr == "" {
                return nil, errors.Unauthorized("MISSING_TOKEN", "缺少认证令牌")
            }

            claims, err := tokenManager.VerifyToken(ctx, tokenStr) // 修正点：传入 ctx
            if err != nil {
                return nil, err
            }

            ctx = context.WithValue(ctx, ctxKeyUserID, claims.UserID)
            ctx = context.WithValue(ctx, ctxKeyUsername, claims.Username)
            ctx = context.WithValue(ctx, ctxKeyToken, tokenStr)
            return handler(ctx, req)
        }
    }
}

// CtxUserID 从 context 提取用户 ID
func CtxUserID(ctx context.Context) uint64 {
    if id, ok := ctx.Value(ctxKeyUserID).(uint64); ok {
        return id
    }
    return 0
}

// CtxToken 提取原始 token 字符串（登出用）
func CtxToken(ctx context.Context) string {
    if t, ok := ctx.Value(ctxKeyToken).(string); ok {
        return t
    }
    return ""
}

// CtxUsername 提取用户名
func CtxUsername(ctx context.Context) string {
    if name, ok := ctx.Value(ctxKeyUsername).(string); ok {
        return name
    }
    return ""
}

// VerifyToken 解析并验证 JWT 令牌字符串（修正点：fail-closed + 版本号）
func (tm *TokenManager) VerifyToken(ctx context.Context, tokenStr string) (*Claims, error) {
    token, err := jwt.ParseWithClaims(tokenStr, &Claims{}, func(token *jwt.Token) (interface{}, error) {
        if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
            return nil, jwt.ErrSignatureInvalid
        }
        return tm.secret, nil
    })
    if err != nil {
        return nil, ErrInvalidToken
    }
    claims, ok := token.Claims.(*Claims)
    if !ok || !token.Valid {
        return nil, ErrInvalidToken
    }

    // —— 黑名单检查（修正点：fail-closed）——
    if tm.cache != nil {
        blacklisted, berr := tm.IsBlacklisted(ctx, tokenStr)
        if berr != nil {
            // Redis 故障：宁可拒绝，避免登出/封禁被绕过
            log.Error("blacklist check failed", "err", berr)
            return nil, ErrTokenExpired
        }
        if blacklisted {
            return nil, ErrTokenExpired
        }
    }

    // —— 令牌版本号检查（修正点：解决改密/封禁吊销）——
    if claims.TokenVersion != 0 {
        current, verr := tm.repo.GetTokenVersion(ctx, claims.UserID)
        if verr != nil {
            return nil, ErrTokenExpired // fail-closed
        }
        if claims.TokenVersion != current {
            return nil, ErrTokenExpired // 版本不符 → 令牌已作废
        }
    }

    return claims, nil
}

// Logout 使当前会话/令牌失效（加入黑名单）
func (uc *UserUsecase) Logout(ctx context.Context, tokenStr string) error {
    if tokenStr == "" {
        return nil // 没带 token 视为已登出，幂等返回
    }
    return uc.token.BlacklistToken(ctx, tokenStr)
}

// LogoutAllDevices 使该用户所有已签发令牌失效（改密/封禁复用同一机制）
func (uc *UserUsecase) LogoutAllDevices(ctx context.Context, userID uint64) error {
    return uc.repo.BumpTokenVersion(ctx, userID)
}

// BlacklistToken 将令牌添加到黑名单
func (tm *TokenManager) BlacklistToken(ctx context.Context, tokenStr string) error {
    if tm.cache == nil {
        return nil // 没有缓存后端时无法实现黑名单，令牌会自然过期
    }
    jti, err := extractJTI(tokenStr)
    if err != nil || jti == "" {
        return nil
    }
    // TTL = access token 有效期，过期后自动清理
    return tm.cache.Set(ctx, tm.blacklistPrefix+jti, "1", tm.expire)
}

// RefreshToken 验证刷新令牌并返回新的访问令牌
func (uc *UserUsecase) RefreshToken(ctx context.Context, refreshTokenStr string) (string, string, int64, error) {
    if refreshTokenStr == "" {
        return "", "", 0, ErrInvalidToken
    }

    claims, err := uc.token.VerifyToken(ctx, refreshTokenStr)
    if err != nil {
        return "", "", 0, ErrInvalidToken
    }

    var userID uint64
    if _, err := fmt.Sscanf(claims.Subject, "%d", &userID); err != nil || userID == 0 {
        return "", "", 0, ErrInvalidToken
    }

    // 验证用户是否仍然存在且未禁用
    user, err := uc.repo.FindByID(ctx, userID)
    if err != nil {
        return "", "", 0, ErrUserNotFound
    }

    // 修正点：查库取 username 与最新 version，避免新 access token 身份/版本缺失
    accessToken, err := uc.token.GenerateAccessToken(user.ID, user.Username, user.TokenVersion)
    if err != nil {
        return "", "", 0, err
    }
    newRefreshToken, err := uc.token.GenerateRefreshToken(user.ID, user.TokenVersion)
    if err != nil {
        return "", "", 0, err
    }

    return accessToken, newRefreshToken, time.Now().Add(uc.token.GetExpire()).Unix(), nil
}

// UpdatePassword 在验证旧密码后修改用户密码，并使旧令牌失效
func (uc *UserUsecase) UpdatePassword(ctx context.Context, userID uint64, oldPassword, newPassword string) error {
    if oldPassword == "" || newPassword == "" {
        return ErrUsernamePasswordRequired
    }
    if !passwordPolicyOK(newPassword) {
        return errors.BadRequest("PASSWORD_WEAK", "密码强度不足")
    }

    user, err := uc.repo.FindByID(ctx, userID)
    if err != nil {
        return ErrUserNotFound
    }
    if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(oldPassword)); err != nil {
        return ErrInvalidPassword
    }

    hashedPassword, err := bcrypt.GenerateFromPassword([]byte(newPassword), 12)
    if err != nil {
        return err
    }
    if err := uc.repo.UpdatePassword(ctx, userID, string(hashedPassword)); err != nil {
        return err
    }
    // 修正点：改密后让所有旧令牌（含 refresh）集体失效
    return uc.repo.BumpTokenVersion(ctx, userID)
}

// ResetPassword 通过密保问题验证来重置密码（修正点：防枚举 + 防爆破）
func (uc *UserUsecase) ResetPassword(ctx context.Context, username, securityAnswer, newPassword string) error {
    if username == "" || securityAnswer == "" || newPassword == "" {
        return ErrUsernamePasswordRequired
    }
    // 修正点：先查锁定
    if locked, _ := uc.repo.IsLocked(ctx, "sec:"+username); locked {
        return errors.Forbidden("ACCOUNT_LOCKED", "尝试过于频繁，请稍后再试")
    }
    if !passwordPolicyOK(newPassword) {
        return errors.BadRequest("PASSWORD_WEAK", "密码强度不足")
    }

    // 修正点：无论用户是否存在，都走同一查库路径，避免时序/错误差异枚举
    user, err := uc.repo.FindByUsername(ctx, username)
    if err != nil || user.SecurityAnswer == "" || user.SecurityQuestion == "" {
        // 统一模糊错误，不暴露"用户不存在"或"未设密保"
        return ErrSecurityAnswerMismatch
    }
    if err := bcrypt.CompareHashAndPassword([]byte(user.SecurityAnswer), []byte(securityAnswer)); err != nil {
        uc.repo.IncLoginFail(ctx, "sec:"+username) // 复用失败计数
        if uc.repo.LoginFailCount(ctx, "sec:"+username) >= 5 {
            uc.repo.LockAccount(ctx, "sec:"+username, 15*time.Minute)
        }
        return ErrSecurityAnswerMismatch
    }
    uc.repo.ResetLoginFail(ctx, "sec:"+username)

    hashedPassword, err := bcrypt.GenerateFromPassword([]byte(newPassword), 12)
    if err != nil {
        return err
    }
    if err := uc.repo.UpdatePassword(ctx, user.ID, string(hashedPassword)); err != nil {
        return err
    }
    // 修正点：重置密码同样让旧令牌失效
    return uc.repo.BumpTokenVersion(ctx, user.ID)
}

// GetSecurityQuestion 返回用户的密保问题（修正点：不暴露账号是否存在）
func (uc *UserUsecase) GetSecurityQuestion(ctx context.Context, username string) (string, error) {
    user, err := uc.repo.FindByUsername(ctx, username)
    if err != nil || user.SecurityQuestion == "" {
        // 统一返回空，前端不区分"不存在"与"未设密保"
        return "", nil
    }
    return user.SecurityQuestion, nil
}

// SendResetCode 发送邮箱重置验证码（限流 + 一次性）
func (uc *UserUsecase) SendResetCode(ctx context.Context, email string) error {
    if !emailRegex.MatchString(email) {
        return errors.BadRequest("EMAIL_INVALID", "邮箱格式不正确")
    }
    user, err := uc.repo.FindByEmail(ctx, email)
    if err != nil {
        return nil // 修正点：不暴露邮箱是否注册（防枚举）
    }
    code := rand6()
    // Redis 存 10 分钟，key 带业务前缀
    if err := uc.cache.Set(ctx, "cloud-disk:reset:"+email, code, 10*time.Minute); err != nil {
        return err
    }
    return uc.SendEmail(ctx, email, "您的重置验证码："+code)
}

// ForgotPassword 用验证码重置密码
func (uc *UserUsecase) ForgotPassword(ctx context.Context, email, code, newPassword string) error {
    if !passwordPolicyOK(newPassword) {
        return errors.BadRequest("PASSWORD_WEAK", "密码强度不足")
    }
    saved, err := uc.cache.Get(ctx, "cloud-disk:reset:"+email)
    if err != nil || saved != code {
        return errors.BadRequest("CODE_WRONG", "验证码错误或已过期")
    }
    user, err := uc.repo.FindByEmail(ctx, email)
    if err != nil {
        return ErrUserNotFound
    }
    hashed, _ := bcrypt.GenerateFromPassword([]byte(newPassword), 12)
    if err := uc.repo.UpdatePassword(ctx, user.ID, string(hashed)); err != nil {
        return err
    }
    uc.cache.Del(ctx, "cloud-disk:reset:"+email) // 一次性
    return uc.repo.BumpTokenVersion(ctx, user.ID) // 旧令牌失效
}

// GetUserInfo 返回已认证用户的个人资料。
func (s *UserService) GetUserInfo(ctx context.Context, req *v1.GetUserInfoRequest) (*v1.GetUserInfoReply, error) {
    userID := CtxUserID(ctx)
    if userID == 0 {
        return nil, biz.ErrInvalidToken
    }
    user, err := s.uc.GetUserInfo(ctx, userID)
    if err != nil {
        return nil, err
    }
    return &v1.GetUserInfoReply{User: toUserInfo(user)}, nil
}

// toUserInfo 将 biz.User 转换为 v1.UserInfo，天然脱敏（不含密码/密保答案）
func toUserInfo(user *biz.User) *v1.UserInfo {
    if user == nil {
        return nil
    }
    return &v1.UserInfo{
        Id: user.ID, Username: user.Username, Email: user.Email,
        Phone: user.Phone, Nickname: user.Nickname, Avatar: user.Avatar,
        Status: user.Status, StorageQuota: user.StorageQuota,
        UsedStorage: user.UsedStorage,
        CreatedAt: user.CreatedAt.Format("2006-01-02 15:04:05"),
        UpdatedAt: user.UpdatedAt.Format("2006-01-02 15:04:05"),
    }
}

const (
    cacheKeyUserStorage = "cloud-disk:user:storage:%d" // 修正点：加业务前缀
    cacheTTLUserStorage = 300 * time.Second
)

func (uc *UserUsecase) GetStorageInfo(ctx context.Context, userID uint64) (*StorageInfo, error) {
    if uc.cache != nil {
        if val, err := uc.cache.Get(ctx, fmt.Sprintf(cacheKeyUserStorage, userID)); err == nil && val != "" {
            var info StorageInfo
            if json.Unmarshal([]byte(val), &info) == nil {
                return &info, nil
            }
        }
    }
    total, used, err := uc.repo.GetUserStorage(ctx, userID)
    if err != nil {
        return nil, err
    }
    available := total - used
    if available < 0 {
        available = 0
    }
    var percent float64
    if total > 0 {
        percent = float64(used) / float64(total) * 100
    }
    info := &StorageInfo{Total: total, Used: used, Available: available, Percent: percent}
    if uc.cache != nil {
        if b, err := json.Marshal(info); err == nil {
            _ = uc.cache.Set(ctx, fmt.Sprintf(cacheKeyUserStorage, userID), string(b), cacheTTLUserStorage)
        }
    }
    return info, nil
}

// UpdateUsedStorageAtomic 原子性增减已用存储容量。delta>0 上传，delta<0 删除
func (r *userRepo) UpdateUsedStorageAtomic(ctx context.Context, userID uint64, delta int64) error {
    if delta < 0 {
        result := r.db.WithContext(ctx).Model(&model.User{}).
            Where("id = ? AND used_storage >= ?", userID, -delta).
            UpdateColumn("used_storage", gorm.Expr("used_storage + ?", delta))
        if result.Error != nil {
            return result.Error
        }
        if result.RowsAffected == 0 {
            var count int64
            r.db.WithContext(ctx).Model(&model.User{}).Where("id = ?", userID).Count(&count)
            if count == 0 {
                return biz.ErrUserNotFound
            }
            return biz.ErrStorageInsufficient
        }
        return nil
    }
    result := r.db.WithContext(ctx).Model(&model.User{}).Where("id = ?", userID).
        UpdateColumn("used_storage", gorm.Expr("used_storage + ?", delta))
    if result.Error != nil {
        return result.Error
    }
    if result.RowsAffected == 0 {
        return biz.ErrUserNotFound
    }
    return nil
}

// DeleteAccount 注销账号：逻辑禁用 + 异步清理
func (uc *UserUsecase) DeleteAccount(ctx context.Context, userID uint64) error {
    if err := uc.repo.DisableAccount(ctx, userID); err != nil {
        return err
    }
    uc.repo.BumpTokenVersion(ctx, userID) // 立即失效所有令牌
    // 异步任务：匿名化昵称/邮箱、删除文件元数据、回收对象存储
    uc.cleanupQueue.Publish(ctx, userID)
    return nil
}

// NewTokenManager 生产化：未配置强密钥直接启动失败
func NewTokenManager(c *conf.Auth) *TokenManager {
    if c == nil || c.JwtSecret == "" {
        // 修正点：绝不回退到硬编码默认值，否则任何人可伪造令牌
        log.Fatalf("auth.jwt_secret is required in production")
    }
    expire, refreshExpire := 24*time.Hour, 7*24*time.Hour
    if c.JwtExpire != nil {
        expire = c.JwtExpire.AsDuration()
    }
    if c.JwtRefreshExpire != nil {
        refreshExpire = c.JwtRefreshExpire.AsDuration()
    }
    return &TokenManager{
        secret: []byte(c.JwtSecret),
        expire: expire, refreshExpire: refreshExpire,
        blacklistPrefix: "blacklist:token:",
    }
}