Het JWT werd alleen op handtekening en looptijd gecontroleerd, dus een gedeactiveerde gebruiker kon tot het verlopen van het token lezen en schrijven. Nu controleert de bearer-validatie per request of het account bestaat en actief is, en weigert de refresh een inactieve gebruiker. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
172 lines
6.2 KiB
C#
172 lines
6.2 KiB
C#
using System.IdentityModel.Tokens.Jwt;
|
|
using System.Security.Claims;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using Microsoft.AspNetCore.Identity;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.Extensions.Logging;
|
|
using Microsoft.Extensions.Options;
|
|
using Microsoft.IdentityModel.Tokens;
|
|
using SlpModularCms.Core.Data;
|
|
using SlpModularCms.Core.Exceptions;
|
|
using SlpModularCms.Core.Identity.Entities;
|
|
using SlpModularCms.Core.Identity.Models;
|
|
using SlpModularCms.Core.Observability;
|
|
|
|
namespace SlpModularCms.Core.Identity.Services;
|
|
|
|
public class AuthService : IAuthService
|
|
{
|
|
private readonly UserManager<ApplicationUser> _userManager;
|
|
private readonly ApplicationDbContext _context;
|
|
private readonly JwtSettings _jwtSettings;
|
|
private readonly ILogger<AuthService> _logger;
|
|
|
|
public AuthService(
|
|
UserManager<ApplicationUser> userManager,
|
|
ApplicationDbContext context,
|
|
IOptions<JwtSettings> jwtSettings,
|
|
ILogger<AuthService> logger)
|
|
{
|
|
_userManager = userManager;
|
|
_context = context;
|
|
_jwtSettings = jwtSettings.Value;
|
|
_logger = logger;
|
|
}
|
|
|
|
public async Task<TokenResponse> AuthenticateAsync(string email, string password)
|
|
{
|
|
var user = await _userManager.FindByEmailAsync(email);
|
|
if (user == null || !user.IsActive || !await _userManager.CheckPasswordAsync(user, password))
|
|
{
|
|
// Repeated occurrences suggest an attack or a forgotten password, and whether the
|
|
// account exists is what tells those apart. Deliberately absent from the event: the
|
|
// password, the attempted password, and the address itself.
|
|
SecurityEvents.FailedLogin(_logger, "/api/v1/Auth/login", accountExists: user is not null);
|
|
|
|
throw new UnauthorizedException("Ongeldige inloggegevens.");
|
|
}
|
|
|
|
return await GenerateTokenResponseAsync(user);
|
|
}
|
|
|
|
public async Task<TokenResponse> RefreshTokenAsync(string refreshToken)
|
|
{
|
|
var savedRefreshToken = await _context.RefreshTokens
|
|
.Include(t => t.User)
|
|
.FirstOrDefaultAsync(t => t.Token == refreshToken);
|
|
|
|
if (savedRefreshToken == null || !savedRefreshToken.IsActive)
|
|
{
|
|
throw new UnauthorizedException("Ongeldig refresh token.");
|
|
}
|
|
|
|
if (savedRefreshToken.IsUsed)
|
|
{
|
|
// Re-use detection: trek alle tokens van de gebruiker in
|
|
var userId = savedRefreshToken.UserId;
|
|
var allTokens = await _context.RefreshTokens.Where(t => t.UserId == userId).ToListAsync();
|
|
foreach (var token in allTokens) token.IsRevoked = true;
|
|
await _context.SaveChangesAsync();
|
|
throw new UnauthorizedException("Mogelijk token misbruik gedetecteerd. Alle sessies zijn beëindigd.");
|
|
}
|
|
|
|
if (!savedRefreshToken.User.IsActive)
|
|
{
|
|
// A deactivated account must not get a new access token from a still-valid refresh token.
|
|
savedRefreshToken.IsRevoked = true;
|
|
await _context.SaveChangesAsync();
|
|
throw new UnauthorizedException("Ongeldig refresh token.");
|
|
}
|
|
|
|
savedRefreshToken.IsUsed = true;
|
|
await _context.SaveChangesAsync();
|
|
|
|
return await GenerateTokenResponseAsync(savedRefreshToken.User);
|
|
}
|
|
|
|
public async Task RevokeTokenAsync(string refreshToken)
|
|
{
|
|
var token = await _context.RefreshTokens.FirstOrDefaultAsync(t => t.Token == refreshToken);
|
|
if (token != null)
|
|
{
|
|
token.IsRevoked = true;
|
|
await _context.SaveChangesAsync();
|
|
}
|
|
}
|
|
|
|
public async Task ChangePasswordAsync(Guid userId, string currentPassword, string newPassword)
|
|
{
|
|
var user = await _userManager.FindByIdAsync(userId.ToString())
|
|
?? throw new UnauthorizedException("Gebruiker niet gevonden.");
|
|
|
|
var result = await _userManager.ChangePasswordAsync(user, currentPassword, newPassword);
|
|
if (!result.Succeeded)
|
|
{
|
|
var errors = string.Join(", ", result.Errors.Select(e => e.Description));
|
|
throw new ValidationException(errors);
|
|
}
|
|
}
|
|
|
|
private async Task<TokenResponse> GenerateTokenResponseAsync(ApplicationUser user)
|
|
{
|
|
var roles = await _userManager.GetRolesAsync(user);
|
|
var primaryRole = roles.FirstOrDefault() ?? "User";
|
|
|
|
var claims = new List<Claim>
|
|
{
|
|
new(JwtRegisteredClaimNames.Sub, user.Id.ToString()),
|
|
new(JwtRegisteredClaimNames.Email, user.Email!),
|
|
new(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
|
|
};
|
|
|
|
foreach (var role in roles)
|
|
{
|
|
claims.Add(new Claim(ClaimTypes.Role, role));
|
|
}
|
|
|
|
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_jwtSettings.Secret));
|
|
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
|
|
var expiry = DateTime.UtcNow.AddMinutes(_jwtSettings.ExpiryMinutes);
|
|
|
|
var token = new JwtSecurityToken(
|
|
_jwtSettings.Issuer,
|
|
_jwtSettings.Audience,
|
|
claims,
|
|
expires: expiry,
|
|
signingCredentials: creds
|
|
);
|
|
|
|
var accessToken = new JwtSecurityTokenHandler().WriteToken(token);
|
|
var refreshToken = GenerateRefreshToken();
|
|
|
|
_context.RefreshTokens.Add(new RefreshToken
|
|
{
|
|
Token = refreshToken,
|
|
UserId = user.Id,
|
|
ExpiryDate = DateTimeOffset.UtcNow.AddDays(_jwtSettings.RefreshTokenExpiryDays),
|
|
CreatedByIp = "Unknown" // In echte implementatie via HttpContextAccessor
|
|
});
|
|
|
|
await _context.SaveChangesAsync();
|
|
|
|
var userResponse = new UserResponse(
|
|
Id: user.Id,
|
|
Email: user.Email!,
|
|
Name: user.DisplayName ?? user.Email!,
|
|
Role: primaryRole,
|
|
IsActive: user.IsActive
|
|
);
|
|
|
|
return new TokenResponse(accessToken, refreshToken, expiry, userResponse);
|
|
}
|
|
|
|
private static string GenerateRefreshToken()
|
|
{
|
|
var randomNumber = new byte[32];
|
|
using var rng = RandomNumberGenerator.Create();
|
|
rng.GetBytes(randomNumber);
|
|
return Convert.ToBase64String(randomNumber);
|
|
}
|
|
}
|