ASP.NET Core: Secure Authentication with Tokens

Getting Started with Authentication

Authentication vs. authorization

Authentication ve authorization, güvenlik açısından iki temel kavramdır ve genellikle birlikte kullanılırlar, ancak farklı amaçlara hizmet ederler.

• Authentication (Kimlik Doğrulama): Authentication, kullanıcıların kimliklerini doğrulama sürecidir. Kullanıcıların kimliklerini doğrulamak, onların kim olduklarını belirlemek anlamına gelir. Kullanıcıların kimliklerini doğrulamak için farklı yöntemler kullanılabilir, örneğin parola, biyometrik veriler, sosyal medya hesaplarıyla oturum açma vb.Örnek bir kod parçası:

[HttpPost]
public async Task<IActionResult> Login(LoginModel model)
{
    var user = await _userManager.FindByNameAsync(model.Username);
    if (user != null && await _userManager.CheckPasswordAsync(user, model.Password))
    {
        // Kullanıcı doğrulandı
        // Token oluşturulur veya oturum açma işlemi gerçekleştirilir
        return Ok("Authentication successful");
    }
    // Doğrulama başarısız
    return Unauthorized();
}

Authorization (Yetkilendirme): Authorization, doğrulanmış kullanıcıların belirli kaynaklara veya eylemlere erişim izinlerini kontrol etme sürecidir. Yani, authentication işleminden sonra, authorization işlemi gerçekleşir. Yetkilendirme, kullanıcıların kimlik doğrulamasını geçtikten sonra belirli bir kaynağa veya eyleme erişip erişemeyeceğini belirler. Bu genellikle kullanıcıların rollerine, izinlerine veya diğer kimlik belirteçlerine dayanır.

Örnek bir kod parçası:

[Authorize(Roles = "Admin")]
[HttpGet("admin")]
public IActionResult AdminPage()
{
    // Sadece Admin rolüne sahip kullanıcılar bu sayfaya erişebilir
    return Ok("Welcome Admin!");
}

Authentication ve authorization, web uygulamalarının güvenliğini sağlamak için önemlidir. Authentication, doğru kullanıcıların sistemde oturum açmasını sağlar, authorization ise bu kullanıcıların sistemdeki kaynaklara ve işlemlere erişimini kontrol eder. İkisi birlikte çalışarak, sistemlerin güvenliğini sağlamak için güçlü bir mekanizma oluştururlar.

Cookie-based vs. token-based authentication

Cookie tabanlı kimlik doğrulama ve token tabanlı kimlik doğrulama, web uygulamalarında kullanılan iki yaygın kimlik doğrulama yöntemidir. Her birinin avantajları ve dezavantajları vardır ve kullanılacak senaryoya göre tercih edilebilirler.

• Cookie Tabanlı Kimlik Doğrulama:
  • Nasıl Çalışır: Sunucu, kullanıcı doğrulandığında, bir oturum kimliği (session ID) gibi bir belirteç oluşturur ve bu belirteci bir cookie içine yerleştirir. Bu cookie, kullanıcının tarayıcısında saklanır ve her istekle birlikte sunucuya gönderilir. Sunucu, her isteği bu oturum kimliğiyle eşleştirir ve bu sayede kullanıcının kimliğini doğrular.
  • Avantajları:
    • Kolay Kullanım: Oturum yönetimi otomatik olarak gerçekleşir, geliştiricinin ekstra kod yazması gerekmez.
    • Tarayıcı Doğrulamasına Dayalı: Kullanıcıların tarayıcı ayarlarına ve güvenlik politikalarına dayanır, bu nedenle genellikle güvenlidir.
  • Dezavantajları:
    • CSRF Saldırılarına Hassas: Cookie tabanlı kimlik doğrulama, Cross-Site Request Forgery (CSRF) saldırılarına karşı hassastır.
    • Ölçeklenebilirlik: Oturum verilerinin sunucu tarafında saklanması gerektiğinden, ölçeklenebilirlik sorunlarına yol açabilir.
  Örnek bir ASP.NET Core kod parçası:

services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
    .AddCookie(options =>
    {
        options.LoginPath = "/Account/Login";
        options.AccessDeniedPath = "/Account/AccessDenied";
    });

Token Tabanlı Kimlik Doğrulama:

Nasıl Çalışır: Kullanıcı kimliği doğrulandığında, sunucu bir JWT (JSON Web Token) gibi bir belirteç oluşturur ve bu belirteci istemciye gönderir. İstemci, bu belirteci saklar ve her istekle birlikte sunucuya gönderir. Sunucu, bu belirteci doğrular ve kullanıcının kimliğini belirler.

Avantajları:

CSRF Saldırılarına Dirençli: Tokenler, CSRF saldırılarına karşı daha dirençlidir, çünkü istemciye gönderilen belirteçler doğrulanmalıdır.
Ölçeklenebilirlik: Oturum verilerinin sunucu tarafında saklanmasına gerek olmadığından, ölçeklenebilirlik açısından daha iyidir.

Dezavantajları:

Komplekslik: Token tabanlı kimlik doğrulama, uygulamanın biraz daha karmaşık olmasına neden olabilir.
Ekstra Geliştirme: Tokenleri doğrulamak ve yönetmek için ekstra kod yazmak gerekir.

Örnek bir ASP.NET Core kod parçası:

services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = Configuration["Jwt:Issuer"],
            ValidAudience = Configuration["Jwt:Audience"],
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration["Jwt:Key"]))
        };
    });

Her iki yaklaşımın da kendine özgü avantajları ve dezavantajları vardır. Uygulamanın gereksinimlerine ve güvenlik politikalarına bağlı olarak, uygun olanı seçilmelidir.

What is identity platform?

Identity platform, kullanıcıların kimlik doğrulama ve yetkilendirme işlemlerini yönetmek için kullanılan bir hizmet veya sistemdir. Bu platformlar, genellikle kullanıcıların kimliklerini doğrulamak, kullanıcıları yönetmek, oturum yönetimini sağlamak, yetkilendirme politikalarını uygulamak ve güvenlikle ilgili diğer görevleri yerine getirmek için kullanılır.

ASP.NET Core Identity Framework, bir identity platform örneğidir. ASP.NET Core Identity, .NET Core tabanlı web uygulamaları için entegre bir kimlik ve erişim yönetimi çözümü sunar. Bu çözüm, kullanıcıların kimliklerini doğrulamak, kullanıcıları yönetmek, rolleri ve izinleri tanımlamak, oturum yönetimini sağlamak ve diğer kimlik ve erişim yönetimi işlevlerini yerine getirmek için kullanılır.

