---
title: Authentication, Authorization ve JWT Nedir? Aralarındaki Farklar Nelerdir?
description: Authentication, Authorization ve JWT, modern web uygulamalarının en temel güvenlik kavramlarıdır ancak çoğu zaman birbirleriyle karıştırılır. Bu yazıda Authentication'ın kimlik doğrulama, Authorization'ın yetkilendirme sürecindeki rolünü ve JWT'nin bu süreçte nasıl kullanıldığını gerçek hayat örnekleri ve ASP.NET Core kodlarıyla adım adım inceliyoruz.
author: Burak Kaşıkcı
date: 2026-08-06
updated: 2026-08-06
tags:
  - asp.net core
  - jwt
  - authentication
  - authorization
  - api security
  - web api
  - .net
  - backend
  - yazılım geliştirme
  - güvenlik
  - identity
  - bearer token
  - claims
canonical: https://burakkasikci.com/blog/authentication-authorization-ve-jwt-nedir-aralarindaki-farklar-nelerdir
slug: authentication-authorization-ve-jwt-nedir-aralarindaki-farklar-nelerdir
---

# Authentication, Authorization ve JWT: Sürekli Karıştırılan Üç Kavram

Bir API geliştirirken ya da ASP.NET Core ile çalışırken en sık duyduğumuz kavramlardan üçü Authentication, Authorization ve JWT'dir. Özellikle yazılıma yeni başlayanlar için bu kavramlar çoğu zaman aynı şeyi ifade ediyormuş gibi görünür. Hatta yıllardır yazılım geliştirenlerin bile bu terimleri birbirinin yerine kullandığını görebilirsiniz.

Oysa bu üç kavram farklı problemleri çözer. Aralarındaki ilişkiyi doğru anladığınızda hem güvenlik mimarilerini daha rahat tasarlarsınız hem de framework'lerin neden belirli şekilde çalıştığını anlamak kolaylaşır.

Bu yazıda bu üç kavramı günlük hayattan örneklerle birlikte inceleyeceğiz.

***

# Authentication: "Sen Kimsin?"

Authentication, Türkçesiyle **kimlik doğrulama**, bir kullanıcının gerçekten iddia ettiği kişi olup olmadığını kontrol etme işlemidir.

En basit örnekle düşünelim.

Bir uygulamaya giriş yapıyorsunuz.

```
Kullanıcı Adı
Şifre
```

Sunucu bu bilgileri veritabanındaki kayıtlarla karşılaştırır.

Bilgiler doğruysa artık sistem şunu bilir:

> Bu kişi gerçekten Burak.

Henüz bu kullanıcının neler yapabileceğiyle ilgilenmez. Sadece kim olduğunu doğrulamıştır.

Bu yüzden Authentication sorusu aslında tek cümledir.

> **Sen kimsin?**

ASP.NET Core tarafında bunun sonucu genellikle şöyle görünür.

```csharp
User.Identity.IsAuthenticated
```

Bu değer `true` ise kullanıcı sisteme giriş yapmıştır.

***

# Authorization: "Bunu Yapabilir misin?"

Kimlik doğrulandıktan sonra ikinci aşama başlar.

Diyelim ki sisteme başarıyla giriş yaptınız.

Peki artık her işlemi yapabilir misiniz?

Tabii ki hayır.

Bir e-ticaret sisteminde müşteri olarak giriş yapmanız, ürün silebileceğiniz anlamına gelmez.

Bir banka çalışanı olmanız da tüm müşteri hesaplarını değiştirebileceğiniz anlamına gelmez.

İşte burada Authorization devreye girer.

Authorization'ın temel sorusu şudur.

> **Bu işlemi yapmaya yetkin var mı?**

Örneğin aşağıdaki API sadece yöneticilere açık olsun.

```http
DELETE /api/users/15
```

Sistem önce kullanıcının kim olduğunu bilir.

Ardından rolünü kontrol eder.

```
Role = Admin
```

Eğer gerekli yetkiye sahipse işlem yapılır.

Değilse sunucu büyük ihtimalle aşağıdaki HTTP durum kodunu döndürür.

```
403 Forbidden
```

Yani kullanıcı sisteme giriş yapmıştır fakat istenen işlemi gerçekleştirme yetkisine sahip değildir.

***

# Authentication ve Authorization Arasındaki Fark

Bu iki kavramı ayırmanın en kolay yolu günlük hayattan bir örnek vermek.

Bir şirkete gittiğinizi düşünün.

Girişte güvenlik görevlisi kimliğinizi kontrol ediyor.

Kimliğiniz doğruysa binaya giriş yapabiliyorsunuz.

Bu Authentication'dır.

Sonra sunucu odasına gitmek istiyorsunuz.

Kapı açılmıyor.

Çünkü o odaya sadece sistem yöneticileri girebiliyor.

Bu ise Authorization'dır.

Yani ilk kapı sizi tanıyor.

İkinci kapı ise yetkinizi kontrol ediyor.

***

# ASP.NET Core'da Authorize Attribute'u

ASP.NET Core'da yetkilendirme işlemleri çoğunlukla `Authorize` attribute'u ile yapılır.

```csharp
[Authorize]
public class UserController : ControllerBase
{
}
```

Bu kullanımın anlamı oldukça nettir.

Bu controller'a yalnızca giriş yapmış kullanıcılar erişebilir.

Daha özel kurallar da yazabiliriz.

Sadece yöneticiler erişsin.

```csharp
[Authorize(Roles = "Admin")]
```

Birden fazla rol tanımlamak da mümkündür.

```csharp
[Authorize(Roles = "Admin,Manager")]
```

