Levge.Identity 2.3.0

Levge.Identity

.NET 10 uygulamaları için JWT tabanlı kimlik doğrulama ve yetkilendirme altyapısı.
Tenant destekli, enum tabanlı rol hiyerarşisi ve clean architecture uyumlu tasarım.

İçindekiler

• Kurulum
• Program.cs
• JwtConfig Referansı
• Token Üretimi — LevgeClaimsFactory
• IJwtTokenService
• ICurrentUser
• Yetkilendirme — LevgePolicies
• IPasswordHasher
• ICodeGenerator
• LevgeClaimTypes
• Bağımlılıklar

Kurulum

dotnet add package Levge.Identity
dotnet add package Levge.Domain

Program.cs

builder.Services
    .AddLevgeIdentity(new JwtConfig
    {
        Secret   = "en-az-32-karakter-uzun-gizli-anahtar",
        Issuer   = "https://api.levge.com",
        Audience = "https://api.levge.com",
        AccessTokenExpirationMinutes  = 60,
        RefreshTokenExpirationMinutes = 43200   // 30 gün
    })
    .AddLevgeAuthorization();

// Middleware sırası
app.UseAuthentication();
app.UseAuthorization();

Özel bir IIdentityProvider implemente ettiyseniz:

builder.Services.AddLevgeIdentity<MyCustomProvider>(jwtConfig);

JwtConfig Referansı

Token Üretimi — LevgeClaimsFactory

Application katmanında token oluşturmadan önce standart claim listesi üretin:

using Levge.Identity;
using Levge.Domain.Enums;

// Temel kullanım
var claims = LevgeClaimsFactory.Create(
    userId:     user.Id,
    email:      user.Email,
    role:       AppUserRole.TenantOwner,
    tenantId:   user.TenantId,
    tenantName: user.TenantName,
    roleId:     user.RoleId
);

var accessToken  = _jwtTokenService.GenerateAccessToken(claims);
var refreshToken = _jwtTokenService.GenerateRefreshToken();
var expiresAt    = _jwtTokenService.GetAccessTokenExpireTime();

Ek claim eklemek için extra parametresini kullanın:

var claims = LevgeClaimsFactory.Create(
    userId: user.Id,
    email:  user.Email,
    role:   AppUserRole.SuperAdmin,
    extra:  [new Claim("custom_key", "custom_value")]
);

IJwtTokenService

public interface IJwtTokenService
{
    string             GenerateAccessToken(IEnumerable<Claim> claims);
    string             GenerateRefreshToken();
    DateTime           GetAccessTokenExpireTime();
    DateTime           GetRefreshTokenExpireTime();
    ClaimsPrincipal?   GetPrincipalFromExpiredToken(string accessToken);
}

Refresh Token Akışı

GetPrincipalFromExpiredToken imzayı doğrular ancak süre kontrolü yapmaz — süresi dolmuş access token'dan kullanıcıyı tanımlamak için kullanılır:

[HttpPost("refresh")]
public async Task<IActionResult> Refresh([FromBody] RefreshRequest request)
{
    var principal = _jwtTokenService.GetPrincipalFromExpiredToken(request.AccessToken);
    if (principal is null)
        return Unauthorized();

    var userId = long.Parse(principal.FindFirstValue(LevgeClaimTypes.UserId)!);
    var user   = await _userRepo.GetWithRefreshTokenAsync(userId, request.RefreshToken);

    if (user is null || user.RefreshTokenExpiry < DateTime.UtcNow)
        return Unauthorized();

    var claims       = LevgeClaimsFactory.Create(user.Id, user.Email, user.AppRole, user.TenantId);
    var accessToken  = _jwtTokenService.GenerateAccessToken(claims);
    var refreshToken = _jwtTokenService.GenerateRefreshToken();

    await _userRepo.UpdateRefreshTokenAsync(user.Id, refreshToken,
        _jwtTokenService.GetRefreshTokenExpireTime());

    return Ok(new { AccessToken = accessToken, RefreshToken = refreshToken });
}

ICurrentUser

Herhangi bir servis veya controller'a inject ederek mevcut kullanıcıyı okuyun:

public class OrderService
{
    private readonly ICurrentUser _currentUser;

    public OrderService(ICurrentUser currentUser)
        => _currentUser = currentUser;

    public void Create()
    {
        if (!_currentUser.IsAuthenticated)
            throw new UnauthorizedAccessException();

        long   userId     = _currentUser.UserId!.Value;
        string email      = _currentUser.Email!;
        long   tenantId   = _currentUser.TenantId!.Value;
        string tenantName = _currentUser.TenantName!;
        string deviceId   = _currentUser.DeviceId ?? "unknown";

        // Enum tabanlı rol kontrolü
        AppUserRole? role = _currentUser.AppRole;  // AppUserRole.TenantOwner

        // Hiyerarşik rol kontrolü
        bool canManage = _currentUser.IsInRole(AppUserRole.TenantOwner);
        // SuperAdmin   → true (hepsi)
        // TenantOwner  → true (TenantOwner + TenantUser)
        // TenantUser   → false

        // Ham claim okuma
        string? custom = _currentUser.GetClaimValue("my_claim");
        string? header = _currentUser.GetHeaderValue("X-Correlation-Id");
    }
}

