Files
slp-modular-cms/src/SlpModularCms.Core/Identity/Services/AuthService.cs
T
SluijsensandClaude Sonnet 5.5 33a7500648 Beveiliging: gedeactiveerde of verwijderde gebruiker wordt direct geweigerd
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>
2026-11-08 14:36:09 +01:00

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);
}
}