ASP.NET Core Identity, .NET Core web uygulamalarında kimlik doğrulama ve yetkilendirme işlemlerini sağlamak için kullanılır. Bu çerçeve, kullanıcıların kaydını oluşturmayı, oturum açmayı, rolleri ve izinleri yönetmeyi, parola sıfırlama işlemlerini gerçekleştirmeyi ve diğer kimlik ve erişim yönetimi işlevlerini kolaylaştırmayı sağlar.

Örnek bir ASP.NET Core Identity kullanımı:

• Proje Yapısını Ayarlama: Bir ASP.NET Core projesi oluşturulurken, kimlik doğrulama özelliği etkinleştirilebilir. Bu, proje şablonunu oluştururken veya sonradan yapılandırılırken yapılabilir.
• Kullanıcıları Yönetme: Kullanıcılar, roller ve izinler ASP.NET Core Identity Framework ile kolayca yönetilebilir. Kullanıcıları oluşturmak, güncellemek, silmek, rolleri atamak ve izinleri tanımlamak için bir dizi API sağlanır.
• Oturum Yönetimi: ASP.NET Core Identity, kullanıcı oturumlarını yönetmek için dahili bir mekanizma sunar. Kullanıcıların oturum açmaları, oturumlarını kapamaları, parolalarını sıfırlamaları vb. işlemler ASP.NET Core Identity tarafından desteklenir.
• Yetkilendirme ve Kimlik Doğrulama: ASP.NET Core Identity, kullanıcıların oturum açmasını ve belirli kaynaklara erişimini kontrol etmek için yetkilendirme ve kimlik doğrulama işlemlerini sağlar. Bu, [Authorize] özniteliği ve yetkilendirme politikaları kullanılarak gerçekleştirilir.

Özetle, identity platformlar, kimlik doğrulama ve yetkilendirme işlemlerini yönetmek ve web uygulamalarında güvenlik sağlamak için kullanılır. ASP.NET Core Identity, .NET Core tabanlı uygulamalarda kimlik yönetimi işlemlerini kolaylaştıran bir identity platform örneğidir. Bu çözüm, kullanıcıların kimliklerini doğrulamak, oturum yönetimi sağlamak, kullanıcıları yönetmek ve diğer kimlik ve erişim yönetimi işlevlerini yerine getirmek için kullanılabilir.

JSON Web Token

JSON Web Token (JWT), modern web uygulamalarında kullanılan bir kimlik doğrulama ve yetkilendirme mekanizmasıdır. JWT, JSON formatında verileri taşıyan ve dijital olarak imzalanmış bir belirteçtir. Genellikle kullanıcı oturumlarını yönetmek, güvenli bir şekilde kimlik doğrulama ve yetkilendirme bilgilerini taşımak için kullanılır.

JWT’nin temel yapısı üç bölümden oluşur: başlık (header), yük (payload) ve imza (signature).

• Başlık (Header): JWT’nin başlık bölümü, belirtecin türünü (typ) ve kullanılan algoritmayı (alg) içerir. Örnek bir başlık JSON nesnesi aşağıdaki gibi olabilir:

{
  "alg": "HS256",
  "typ": "JWT"
}

Yük (Payload): JWT’nin yük bölümü, taşınacak verileri içerir. Bu veriler, kullanıcı bilgileri, roller, izinler gibi kimlik doğrulama ve yetkilendirme bilgilerini içerebilir. Örnek bir yük JSON nesnesi şu şekilde olabilir:

{
  "sub": "1234567890",
  "name": "John Doe",
  "admin": true
}

• İmza (Signature): JWT’nin imza bölümü, başlık ve yük bölümlerinin birleştirilip belirli bir algoritma kullanılarak dijital olarak imzalanmasıyla oluşturulur. Bu imza, JWT’nin güvenliğini sağlar ve değiştirilmediğini doğrular.

JWT’nin yaygın kullanım senaryoları şunlardır:

Örnek bir JWT oluşturma ve doğrulama işlemi ASP.NET Core için şu şekilde yapılabilir:

// JWT oluşturma
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes("my_secret_key");

var tokenDescriptor = new SecurityTokenDescriptor
{
    Subject = new ClaimsIdentity(new Claim[]
    {
        new Claim(ClaimTypes.Name, "John Doe"),
        new Claim(ClaimTypes.Role, "Admin"),
        // Diğer talep (claim) bilgileri buraya eklenebilir
    }),
    Expires = DateTime.UtcNow.AddDays(7),
    SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};

var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);

// JWT doğrulama
var tokenValidationParameters = new TokenValidationParameters
{
    ValidateIssuerSigningKey = true,
    IssuerSigningKey = new SymmetricSecurityKey(key),
    ValidateIssuer = false,
    ValidateAudience = false,
    RequireExpirationTime = true,
    ValidateLifetime = true
};

var tokenHandler = new JwtSecurityTokenHandler();
var claimsPrincipal = tokenHandler.ValidateToken(tokenString, tokenValidationParameters, out var validatedToken);

// Token doğrulandıktan sonra, talep (claim) bilgilerine erişilebilir

Bu örnek, bir JWT oluştururken kullanıcı bilgilerini ve rol bilgilerini içeren bir JWT yaratır. Ayrıca, JWT’nin doğrulama sürecini gösterir, yani JWT’nin imzasını doğrular ve içindeki bilgileri çözer.

Token-Based Authentication

Setting up Entity Framework Core

Token tabanlı kimlik doğrulama için Entity Framework Core (EF Core) kullanarak bir veritabanı bağlantısı kurmak oldukça yaygın bir uygulamadır. Bu, kullanıcı bilgilerini ve yetkilendirme verilerini saklamak için veritabanı kullanmanın tipik bir yoludur.

• EF Core NuGet Paketini Yükleme: Projenize EF Core NuGet paketini ekleyin. Bunun için aşağıdaki komutu NuGet Package Manager Console’da veya .NET CLI’da çalıştırabilirsiniz:

dotnet add package Microsoft.EntityFrameworkCore.SqlServer

Veritabanı Bağlantı Dizesini Ayarlama: appsettings.json veya appsettings.Development.json dosyasına veritabanı bağlantı dizesini ekleyin:

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=MyDatabase;Trusted_Connection=True;MultipleActiveResultSets=true"
  }
}

