Lab4/library/Services/TokenService.cs - master - egopen/Lab1

Lab4/library/Services/TokenService.cs
140 строк4 KB
Egopen
lab 4
01 ноя 2025, 18:03
01 ноя 2025, 18:0378d017c
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;
using Microsoft.IdentityModel.Tokens;

namespace library.Services
{
    public class TokenService
    {
        private readonly JwtSecurityTokenHandler _tokenHandler;

        public TokenService()
        {
            _tokenHandler = new JwtSecurityTokenHandler();
        }

        public string CreateAccessToken(string userId, string role)
        {
            var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Environment.GetEnvironmentVariable("SECRET_KEY")));
            var credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);

            var claims = new[]
            {
                new Claim("sub", userId),
                new Claim("role", role)
            };

            var token = new JwtSecurityToken(
                claims: claims,
                expires: DateTime.UtcNow.AddMinutes(15),
                signingCredentials: credentials
            );

            return _tokenHandler.WriteToken(token);
        }

        public string CreateRefreshToken(string userId)
        {
            var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Environment.GetEnvironmentVariable("SECRET_KEY")));
            var credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);

            var claims = new[]
            {
                new Claim("sub", userId)
            };

            var token = new JwtSecurityToken(
                claims: claims,
                expires: DateTime.UtcNow.AddMonths(1),
                signingCredentials: credentials
            );

            return _tokenHandler.WriteToken(token);
        }
        public ClaimsPrincipal? ValidateToken(string token, bool validateLifetime = true)
        {
            try
            {
                var tokenHandler = new JwtSecurityTokenHandler();
                var validationParameters = new TokenValidationParameters
                {
                    ValidateIssuerSigningKey = true,
                    IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Environment.GetEnvironmentVariable("SECRET_KEY"))),
                    ValidateIssuer = false,
                    ValidateAudience = false, 
                    ValidateLifetime = validateLifetime,
                    ClockSkew = TimeSpan.Zero 
                };

                var principal = tokenHandler.ValidateToken(token, validationParameters, out SecurityToken validatedToken);
                return principal;
            }
            catch (SecurityTokenException)
            {
                return null;
            }
            catch (Exception)
            {
                return null;
            }
        }
        public bool IsTokenValid(string token)
        {
            return ValidateToken(token) != null;
        }

        public string? GetUserIdFromToken(string token)
        {
            var principal = ValidateToken(token);
            return principal?.FindFirst(ClaimTypes.NameIdentifier)?.Value;
        }

        public string? GetUserRoleFromToken(string token)
        {
            var principal = ValidateToken(token);
            return principal?.FindFirst(ClaimTypes.Role)?.Value;
        }
        public string? RefreshAccessToken(string refreshToken, string role)
        {
            var principal = ValidateToken(refreshToken);

            if (principal == null)
                return null;

            var tokenType = principal.FindFirst("token_type")?.Value;
            if (tokenType != "refresh")
                return null;

            var userId = principal.FindFirst(JwtRegisteredClaimNames.Sub)?.Value;
            if (string.IsNullOrEmpty(userId))
                return null;

            return CreateAccessToken(userId, role);
        }

        public IEnumerable<Claim>? GetClaimsFromExpiredToken(string token)
        {
            try
            {
                var jwtToken = _tokenHandler.ReadJwtToken(token);
                return jwtToken.Claims;
            }
            catch
            {
                return null;
            }
        }
        public Guid GetCurrentUserId(string token)
        {
            var userIdString = this.GetUserIdFromToken(token);

            if (string.IsNullOrEmpty(userIdString) || !Guid.TryParse(userIdString, out Guid userId))
            {
                throw new UnauthorizedAccessException("Invalid token");
            }

            return userId;
        }
    }
}