Rol yerine Policy tabanlı bir yapı da kurulabilir.

```csharp
[Authorize(Policy = "CanDeleteUser")]
```

Bu yaklaşım özellikle büyük projelerde daha esnek bir yetkilendirme modeli sunar.

***

# JWT Nedir?

JWT'nin açılımı **JSON Web Token**'dır.

JWT çoğu zaman yanlış anlaşılır.

JWT bir giriş yöntemi değildir.

JWT bir yetkilendirme sistemi de değildir.

JWT aslında yalnızca **bilgiyi güvenli şekilde taşımaya yarayan bir formattır.**

Örneğin sunucu aşağıdaki bilgileri kullanıcı adına saklamak isteyebilir.

```json
{
  "id": 15,
  "name": "Burak",
  "role": "Admin"
}
```

Bu bilgiler doğrudan gönderilmez.

Bunun yerine imzalanmış bir token oluşturulur.

```
eyJhbGciOi...
```

İstemci bu token'ı saklar ve sonraki isteklerde sunucuya gönderir.

***

# JWT'nin Yapısı

Bir JWT üç bölümden oluşur.

```
HEADER.PAYLOAD.SIGNATURE
```

## Header

Header kısmında kullanılan algoritma bilgisi bulunur.

Örneğin:

```json
{
  "alg": "HS256",
  "typ": "JWT"
}
```

***

## Payload

Payload kullanıcıya ait bilgilerin bulunduğu bölümdür.

```json
{
  "sub": "15",
  "name": "Burak",
  "role": "Admin",
  "exp": 1770000000
}
```

Buradaki bilgiler **Claim** olarak adlandırılır.

Claim'ler;

* Kullanıcı Id'si
* Rol
* E-posta
* Departman
* Yetkiler
* Token'ın geçerlilik süresi

gibi bilgileri taşıyabilir.

***

## Signature

JWT'nin en önemli kısmı Signature bölümüdür.

Sunucu gizli anahtarıyla token'ı imzalar.

Bu sayede kullanıcı token'ın içeriğini değiştiremez.

Örneğin rol bilgisini "User" yerine "Admin" yapmaya çalışırsa imza geçersiz hale gelir.

Sunucu bunu anında fark eder.

***

# JWT ile Bir İstek Nasıl Çalışır?

Genellikle süreç şu şekilde ilerler.

1. Kullanıcı giriş yapar.
2. Sunucu kullanıcıyı doğrular.
3. JWT oluşturulur.
4. Token istemciye gönderilir.
5. İstemci token'ı saklar.
6. Sonraki her istekte token gönderilir.

HTTP isteği genellikle şöyle görünür.

```http
Authorization: Bearer eyJhbGciOi...
```

Sunucu gelen token'ı kontrol eder.

* İmza doğru mu?
* Süresi dolmuş mu?
* Token güvenilir mi?

Her şey doğruysa kullanıcı bilgileri okunur.

Sonrasında Authorization kuralları devreye girer.

***

# JWT ile Authorize Nasıl Birlikte Çalışır?

Çoğu geliştirici burada küçük bir yanılgıya düşüyor.

JWT kimseye yetki vermez.

JWT sadece bilgiyi taşır.

Asıl yetkilendirme işlemini uygulama yapar.

Örneğin token içerisinde şu bilgi bulunsun.

```json
{
    "role": "Admin"
}
```

Controller tarafında ise şöyle bir tanım olsun.

```csharp
[Authorize(Roles = "Admin")]
public IActionResult DeleteUser()
{
    ...
}
```

İstek geldiğinde ASP.NET Core şu adımları izler.

* Token'ı doğrular.
* İçindeki Claim'leri okur.
* Role bilgisini alır.
* Role değeri "Admin" ise metoda erişime izin verir.

Yani karar mekanizması `Authorize` attribute'udur.

JWT ise bu kararın verilmesini sağlayacak bilgileri taşır.

***

# Süreci Birlikte Düşünelim

Bütün akışı tek bir senaryoda özetleyelim.

Ali bir e-ticaret uygulamasına giriş yapıyor.

Kullanıcı adı ve şifresi doğru olduğu için Authentication başarılı oluyor.

Sunucu Ali adına bir JWT üretiyor.

Bu token'ın içerisinde kullanıcı kimliği ve rol bilgisi bulunuyor.

Ali daha sonra ürün silme API'sine istek gönderiyor.

ASP.NET Core önce JWT'yi doğruluyor.

Ardından token içindeki rol bilgisini okuyor.

Controller üzerinde yalnızca yöneticilere izin veren bir `Authorize` kuralı bulunduğu için Ali'nin rolü kontrol ediliyor.

Eğer rolü **Admin** ise işlem gerçekleşiyor.

Değilse istek reddediliyor.

Bu örnekte Authentication, Authorization ve JWT birlikte çalışıyor olsa da her biri farklı bir görevi yerine getiriyor.

***

# Sonuç

Authentication, Authorization ve JWT aynı güvenlik sürecinin parçalarıdır ancak aynı işi yapmazlar.

Authentication kullanıcının kim olduğunu doğrular.

Authorization kullanıcının hangi işlemleri yapabileceğine karar verir.

JWT ise bu kararların verilebilmesi için gerekli bilgileri güvenli şekilde taşıyan bir token formatıdır.

Bu ayrımı net olarak kavradığınızda yalnızca ASP.NET Core değil, Spring Boot, Node.js, Django veya Go gibi farklı platformlardaki güvenlik yapılarını anlamak da çok daha kolay hale gelir. Çünkü kullanılan teknoloji değişse bile temel mantık büyük ölçüde aynıdır.