Veritabanı Bağlantısını Yapılandırma: ConfigureServices yöntemi içinde, DbContext sınıfını ve bağlantı dizesini yapılandırın:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
    
    // Diğer servis yapılandırmaları...
}

Veritabanı Bağlantısını Kullanarak Model Oluşturma: Veritabanında saklanacak olan veri modellerini tanımlayın. Örneğin, bir kullanıcı modeli:

public class ApplicationUser : IdentityUser
{
    // Kullanıcıya özgü alanlar...
}

Migration’lar Oluşturma ve Veritabanına Uygulama: Entity Framework Core Migration aracını kullanarak veritabanında değişiklikler için migration’lar oluşturun ve ardından bu değişiklikleri veritabanına uygulayın:

dotnet ef migrations add InitialCreate
dotnet ef database update

Bu adımları takip ederek, ASP.NET Core projesinde EF Core kullanarak bir veritabanı bağlantısı kurabilirsiniz. Bu sayede, kullanıcıların kimlik bilgilerini ve yetkilendirme verilerini veritabanında saklayabilir ve token tabanlı kimlik doğrulaması için gereken verilere erişebilirsiniz.

Adding default identity tables using EF Core

ASP.NET Core uygulamalarında kimlik doğrulama ve yetkilendirme işlemleri için varsayılan olarak sunulan Identity Framework’ü kullanmak oldukça yaygındır. Entity Framework Core (EF Core) ile birlikte Identity Framework’ü kullanarak, kullanıcıları ve rolleri saklamak için veritabanında varsayılan tabloları oluşturmak oldukça kolaydır.

• Identity Framework’ü Yüklemek: İlk olarak, projenize ASP.NET Core Identity NuGet paketini ekleyin. Bunun için aşağıdaki komutu NuGet Package Manager Console’da veya .NET CLI’da çalıştırabilirsiniz:

dotnet add package Microsoft.AspNetCore.Identity.EntityFrameworkCore

DbContext Sınıfını Oluşturmak: EF Core tarafından kullanılacak olan DbContext sınıfını oluşturun ve IdentityDbContext sınıfını genişletin. Bu sınıf, Identity Framework’ün varsayılan tablolarını içerecektir.

using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;

public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options)
    {
    }
}

Startup Sınıfında Servisleri Yapılandırmak: ConfigureServices yöntemi içinde, Identity Framework’ü ve DbContext’i yapılandırın:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

    services.AddDefaultIdentity<ApplicationUser>(options => options.SignIn.RequireConfirmedAccount = true)
        .AddEntityFrameworkStores<ApplicationDbContext>();
    
    // Diğer servis yapılandırmaları...
}

Migration’lar Oluşturma ve Veritabanına Uygulama: Şimdi, Entity Framework Core Migration aracını kullanarak Identity Framework tarafından tanımlanan varsayılan tablolar için bir migration oluşturun ve bu değişiklikleri veritabanına uygulayın:

dotnet ef migrations add InitialIdentity
dotnet ef database update

Bu adımları takip ederek, EF Core kullanarak Identity Framework’ün varsayılan tablolarını veritabanında oluşturabilirsiniz. Bu tablolar, kullanıcıları, rolleri, parola hash’lerini ve diğer kimlik doğrulama ve yetkilendirme verilerini saklar. Bu sayede, ASP.NET Core uygulamanızda kullanıcı kimlik doğrulama ve yetkilendirme işlemlerini kolayca gerçekleştirebilirsiniz.

Configuring token-based authentication

Token tabanlı kimlik doğrulama için ASP.NET Core’da yapılandırma oldukça önemlidir. Token tabanlı kimlik doğrulama, JWT gibi bir tokenin kullanıcı kimliğini doğrulamak için kullanılmasını içerir.

• JWT Paketini Yükleme: İlk olarak, JWT’nin ASP.NET Core projesine eklenmesi gerekir. Bu işlem için Microsoft.AspNetCore.Authentication.JwtBearer NuGet paketini kullanabilirsiniz:

dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer

Authentication Middleware Ayarlarını Yapılandırma: ConfigureServices yöntemi içinde, JWT tabanlı kimlik doğrulama için gerekli servisleri ve yapılandırmaları ekleyin:

using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.IdentityModel.Tokens;
using System.Text;

public void ConfigureServices(IServiceCollection services)
{
    services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
        .AddJwtBearer(options =>
        {
            options.TokenValidationParameters = new TokenValidationParameters
            {
                ValidateIssuer = true,
                ValidateAudience = true,
                ValidateLifetime = true,
                ValidateIssuerSigningKey = true,
                ValidIssuer = "your-issuer",
                ValidAudience = "your-audience",
                IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("your-secret-key"))
            };
        });

    // Diğer servis yapılandırmaları...
}

Authentication Middleware’i Kullanma: Configure yöntemi içinde, kimlik doğrulama middleware’ini ekleyin ve kullanın:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // Diğer middleware'ler...

    app.UseAuthentication();
    app.UseAuthorization();

    // Diğer middleware'ler...
}

• JWT Oluşturma ve Doğrulama: Kullanıcı girişi sırasında, JWT oluşturun ve kullanıcıya gönderin. Her istekte, gelen JWT’yi doğrulayın ve kullanıcı bilgilerine erişim izni verin.

Bu adımları takip ederek, ASP.NET Core uygulamanızda token tabanlı kimlik doğrulama sağlayabilirsiniz. Bu yapılandırmada, JWT tokenlerinin doğruluğu, hangi ISSUER ve AUDIENCE’ye ait olduğu gibi kritik güvenlik kontrolleri sağlanmaktadır. Ayrıca, bu yapılandırmada kullanılan güvenlik anahtarını (secret key) korumak da büyük önem taşır.

Adding the authentication controller

Token tabanlı kimlik doğrulama için ASP.NET Core’da bir kimlik doğrulama kontrolcüsü eklemek oldukça önemlidir. Bu kontrolcü, kullanıcıların kimlik bilgilerini doğrulamak ve JWT tokenleri almak için kullanılır.

• Authentication Controller Oluşturma: İlk olarak, bir kimlik doğrulama kontrolcüsü oluşturun. Bu kontrolcü, kullanıcıların kimlik doğrulama işlemlerini gerçekleştirecek HTTP isteklerini işleyecektir. Örneğin, AuthenticationController adında bir kontrolcü oluşturalım:

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.IdentityModel.Tokens;
using System;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;

[Route("api/[controller]")]
[ApiController]
public class AuthenticationController : ControllerBase
{
    private readonly IConfiguration _configuration;

