Session鉴权

自定义 Session 鉴权的实现思路和过程，主要围绕以下几个关键点展开：

1. Session 的存储和管理：Session 是一种基于服务器的身份状态保持机制。客户端（通常是通过 Cookie）持有一个 Session ID，服务器通过这个 ID 识别该用户的会话信息。
2. Session 鉴权的核心逻辑：当客户端发起请求时，服务器通过解析请求中的 Session ID 来查找用户信息，进行身份验证和授权。
3. 自定义 Session 鉴权流程：我们可以自定义实现 Session 的生成、存储、检索及失效处理等功能，替代传统的认证方式（如 JWT）。

实现思想

1. Session ID 的生成和管理：

   • 每当用户成功登录时，服务器生成一个唯一的 Session ID，并将该 Session ID 与用户信息（例如用户 ID、角色、权限等）关联。
   • 将 Session ID 存储在服务器端（例如内存、数据库或分布式缓存中），并通过 HTTP 响应将 Session ID 设置为客户端 Cookie。

2. Session ID 的校验：

   • 每次请求时，服务器从请求中解析出 Session ID（通常是从 Cookie 中）。
   • 在服务器端查找与该 Session ID 关联的用户信息，验证会话是否有效。如果有效，允许请求继续处理；否则，拒绝访问并提示用户重新登录。

3. Session 生命周期管理：

   • Session 通常有一个超时设置，即在用户一段时间内没有活动后，Session 自动失效。可以通过定时任务清理过期的 Session，或设置 Session 的有效期，并在用户活动时刷新 Session 的过期时间。

4. 安全性考虑：

   • Session ID 应该足够复杂和随机，防止被猜测或伪造。
   • 可以设置 Session ID 的生命周期，定期刷新，避免长时间未失效的 Session 被利用。
   • HTTPS 传输，确保 Session ID 不被中间人攻击截获。

过程与代码实现

1. 生成Session ID 并存储

public class SessionService
{
    private readonly IDistributedCache _cache; // 或 IMemoryCache

    public SessionService(IDistributedCache cache)
    {
        _cache = cache;
    }

    public string CreateSession(string userId)
    {
        // 生成唯一的 Session ID
        var sessionId = Guid.NewGuid().ToString();
        // 保存用户信息（例如 userId）到缓存中
        _cache.SetString(sessionId, userId, new DistributedCacheEntryOptions
        {
            AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(30) // 设置Session超时时间
        });

        return sessionId;
    }

    public string GetUserBySession(string sessionId)
    {
        // 从缓存中获取用户信息
        var userId = _cache.GetString(sessionId);
        return userId;
    }

    public void InvalidateSession(string sessionId)
    {
        // 移除Session
        _cache.Remove(sessionId);
    }
}

2. 设置和获取客户端 Cookie 中的 Session ID

在用户登录成功后，将生成的 Session ID 写入 HTTP 响应的 Cookie 中：

public IActionResult Login(string username, string password)
{
    // 假设验证成功，获取 userId
    string userId = AuthenticateUser(username, password);

    if (userId != null)
    {
        // 生成Session
        var sessionId = _sessionService.CreateSession(userId);

        // 设置Session ID到客户端 Cookie
        Response.Cookies.Append("SessionId", sessionId, new CookieOptions
        {
            HttpOnly = true, // 防止客户端JavaScript访问，提升安全性
            Secure = true,   // 仅在 HTTPS 连接上传输
            Expires = DateTimeOffset.Now.AddMinutes(30)
        });

        return Ok("Login successful");
    }

    return Unauthorized("Invalid username or password");
}

3. 自定义中间件解析Session并鉴权

接下来，使用自定义中间件来从每个请求的 Cookie 中提取 Session ID，并通过 Session 服务验证用户身份。

public class SessionMiddleware
{
    private readonly RequestDelegate _next;
    private readonly SessionService _sessionService;

    public SessionMiddleware(RequestDelegate next, SessionService sessionService)
    {
        _next = next;
        _sessionService = sessionService;
    }

    public async Task Invoke(HttpContext context)
    {
        if (context.Request.Cookies.ContainsKey("SessionId"))
        {
            var sessionId = context.Request.Cookies["SessionId"];
            var userId = _sessionService.GetUserBySession(sessionId);

            if (userId != null)
            {
                // 验证通过，创建用户身份信息
                var claims = new List<Claim>
                {
                    new Claim(ClaimTypes.Name, userId)
                };
                var identity = new ClaimsIdentity(claims, "SessionAuth");
                var principal = new ClaimsPrincipal(identity);

                context.User = principal;
            }
        }

        // 调用下一个中间件
        await _next(context);
    }
}

4. 在 Startup.cs 中注册中间件

将自定义的 Session 中间件添加到请求管道中：

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddDistributedMemoryCache(); // 使用内存缓存来存储Session
        services.AddSingleton<SessionService>();
    }

    public void Configure(IApplicationBuilder app)
    {
        app.UseMiddleware<SessionMiddleware>(); // 注册自定义Session中间件

        app.UseAuthentication(); // 如果有其他鉴权机制，如 JWT 或 Cookie

        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });
    }
}

5. 使用授权过滤器

在需要鉴权的控制器或操作方法上，使用 [Authorize] 属性进行限制：

[Authorize]
[ApiController]
[Route("api/[controller]")]
public class ProtectedController : ControllerBase
{
    [HttpGet]
    public IActionResult Get()
    {
        return Ok("You are authorized with a valid session!");
    }
}

鉴权流程：

1. 用户登录：当用户登录成功时，服务器生成一个 Session ID，将其与用户信息关联并存储在服务器端（如缓存或数据库）。同时，服务器将 Session ID 作为 Cookie 返回给客户端。

2. 客户端请求：每次客户端发起请求时，都会自动附带该 Session ID（通过浏览器的 Cookie 机制）。

3. Session 验证：自定义的 SessionMiddleware 从请求中提取 Session ID，并通过 SessionService 验证 Session 的有效性。如果 Session 有效，将用户信息注入到 HttpContext.User 中。

4. 授权控制：在需要进行鉴权的控制器或方法上使用 [Authorize]，如果 HttpContext.User 存在有效的用户信息，则允许访问，否则拒绝请求。

思考与扩展：

1. Session 的持久化：如果应用是分布式的（多个服务器实例），可以使用分布式缓存（如 Redis）来存储 Session 信息，确保各个服务器实例可以共享 Session 数据。

2. Session 的安全性：确保 Session ID 传输时使用 HTTPS 加密，防止被窃听。同时，Session ID 需要具备足够的复杂度，避免被猜测或暴力破解。

3. Session 的刷新机制：可以在每次用户请求时，刷新 Session 的过期时间，延长用户的会话时间。

4. 多因素认证（MFA）：可以结合 Session 鉴权和多因素认证，提高系统的安全性。

5. Token + Session 结合：可以结合 JWT Token 的方案，将部分用户身份信息存储在 Token 中，而将更敏感的信息存储在 Session 中，实现 Token 和 Session 的双重验证。

通过这些思路和过程，你可以在 C# 中实现一个自定义的 Session 鉴权机制，并根据实际的业务需求进行调整和优化。