ICurrentUser Üyeleri

Yetkilendirme — LevgePolicies

AddLevgeAuthorization() üç hiyerarşik policy kaydeder:

// Controller veya endpoint üzerinde kullanım
[Authorize(Policy = LevgePolicies.SuperAdmin)]
[HttpDelete("admin/users/{id}")]
public IActionResult DeleteUser(long id) { ... }

[Authorize(Policy = LevgePolicies.TenantOwner)]
[HttpGet("tenant/reports")]
public IActionResult GetReports() { ... }

[Authorize(Policy = LevgePolicies.TenantUser)]
[HttpGet("me")]
public IActionResult GetProfile() { ... }

AppUserRole Enum

public enum AppUserRole
{
    SuperAdmin  = 0,   // Tüm tenant'lar üzerinde tam yetki
    TenantOwner = 1,   // Kendi tenant'ı üzerinde tam yetki
    TenantUser  = 2    // Standart tenant kullanıcısı
}

IPasswordHasher

PBKDF2 algoritmasıyla şifre karma ve doğrulama:

public interface IPasswordHasher
{
    string Hash(string password);
    bool   Verify(string password, string hashedPassword);
}

// Kayıt
var hashed = _passwordHasher.Hash(request.Password);

// Giriş
bool valid = _passwordHasher.Verify(request.Password, user.PasswordHash);
if (!valid) return Unauthorized();

ICodeGenerator

public interface ICodeGenerator
{
    string GenerateNumericCode(int length = 6);
    string GenerateAlphaNumericCode(int length = 8);
    string GenerateScopedCode(string scopeKey, string entityId);
    string GeneratePassword(int length, int minUpper = 1, int minDigits = 1,
                            int minSpecial = 1, string specialChars = "!@#$%^&*");
}

// OTP
var otp = _codeGenerator.GenerateNumericCode();           // 6 hane

// E-posta doğrulama linki için
var token = _codeGenerator.GenerateScopedCode("email-verify", user.Id.ToString());

// Geçici parola
var tempPwd = _codeGenerator.GeneratePassword(length: 12, minUpper: 2, minSpecial: 2);

LevgeClaimTypes

Token üretimi ve okuma arasında tutarlılık için sabitler — her iki tarafta da bu sabitleri kullanın:

public static class LevgeClaimTypes
{
    public const string UserId     = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier";
    public const string Email      = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress";
    public const string Role       = "http://schemas.microsoft.com/ws/2008/06/identity/claims/role";
    public const string RoleId     = "role_id";
    public const string TenantId   = "tenant_id";
    public const string TenantName = "tenant_name";
}

Clean Architecture Örneği

src/
├── MyApp.Domain/
├── MyApp.Application/
│   └── Features/Auth/
│       ├── LoginCommand.cs
│       └── LoginCommandHandler.cs     ← LevgeClaimsFactory + IJwtTokenService burada
├── MyApp.Infrastructure/
│   └── Persistence/UserRepository.cs
└── MyApp.WebApi/
    ├── Program.cs                     ← AddLevgeIdentity + AddLevgeAuthorization
    └── Controllers/AuthController.cs

// Application katmanı — LoginCommandHandler.cs
public class LoginCommandHandler
{
    private readonly IJwtTokenService _jwt;
    private readonly IPasswordHasher  _hasher;
    private readonly IUserRepository  _users;

    public async Task<TokenResponse> Handle(LoginCommand cmd)
    {
        var user = await _users.FindByEmailAsync(cmd.Email)
            ?? throw new UnauthorizedException();

        if (!_hasher.Verify(cmd.Password, user.PasswordHash))
            throw new UnauthorizedException();

        var claims = LevgeClaimsFactory.Create(
            userId:     user.Id,
            email:      user.Email,
            role:       user.AppRole,
            tenantId:   user.TenantId,
            tenantName: user.TenantName
        );

        return new TokenResponse(
            AccessToken:  _jwt.GenerateAccessToken(claims),
            RefreshToken: _jwt.GenerateRefreshToken(),
            ExpiresAt:    _jwt.GetAccessTokenExpireTime()
        );
    }
}

// WebApi katmanı — Controller
[ApiController, Route("api/auth")]
public class AuthController : ControllerBase
{
    private readonly ICurrentUser _currentUser;

    [HttpPost("login")]
    [AllowAnonymous]
    public Task<IActionResult> Login([FromBody] LoginCommand cmd) { ... }

    [HttpGet("me")]
    [Authorize(Policy = LevgePolicies.TenantUser)]
    public IActionResult Me() => Ok(new
    {
        _currentUser.UserId,
        _currentUser.Email,
        _currentUser.AppRole,
        _currentUser.TenantId,
        _currentUser.TenantName
    });
}

Bağımlılıklar