    public AuthenticationController(IConfiguration configuration)
    {
        _configuration = configuration;
    }

    [HttpPost]
    [Route("login")]
    public IActionResult Login(string username, string password)
    {
        // Kullanıcı adı ve şifreyi doğrula (örneğin, veritabanından kontrol edilebilir)

        // Kullanıcı bilgileri doğrulanırsa, JWT oluştur
        var token = GenerateJwtToken(username);

        // Tokeni istemciye dön
        return Ok(new { token });
    }

    private string GenerateJwtToken(string username)
    {
        var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["Jwt:SecretKey"]));
        var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);

        var claims = new[]
        {
            new Claim(JwtRegisteredClaimNames.Sub, username),
            new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
        };

        var token = new JwtSecurityToken(
            issuer: _configuration["Jwt:Issuer"],
            audience: _configuration["Jwt:Audience"],
            claims: claims,
            expires: DateTime.Now.AddMinutes(Convert.ToDouble(_configuration["Jwt:ExpiryInMinutes"])),
            signingCredentials: credentials);

        return new JwtSecurityTokenHandler().WriteToken(token);
    }
}

Konfigürasyon Eklemek: Uygulamanızın yapılandırma dosyasına (örneğin, appsettings.json) JWT ayarlarını ekleyin:

{
  "Jwt": {
    "Issuer": "your-issuer",
    "Audience": "your-audience",
    "SecretKey": "your-secret-key",
    "ExpiryInMinutes": 60
  }
}

Dependency Injection Ayarlarını Yapmak: Startup.cs dosyasında, AuthenticationController‘a bağlı olan IConfiguration servisini yapılandırın:

public void ConfigureServices(IServiceCollection services)
{
    // Diğer servis yapılandırmaları...

    services.AddSingleton(Configuration);

    // Diğer servis yapılandırmaları...
}

Bu adımları takip ederek, ASP.NET Core uygulamanıza bir kimlik doğrulama kontrolcüsü ekleyebilir ve kullanıcıların kimlik bilgilerini doğrulamak ve JWT tokenleri almak için kullanabilirsiniz. Bu kontrolcü, kullanıcı giriş isteklerini alır, kullanıcı bilgilerini doğrular ve başarılı olursa bir JWT tokeni oluşturur ve kullanıcıya geri gönderir.

Registering new users using UserManager

ASP.NET Core’da Token tabanlı kimlik doğrulama kullanırken, yeni kullanıcıların kaydedilmesi ve yönetilmesi için UserManager sınıfını kullanabilirsiniz. UserManager sınıfı, ASP.NET Core Identity Framework’ünün bir parçasıdır ve kullanıcı oluşturma, silme, parola değiştirme vb. gibi işlemleri kolaylaştırır.

• UserManager’ı Dependency Injection ile Ekleme: İlk olarak, UserManager sınıfını kullanabilmek için Startup.cs dosyasında ConfigureServices metoduna UserManager‘ı ekleyin:

public void ConfigureServices(IServiceCollection services)
{
    // Diğer servis yapılandırmaları...

    services.AddIdentity<ApplicationUser, IdentityRole>()
            .AddEntityFrameworkStores<ApplicationDbContext>()
            .AddDefaultTokenProviders();

    services.AddScoped<IUserClaimsPrincipalFactory<ApplicationUser>, UserClaimsPrincipalFactory<ApplicationUser, IdentityRole>>();

    // Diğer servis yapılandırmaları...
}

Kullanıcı Oluşturma İşlemi: Şimdi, yeni bir kullanıcı oluşturmak için UserManager‘ı kullanabiliriz. Öncelikle, ApplicationUser sınıfınızı tanımlamanız gerekecek. Bu sınıf, kullanıcı verilerini temsil eder. Daha sonra, UserManager sınıfını kullanarak yeni bir kullanıcı oluşturabiliriz. Aşağıda bir örnek kod bulunmaktadır:

using Microsoft.AspNetCore.Identity;

public class UserController : ControllerBase
{
    private readonly UserManager<ApplicationUser> _userManager;

    public UserController(UserManager<ApplicationUser> userManager)
    {
        _userManager = userManager;
    }

    [HttpPost]
    [Route("register")]
    public async Task<IActionResult> Register(string username, string password)
    {
        var user = new ApplicationUser { UserName = username };

        var result = await _userManager.CreateAsync(user, password);

        if (result.Succeeded)
        {
            // Kullanıcı başarıyla oluşturuldu
            return Ok("User created successfully.");
        }
        else
        {
            // Kullanıcı oluşturulurken bir hata oluştu, hataları döndür
            return BadRequest(result.Errors);
        }
    }
}

Bu örnekte, Register metodu, yeni bir kullanıcı oluşturmak için kullanılır. Kullanıcı adı ve şifre alınır, ardından UserManager kullanılarak yeni bir ApplicationUser nesnesi oluşturulur ve CreateAsync metoduyla veritabanına eklenir. CreateAsync metodu bir IdentityResult döndürür, bu nedenle işlem başarılıysa Ok durum koduyla birlikte bir mesaj döndürülür. Aksi takdirde, hatalar BadRequest ile döndürülür.

Bu adımları takip ederek, ASP.NET Core uygulamanızda yeni kullanıcıları UserManager kullanarak kolayca kaydedebilirsiniz. Bu sayede, kullanıcı kayıt işlemlerini basitleştirebilir ve kullanıcıların uygulamanıza kaydolmasını sağlayabilirsiniz.

Logging in users

Token tabanlı kimlik doğrulama ile kullanıcıların giriş yapması, kullanıcı adı ve şifrelerini doğrulamak ve bir JWT (JSON Web Token) oluşturmakla ilgilidir. Bu işlem, giriş isteği gönderen kullanıcının kimliğini doğrulamak için kullanılır.

• Giriş İsteğini İşleme: Kullanıcı giriş isteği geldiğinde, bu isteği işleyen bir kontrolcü oluşturun. Bu kontrolcü, kullanıcı adı ve şifre gibi kimlik bilgilerini alacak ve kimlik doğrulama işlemini gerçekleştirecektir.

[Route("api/[controller]")]
[ApiController]
public class AuthenticationController : ControllerBase
{
    private readonly UserManager<ApplicationUser> _userManager;
    private readonly SignInManager<ApplicationUser> _signInManager;

