如何在ASP.NET Core Web API中实现用户仅能访问自身端点的授权？

首先明确：JWT本身是经过数字签名的，只要你的API正确配置了JWT验证中间件（用合法密钥验证签名），篡改令牌中的NameIdentifier等Claim会直接导致签名验证失败，请求会被中间件拒绝，所以你担心的“令牌被篡改修改ID”在正常配置下无法实现。不过我们可以通过以下方式优化实现，让逻辑更严谨、可维护性更高：

1. 自定义授权策略，避免重复验证逻辑 #

把用户ID匹配的验证逻辑抽离到全局授权策略中，不用在每个控制器方法里重复写判断：

// 在 Program.cs 中配置授权策略
builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("OwnUser", policy =>
        policy.RequireAssertion(context =>
        {
            // 从Claims获取当前用户ID
            if (!int.TryParse(context.User.FindFirstValue(ClaimTypes.NameIdentifier), out var currentUserId))
                return false;
            
            // 从路由参数获取目标用户ID
            if (!int.TryParse(context.RouteData.Values["userId"]?.ToString(), out var targetUserId))
                return false;
            
            return currentUserId == targetUserId;
        }));
});

// 控制器中直接使用策略
[HttpGet("{userId:int}"), Authorize(Policy = "OwnUser")]
public async Task<ActionResult> GetUserById([FromRoute] int userId)
{
    var user = await unitOfWork.UserRepository.GetUserByIdAsync(userId);
    
    if (user == null)  
        return NotFound("User not found");

    return Ok(user);
}

2. 移除路由中的用户ID，直接从令牌获取 #

将端点改为api/users/me，不需要前端传递用户ID，直接从JWT Claims中提取当前用户ID，彻底避免参数层面的风险：

[HttpGet("me"), Authorize]
public async Task<ActionResult> GetCurrentUser()
{
    // 从Claims解析当前用户ID
    if (!int.TryParse(User.FindFirstValue(ClaimTypes.NameIdentifier), out var currentUserId))
        return Unauthorized();

    var user = await unitOfWork.UserRepository.GetUserByIdAsync(currentUserId);
    
    if (user == null)  
        return NotFound("User not found");

    return Ok(user);
}

3. 使用资源型授权（适合复杂场景） #

如果后续需要扩展权限逻辑（比如管理员可以访问所有用户），可以使用ASP.NET Core的资源型授权机制：

第一步：定义授权需求和处理器 #

// 授权需求标记
public class OwnUserRequirement : IAuthorizationRequirement { }

// 授权处理器
public class OwnUserAuthorizationHandler : AuthorizationHandler<OwnUserRequirement, int>
{
    protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, 
                                                   OwnUserRequirement requirement, 
                                                   int targetUserId)
    {
        // 验证当前用户ID是否与目标ID匹配
        if (int.TryParse(context.User.FindFirstValue(ClaimTypes.NameIdentifier), out var currentUserId) 
            && currentUserId == targetUserId)
        {
            context.Succeed(requirement);
        }
        return Task.CompletedTask;
    }
}

第二步：注册处理器到依赖注入 #

// Program.cs
builder.Services.AddScoped<IAuthorizationHandler, OwnUserAuthorizationHandler>();

第三步：控制器中使用 #

private readonly IAuthorizationService _authorizationService;

// 构造函数注入
public YourController(IAuthorizationService authorizationService, /* 其他依赖 */)
{
    _authorizationService = authorizationService;
}

[HttpGet("{userId:int}"), Authorize]
public async Task<ActionResult> GetUserById([FromRoute] int userId)
{
    // 执行授权验证
    var authResult = await _authorizationService.AuthorizeAsync(User, userId, new OwnUserRequirement());
    if (!authResult.Succeeded)
        return Forbid();

    var user = await unitOfWork.UserRepository.GetUserByIdAsync(userId);
    
    if (user == null)  
        return NotFound("User not found");

    return Ok(user);
}

4. 添加额外的用户状态验证 #

即使JWT验证通过，也可以增加一层数据库校验，确保用户状态合法（比如未被禁用、账号存在）：

[HttpGet("{userId:int}"), Authorize]
public async Task<ActionResult> GetUserById([FromRoute] int userId)
{
    if (!int.TryParse(User.FindFirstValue(ClaimTypes.NameIdentifier), out var currentUserId))
        return Unauthorized();

    if (currentUserId != userId)
        return Forbid();

    // 额外校验：确认用户存在且状态正常
    var user = await unitOfWork.UserRepository.GetUserByIdAsync(currentUserId);
    if (user == null || !user.IsActive)  
        return NotFound("User not found or account inactive");

    return Ok(user);
}

关键基础保障 #

无论使用哪种方案，都必须确保：

• API启用HTTPS，防止令牌在传输过程中被窃取
• JWT的签名密钥（Secret）严格保管，避免泄露
• JWT的过期时间设置合理，减少令牌被盗用的风险

内容的提问来源于stack exchange，提问作者dinoboy