    public AuthenticationController(UserManager<ApplicationUser> userManager, SignInManager<ApplicationUser> signInManager)
    {
        _userManager = userManager;
        _signInManager = signInManager;
    }

    [HttpPost]
    [Route("login")]
    public async Task<IActionResult> Login(LoginViewModel model)
    {
        var user = await _userManager.FindByNameAsync(model.UserName);

        if (user != null && await _userManager.CheckPasswordAsync(user, model.Password))
        {
            var claims = new List<Claim>
            {
                new Claim(JwtRegisteredClaimNames.Sub, user.UserName),
                new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
            };

            var signinKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["Jwt:SecretKey"]));

            var token = new JwtSecurityToken(
                issuer: _configuration["Jwt:Issuer"],
                audience: _configuration["Jwt:Audience"],
                expires: DateTime.UtcNow.AddHours(1),
                claims: claims,
                signingCredentials: new SigningCredentials(signinKey, SecurityAlgorithms.HmacSha256)
            );

            return Ok(new
            {
                token = new JwtSecurityTokenHandler().WriteToken(token),
                expiration = token.ValidTo
            });
        }

        return Unauthorized();
    }
}

Kullanıcıyı Giriş Yapmış Olarak İşaretleme: Başarılı bir kimlik doğrulama işleminden sonra, kullanıcıyı giriş yapmış olarak işaretlemek için SignInManager‘ı kullanın.

var result = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, false, lockoutOnFailure: false);

if (result.Succeeded)
{
    return Ok("User logged in successfully.");
}
else
{
    return Unauthorized();
}

Bu adımları takip ederek, ASP.NET Core uygulamanızda kullanıcıların giriş yapması ve JWT token alması sağlanır. Bu token daha sonra kullanıcının herhangi bir işlem yaparken kimliğini doğrulamak için kullanılabilir.

Generating an access token

Token tabanlı kimlik doğrulama kullanırken, erişim belirteci (access token) oluşturmak, kimlik doğrulama sonrasında kullanıcının işlem yapabilmesi için kullanılabilir. Bu access token, genellikle JWT (JSON Web Token) formatında oluşturulur ve kullanıcı kimliği ve diğer ilgili bilgileri içerir.

• Access Token Oluşturma İşlemi: Access token oluşturma işlemi, bir JWT oluşturarak gerçekleştirilir. JWT, başlık (header), yük (payload) ve imza (signature) olmak üzere üç kısımdan oluşur.

using Microsoft.IdentityModel.Tokens;
using System.IdentityModel.Tokens.Jwt;

public class TokenService
{
    public string GenerateAccessToken(string userId, string secretKey, string issuer, string audience, int expiryMinutes)
    {
        var claims = new[]
        {
            new Claim(JwtRegisteredClaimNames.Sub, userId),
            new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
        };

        var signinKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(secretKey));
        var token = new JwtSecurityToken(
            issuer: issuer,
            audience: audience,
            claims: claims,
            expires: DateTime.UtcNow.AddMinutes(expiryMinutes),
            signingCredentials: new SigningCredentials(signinKey, SecurityAlgorithms.HmacSha256)
        );

        return new JwtSecurityTokenHandler().WriteToken(token);
    }
}

• Yukarıdaki kod örneğinde, GenerateAccessToken metodu kullanıcı kimliği (userId), gizli anahtar (secretKey), sunucu (issuer), hedef alıcı (audience) ve token geçerlilik süresi gibi parametreler alır. Bu bilgiler kullanılarak JWT oluşturulur ve string olarak döndürülür.
• Access Token Kullanımı: Oluşturulan access token, kullanıcının işlem yaparken kimliğini doğrulamak için kullanılır. Örneğin, bir HTTP isteği başlığında bu token kullanılabilir.

public async Task<IActionResult> SomeAction()
{
    var userId = "123"; // Örnek olarak kullanıcı kimliği
    var accessToken = _tokenService.GenerateAccessToken(userId, "your_secret_key", "your_issuer", "your_audience", 60);

    // Access token'ı HTTP isteği başlığına ekleme
    httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);

    // Diğer işlemler...
}

• Bu örnekte, GenerateAccessToken metodu kullanılarak bir access token oluşturulur ve ardından HTTP isteği başlığına eklenir. Bu şekilde, sunucu, kullanıcının kimliğini doğrulamak için bu token’ı kullanabilir.

Access token oluşturma işlemi, kullanıcı kimliğini güvenli bir şekilde temsil eden ve kimlik doğrulama sonrasında kullanıcının yetkilendirilmesine izin veren önemli bir adımdır. Yukarıdaki adımları takip ederek, ASP.NET Core uygulamanızda access token’ları başarıyla oluşturabilirsiniz.

Adding the RefreshToken table

Token tabanlı kimlik doğrulama kullanırken, bir kullanıcının oturumu süresi dolduğunda veya güvenlik nedenleriyle oturumun yeniden doğrulanması gerektiğinde, kullanıcının mevcut access token’ını yenilemek için refresh token’lar kullanılır. Refresh token’lar, genellikle bir veritabanında saklanır ve access token’larının yenilenmesi için kullanılır.

• Refresh Token Tablosu Oluşturma: Öncelikle, veritabanında refresh token’ları saklamak için bir tablo oluşturmanız gerekir. Bu tablo, genellikle kullanıcı kimliği, refresh token ve token’in son kullanma tarihini içerir.

public class RefreshToken
{
    [Key]
    public string UserId { get; set; }
    public string Token { get; set; }
    public DateTime Expires { get; set; }
}

• Yukarıdaki kod örneğinde, RefreshToken sınıfı refresh token’ları temsil eder. UserId, kullanıcının kimliğini, Token, refresh token’ı ve Expires, token’ın son kullanma tarihini içerir.
• Veritabanı Bağlamını Güncelleme: Veritabanında refresh token’ları saklamak için bir DbSet oluşturun ve veritabanı bağlamınızı güncelleyin.

public class ApplicationDbContext : DbContext
{
    public DbSet<RefreshToken> RefreshTokens { get; set; }

    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options)
    {
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<RefreshToken>()
            .HasKey(rt => rt.UserId);
    }
}

• Yukarıdaki kod örneğinde, ApplicationDbContext sınıfında RefreshTokens adında bir DbSet tanımlanmıştır. Ayrıca, refresh token’ları saklamak için RefreshToken sınıfına ait bir anahtar belirlenmiştir.
• Veritabanı Migration’ları: Refresh token tablosunu veritabanına eklemek için migration’lar oluşturun ve uygulayın.

dotnet ef migrations add AddRefreshTokenTable
dotnet ef database update

• Bu adımların ardından, refresh token’ları saklamak için bir tablo oluşturulmuş ve veritabanına eklenmiş olacaktır.

Refresh token tablosu, token tabanlı kimlik doğrulama işlemi sırasında kullanıcı oturumlarının güvenliğini artırmak için önemlidir. Yukarıdaki adımları takip ederek, ASP.NET Core uygulamanızda refresh token’ları başarıyla saklayabilirsiniz.

Generating and storing refresh tokens

Refresh token’ların oluşturulması ve saklanması, token tabanlı kimlik doğrulama sürecinde kullanıcı oturumlarını yönetmek için önemlidir.

• Refresh Token Oluşturma: Bir refresh token, genellikle rastgele bir dize veya GUID’den oluşur. Bu token’ın oluşturulması için bir yöntem kullanılabilir.

public class TokenService
{
    public string GenerateRefreshToken()
    {
        var randomNumber = new byte[32];
        using (var rng = RandomNumberGenerator.Create())
        {
            rng.GetBytes(randomNumber);
            return Convert.ToBase64String(randomNumber);
        }
    }
}

• Yukarıdaki kod örneğinde, GenerateRefreshToken metodu rastgele bir byte dizisi oluşturur ve bunu base64 formatında bir dizeye dönüştürerek refresh token olarak döndürür.
• Refresh Token’ın Saklanması: Oluşturulan refresh token, bir veritabanında saklanmalıdır. Veritabanında refresh token’ları saklamak için bir tablo oluşturulur ve bu tabloya token ve ilgili kullanıcıya ait bilgiler kaydedilir.

public class RefreshTokenRepository
{
    private readonly ApplicationDbContext _context;

    public RefreshTokenRepository(ApplicationDbContext context)
    {
        _context = context;
    }

    public void AddRefreshToken(string userId, string refreshToken, DateTime expires)
    {
        var token = new RefreshToken
        {
            UserId = userId,
            Token = refreshToken,
            Expires = expires
        };

        _context.RefreshTokens.Add(token);
        _context.SaveChanges();
    }
}

• Yukarıdaki kod örneğinde, AddRefreshToken metoduyla veritabanına yeni bir refresh token eklenir. Bu token, ilgili kullanıcıya ait kimlik bilgileriyle birlikte saklanır.
• Refresh Token’ın Kullanımı: Refresh token, access token’ın geçerliliği sona erdiğinde veya yenilenmesi gerektiğinde kullanılır. Kullanıcının access token’ını yenilemek için refresh token kullanılabilir.

public class TokenService
{
    public string GenerateAccessToken(string userId, string secretKey, string issuer, string audience, int expiryMinutes)
    {
        // Access token oluşturma işlemi...
    }

    public void UseRefreshToken(string userId, string refreshToken)
    {
        // Veritabanından refresh token'ı kontrol etme ve kullanma işlemi...
    }
}

• Refresh token, ilgili kullanıcıya ait kimlik bilgileriyle birlikte saklanır ve access token yenileme işlemi için kullanılır.

Yukarıdaki adımları takip ederek, ASP.NET Core uygulamanızda refresh token’ların oluşturulması ve saklanması sağlanabilir, böylece kullanıcı oturumları güvenli bir şekilde yönetilebilir.

Injecting TokenValidationParameters

TokenValidationParameters, ASP.NET Core uygulamalarında token tabanlı kimlik doğrulama sürecini yapılandırmak için kullanılan bir sınıftır. Bu sınıf, gelen token’ların doğruluğunu ve güvenilirliğini kontrol etmek için kullanılır. TokenValidationParameters’ın enjekte edilmesi, uygulamanın başlatılması sırasında yapılandırılmasını ve belirli token doğrulama parametrelerinin belirlenmesini sağlar.

• Startup.cs Dosyasında Servisleri Yapılandırma: İlk olarak, ConfigureServices metodunda JWT (JSON Web Token) tabanlı kimlik doğrulama için gerekli servisleri eklemek ve TokenValidationParameters’ı yapılandırmak gerekir.

public void ConfigureServices(IServiceCollection services)
{
    // Diğer servislerin ekleme işlemleri...

    services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
        .AddJwtBearer(options =>
        {
            options.TokenValidationParameters = new TokenValidationParameters
            {
                ValidateIssuer = true,
                ValidateAudience = true,
                ValidateLifetime = true,
                ValidateIssuerSigningKey = true,
                ValidIssuer = "your_issuer",
                ValidAudience = "your_audience",
                IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("your_secret_key"))
            };
        });

    // Diğer servislerin ekleme işlemleri devam eder...
}

• Yukarıdaki kod örneğinde, ConfigureServices metodu içinde AddAuthentication ve AddJwtBearer metotları çağrılarak JWT tabanlı kimlik doğrulama yapılandırması eklenmiştir. TokenValidationParameters, AddJwtBearer metodu aracılığıyla yapılandırılır ve token doğrulama parametreleri belirlenir.
• TokenValidationParameters’ı Enjekte Etme: Bir bileşen içinde TokenValidationParameters’ı kullanmak için, ilgili bileşenin yapıcı metoduna TokenValidationParameters parametresini eklemek gerekir.

public class YourService
{
    private readonly TokenValidationParameters _tokenValidationParameters;

    public YourService(TokenValidationParameters tokenValidationParameters)
    {
        _tokenValidationParameters = tokenValidationParameters;
    }

    public void YourMethod()
    {
        // TokenValidationParameters'ı kullanarak işlemleri gerçekleştirme...
    }
}

• Yukarıdaki örnekte, YourService adlı bir hizmet sınıfı içinde TokenValidationParameters’ın enjekte edildiği görülmektedir. Bu sayede, hizmet sınıfı içinde token doğrulama parametrelerini kullanabiliriz.

TokenValidationParameters’ın enjekte edilmesi, ASP.NET Core uygulamalarında JWT tabanlı kimlik doğrulama sürecini yapılandırmak ve belirli token doğrulama parametrelerini belirlemek için önemlidir. Bu parametreler, gelen token’ların doğruluğunu ve güvenilirliğini kontrol etmek için kullanılır.

Refreshing expired tokens

Token tabanlı kimlik doğrulama sürecinde, token’ların belirli bir süre sonra geçersizleşmesi yaygın bir durumdur. Bu nedenle, token’ların yenilenmesi (refresh) işlemi önemlidir. Bu işlem, kullanıcının süresi dolmuş olan token’ını, geçerli bir refresh token kullanarak yeni bir access token ile değiştirir.

• Refresh Token Oluşturma ve Saklama: İlk olarak, kullanıcıların authentication işlemi sırasında bir refresh token alması ve bu token’ın saklanması gerekir. Bu refresh token daha sonra süresi dolmuş access token’ı yenilemek için kullanılır.

public class TokenService
{
    public string GenerateRefreshToken()
    {
        var randomNumber = new byte[32];
        using (var rng = RandomNumberGenerator.Create())
        {
            rng.GetBytes(randomNumber);
            return Convert.ToBase64String(randomNumber);
        }
    }
}

• Yukarıdaki kod örneğinde, GenerateRefreshToken metodu rastgele bir byte dizisi oluşturur ve bunu base64 formatında bir dizeye dönüştürerek refresh token olarak döndürür.
• Token Yenileme (Refreshing): Token yenileme işlemi, access token’ın geçerliliğinin sona ermesi durumunda gerçekleştirilir. Kullanıcı, geçerli bir refresh token ile token yenileme talebinde bulunur.

public class TokenService
{
    public string GenerateAccessToken(string userId, string secretKey, string issuer, string audience, int expiryMinutes)
    {
        // Access token oluşturma işlemi...
    }

    public void RefreshToken(string refreshToken)
    {
        // Refresh token'ı kullanarak access token yenileme işlemi...
    }
}

• Yukarıdaki kod örneğinde, RefreshToken metodu ile refresh token kullanılarak access token yenileme işlemi gerçekleştirilir.
• Token Refresh Endpoint Oluşturma: Token yenileme işlemini gerçekleştirecek bir API endpoint’i oluşturulmalıdır. Bu endpoint, kullanıcının refresh token ile access token yenileme işlemini gerçekleştirmesini sağlar.

[HttpPost("refresh")]
public IActionResult RefreshToken([FromBody] RefreshTokenRequestModel model)
{
    // Refresh token ile access token yenileme işlemi...
}

• Yukarıdaki kod örneğinde, refresh token ile access token yenileme işlemini gerçekleştirecek bir POST endpoint’i tanımlanmıştır.

Token’ların yenilenmesi, uygulamanın güvenliğini ve kullanıcı deneyimini artıran önemli bir adımdır. Yukarıdaki adımları takip ederek, ASP.NET Core uygulamanızda süresi dolmuş token’ları yenileyebilirsiniz.

Role-Based Authentication

Seeding the database with roles

Veritabanını rollerle doldurmak, ASP.NET Core uygulamalarında rol tabanlı yetkilendirme (authorization) için önemli bir adımdır. Bu işlem, uygulama başlatıldığında belirli rollerin veritabanına eklenmesini ve kullanıcıların bu rollerle ilişkilendirilmesini sağlar.

• Rolleri Tanımlama: İlk olarak, uygulamanızda kullanılacak rolleri tanımlamanız gerekir. Bu roller genellikle “Admin”, “User”, “Manager” gibi isimlerle ifade edilir.

public enum Roles
{
    Admin,
    User,
    Manager
}

Rol Modeli Oluşturma: Rol bilgilerini temsil etmek için bir model oluşturmanız gerekebilir. Bu model, veritabanına rolleri eklemek için kullanılacaktır.

public class Role
{
    public int Id { get; set; }
    public string Name { get; set; }
}

Veritabanına Rollerin Eklenmesi: Veritabanına rollerin eklenmesi işlemi, uygulamanın başlangıcında gerçekleştirilir. Bu işlem, veritabanına tanımlanan rollerin eklenmesini sağlar.

public static void SeedRoles(IServiceProvider serviceProvider)
{
    using (var serviceScope = serviceProvider.GetRequiredService<IServiceScopeFactory>().CreateScope())
    {
        var context = serviceScope.ServiceProvider.GetRequiredService<YourDbContext>();

        if (!context.Roles.Any())
        {
            var roles = Enum.GetNames(typeof(Roles)).ToList();

            foreach (var roleName in roles)
            {
                context.Roles.Add(new Role { Name = roleName });
            }

            context.SaveChanges();
        }
    }
}

• Yukarıdaki kod örneğinde, SeedRoles metodu kullanılarak veritabanına roller eklenmektedir. Metod, veritabanında herhangi bir rol olup olmadığını kontrol eder. Eğer roller henüz eklenmemişse, enum’dan alınan roller veritabanına eklenir.
• Startup.cs Dosyasında SeedRoles Metodunun Kullanılması: SeedRoles metodunun uygulama başlatıldığında çağrılması sağlanmalıdır. Bu işlem, uygulama başladığında rollerin otomatik olarak veritabanına eklenmesini sağlar.

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    // Diğer middleware'lerin eklenmesi...

    using (var serviceScope = app.ApplicationServices.GetRequiredService<IServiceScopeFactory>().CreateScope())
    {
        SeedRoles(serviceScope.ServiceProvider);
    }

    // Diğer middleware'lerin eklenmesi devam eder...
}

• Yukarıdaki kod örneğinde, Configure metodu içinde SeedRoles metodunun çağrılması sağlanmıştır. Bu sayede, uygulama başlatıldığında roller otomatik olarak veritabanına eklenir.

Bu adımları takip ederek, ASP.NET Core uygulamanızda rolleri veritabanına ekleyebilir ve rol tabanlı yetkilendirme sistemini kullanabilirsiniz. Bu sayede, kullanıcıların belirli rollerle ilişkilendirilmesi ve bu rollerin kullanıcıların erişim haklarını belirlemesi sağlanır.

Adding role claims to tokens

Rol tabanlı doğrulama (role-based authentication) uygulamalarında, kullanıcının rolleri token içinde taşınarak yetkilendirme (authorization) sürecini kolaylaştırabilir. Bu rol bilgileri, token içinde rol id’leri veya rollerin adları şeklinde olabilir. Bu adımlarla rol bilgilerini token’lara eklemek mümkündür:

• JWT (JSON Web Token) İmzalama İşlemi: İlk adım, JWT oluşturma ve imzalama işlemidir. JWT, kullanıcı bilgilerini ve rollerini içerecek şekilde oluşturulur ve bir anahtar (key) kullanılarak imzalanır.

public string GenerateToken(string userId, IEnumerable<string> roles, string secretKey, string issuer, string audience, int expiryMinutes)
{
    var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(secretKey));
    var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);

    var claims = new List<Claim>
    {
        new Claim(ClaimTypes.NameIdentifier, userId)
    };

    foreach (var role in roles)
    {
        claims.Add(new Claim(ClaimTypes.Role, role));
    }

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

    return new JwtSecurityTokenHandler().WriteToken(token);
}

• Yukarıdaki kod örneğinde, GenerateToken metodu ile token oluşturma işlemi gerçekleştirilir. Bu metod, userId ve rolleri içeren JWT oluşturur.
• Token Oluşturulurken Rollerin Eklenmesi: Token oluşturulurken, kullanıcı rolleri JWT içinde rol id’leri veya rollerin adları olarak eklenir.

var roles = new List<string> { "Admin", "User" };
var token = GenerateToken(userId, roles, secretKey, issuer, audience, expiryMinutes);

• Yukarıdaki kod örneğinde, GenerateToken metodu kullanılarak token oluşturulurken, roller de token’a eklenir.
• Token Doğrulama ve Rol Kontrolü: İstemci tarafında veya API tarafında token doğrulama işlemi gerçekleştirilir ve token içindeki roller kontrol edilir. Bu şekilde, kullanıcı rollerine göre yetkilendirme işlemi yapılabilir.

[Authorize(Roles = "Admin")]
public IActionResult AdminAction()
{
    // Sadece admin rolüne sahip kullanıcılar bu eylemi gerçekleştirebilir.
}

• Yukarıdaki kod örneğinde, [Authorize] attribute kullanılarak sadece “Admin” rolüne sahip kullanıcıların AdminAction metodunu çağırabileceği belirtilmiştir.

Bu adımları takip ederek, ASP.NET Core uygulamanızda rol bilgilerini token’lara ekleyebilir ve rol tabanlı yetkilendirme sistemini kullanabilirsiniz. Bu sayede, kullanıcıların rollerine göre erişim haklarını kontrol edebilir ve uygulamanızı güvenli hale getirebilirsiniz.

Adding role authentication to a controller

ASP.NET Core’da rol tabanlı yetkilendirme (role-based authentication) yapmak için, bir controller’a veya belirli bir işleve yalnızca belirli rollerdeki kullanıcıların erişimine izin vermek gerekebilir. Bu durumda, [Authorize] özniteliği rol tabanlı yetkilendirme için kullanılır.

• Authorize Attribute Kullanımı: [Authorize] özniteliği, belirli bir rol gerektiren controller’a veya action’a uygulanabilir. Bu, sadece belirli rollerdeki kullanıcıların erişebileceği anlamına gelir.

[Authorize(Roles = "Admin")]
public class AdminController : Controller
{
    // Admin rolüne sahip kullanıcılar bu controller'a erişebilir.
}

• Yukarıdaki örnekte, AdminController sınıfına [Authorize(Roles = “Admin”)] özniteliği uygulanmıştır. Bu, yalnızca “Admin” rolüne sahip kullanıcıların bu controller’a erişebileceği anlamına gelir.
• Birden Fazla Rol için Yetkilendirme: Birden fazla role erişime izin vermek için, [Authorize] özniteliğine birden fazla rol ekleyebilirsiniz.

[Authorize(Roles = "Admin,Manager")]
public class AdminController : Controller
{
    // Admin veya Manager rolüne sahip kullanıcılar bu controller'a erişebilir.
}

Rolleri Kod İçinde Kontrol Etme: Bazı durumlarda, [Authorize] özniteliği kullanmadan rol bazlı doğrulamayı kod içinde kontrol etmek isteyebilirsiniz. Bu durumda, rolleri doğrudan kod içinde kontrol edebilirsiniz.

public IActionResult AdminAction()
{
    if (User.IsInRole("Admin"))
    {
        // Admin rolüne sahip kullanıcılar bu eylemi gerçekleştirebilir.
    }
    else
    {
        return Forbid(); // Yetkisiz erişim durumunda 403 Forbidden döner.
    }
}

• Yukarıdaki örnekte, AdminAction metodu içinde User.IsInRole metodu kullanılarak rol kontrolü yapılır. Bu, kullanıcının “Admin” rolüne sahip olup olmadığını kontrol eder.

Bu adımları izleyerek, ASP.NET Core uygulamanızda rol tabanlı yetkilendirme ekleyebilirsiniz. Bu sayede, belirli rollerdeki kullanıcıların belirli controller ve action’lara erişimini kontrol edebilirsiniz.

Adding multiple roles to a controller

ASP.NET Core’da bir controller’a birden fazla rol eklemek, o controller’a erişim için birden fazla rolü gerektirebilir. Bu, belirli bir controller veya action’a erişmek için kullanıcının birden fazla role sahip olması gerektiği anlamına gelir.

• Authorize Attribute Kullanımı: [Authorize] özniteliği kullanarak bir controller’a birden fazla rol ekleyebilirsiniz.

[Authorize(Roles = "Admin,Manager")]
public class AdminController : Controller
{
    // Admin veya Manager rolüne sahip kullanıcılar bu controller'a erişebilir.
}

• Yukarıdaki örnekte, AdminController sınıfına [Authorize(Roles = “Admin,Manager”)] özniteliği uygulanmıştır. Bu, yalnızca “Admin” veya “Manager” rollerine sahip kullanıcıların bu controller’a erişebileceği anlamına gelir.
• Birden Fazla Rol ile Yetkilendirme Kontrolü: Eğer belirli bir controller veya action’a erişim, birden fazla rol gerektiriyorsa, kod içinde bu rolleri kontrol edebilirsiniz.

public IActionResult AdminAction()
{
    if (User.IsInRole("Admin") || User.IsInRole("Manager"))
    {
        // Admin veya Manager rollerinden birine sahip kullanıcılar bu eylemi gerçekleştirebilir.
    }
    else
    {
        return Forbid(); // Yetkisiz erişim durumunda 403 Forbidden döner.
    }
}

• Yukarıdaki örnekte, AdminAction metodu içinde User.IsInRole metodu kullanılarak hem “Admin” hem de “Manager” rolleri için yetkilendirme kontrolü yapılmıştır.

Birden fazla rol eklemek, bir controller veya action’a erişim gereksinimlerini daha spesifik hale getirebilir ve uygulamanızın güvenliğini artırabilir. Bu yöntemle, farklı rollerdeki kullanıcıların belirli controller ve action’lara erişimini kontrol edebilirsiniz.

Bir sonraki yazıda görüşmek dileğiyle!”