NestJS Güvenliği: 10 Kritik Best Practice [2026 Rehberi]
Yazar: Burak Balkı | Kategori: Security | Okuma Süresi: 47 dk
NestJS Güvenliği üzerine 2026 yılına özel bu kapsamlı rehber, uygulamalarınızı siber tehditlere karşı korumak için temelden ileri seviyeye kadar tüm kritik t...
# NestJS Güvenliği: 10 Kritik Best Practice [2026 Rehberi]
Bir siber güvenlik raporuna göre, 2026 yılında web uygulamalarına yönelik saldırıların %60'ından fazlası kimlik doğrulama ve yetkilendirme zafiyetlerinden kaynaklanmaktadır. Bu kritik istatistik, modern web uygulamaları geliştirirken güvenliğin ne denli öncelikli olması gerektiğini açıkça ortaya koyuyor. Bu kapsamlı rehberde, NestJS tabanlı uygulamalarınızı 2026 standartlarında nasıl güvence altına alacağınızı, temel güvenlik prensiplerinden ileri seviye tekniklere kadar adım adım öğreneceksiniz. Amacımız, uygulamanızın yalnızca işlevsel değil, aynı zamanda siber tehditlere karşı da dirençli olmasını sağlamak.
## NestJS Güvenliği Nedir?
**NestJS Güvenliği, NestJS tabanlı bir uygulamanın, yetkisiz erişim, veri ihlali, hizmet reddi ve diğer kötü niyetli saldırılara karşı korunması için uygulanan tüm stratejileri, teknikleri ve mekanizmaları kapsar.** Bu, kimlik doğrulama, yetkilendirme, girdi doğrulama, veri şifreleme, güvenlik başlıkları ve bağımlılık yönetimi gibi alanları içerir. NestJS'in modüler yapısı ve güçlü ekosistemi, geliştiricilere bu güvenlik katmanlarını kolayca entegre etme imkanı sunar, böylece 2026'nın karmaşık tehdit ortamında bile sağlam uygulamalar inşa edilebilir.
NestJS, TypeScript üzerine kurulu bir framework olarak, güvenlik odaklı geliştirme için güçlü bir temel sunar. Zaten güçlü bir tip sistemi ve dekoratör tabanlı yapısıyla hataları erken aşamada yakalama potansiyeli taşır. Ancak, bu yapısal avantajlara ek olarak, geliştiricilerin güvenlik best practice'lerini aktif olarak uygulaması ve framework'ün sunduğu güvenlik modüllerini doğru şekilde kullanması hayati önem taşır. Production ortamında NestJS kullanırken karşılaştığım en yaygın sorunlardan biri, geliştiricilerin varsayılan güvenlik ayarlarını değiştirmeyi veya ek güvenlik katmanları eklemeyi ihmal etmesiydi. Bu rehber, bu tür ihmalleri ortadan kaldırmayı hedeflemektedir.
## Neden NestJS Güvenliği Kullanmalısınız?
NestJS, modern web uygulamalarının karmaşıklığına yanıt verirken, güvenlik konusunda da önemli avantajlar sunar. 2026 itibarıyla, API odaklı mimarilerin yaygınlaşmasıyla birlikte, her bir endpoint'in güvenliği kritik hale gelmiştir. İşte NestJS'in güvenlik açısından sunduğu başlıca değer önerileri:
* **Yapısal Güvenlik:** NestJS, mimarisi gereği modüler ve katmanlı bir yapıya sahiptir. Bu, güvenlik katmanlarının (kimlik doğrulama, yetkilendirme, doğrulama) uygulamanın diğer bölümlerinden bağımsız olarak geliştirilmesini ve yönetilmesini kolaylaştırır. Bu sayede, güvenlik odaklı modüller oluşturmak ve bunları uygulamanın farklı yerlerine entegre etmek daha düzenli hale gelir.
* **TypeScript Avantajı:** TypeScript'in sunduğu güçlü tip denetimi, birçok yaygın güvenlik açığının (örneğin, yanlış veri türü manipülasyonu) derleme zamanında tespit edilmesine yardımcı olur. Bu, runtime hatalarını ve olası güvenlik zafiyetlerini azaltır.
* **Geniş Ekosistem ve Entegrasyon:** NestJS, Node.js ekosisteminin zengin kütüphanelerinden faydalanır. Passport.js, Helmet, class-validator gibi yaygın olarak kullanılan ve güvenilirliği kanıtlanmış güvenlik kütüphaneleri NestJS ile sorunsuz bir şekilde entegre edilebilir. Bu entegrasyonlar, geliştiricilerin güvenlik özelliklerini hızlıca devreye almasını sağlar.
* **Kurumsal Destek ve Topluluk:** NestJS, kurumsal düzeyde projelerde yaygın olarak kullanılan ve aktif bir topluluğa sahip bir framework'tür. Bu, güvenlik güncellemelerinin ve yamalarının düzenli olarak yayınlandığı, sorunların hızla çözüldüğü anlamına gelir. 2026'da birçok büyük teknoloji şirketi, ölçeklenebilir ve güvenli backend'ler için NestJS'i tercih etmektedir.
* **Otomatik Güvenlik Mekanizmaları:** NestJS, bazı güvenlik özelliklerini (örneğin, CORS varsayılan ayarları) otomatik olarak sunar. Ayrıca, Guard'lar, Pipe'lar ve Interceptor'lar gibi araçlarla özel güvenlik mantığı oluşturmayı son derece kolaylaştırır. Ekibimizde NestJS'e geçiş sürecinde öğrendiğimiz 3 kritik dersten biri, bu yerleşik mekanizmaları doğru kullanmanın geliştirme hızını artırırken güvenlik seviyesini de yükseltmesiydi.
Kimler için uygundur? Büyük ölçekli kurumsal uygulamalar, mikro servis mimarileri, yüksek güvenlik gereksinimleri olan finansal veya sağlık uygulamaları için idealdir. Kimler için uygun değildir? Çok basit, tek sayfalık uygulamalar veya güvenlik kaygısı olmayan prototipler için belki aşırıya kaçabilir, ancak günümüz tehdit ortamında güvenlik her proje için bir gerekliliktir.
## NestJS Güvenliği vs Alternatifler
NestJS'in güvenlik yaklaşımını daha iyi anlamak için, popüler Node.js framework'leri olan Express.js ve Fastify ile karşılaştıralım. Bu karşılaştırma, 2026'daki güncel durumlarını yansıtmaktadır.
| Özellik | NestJS | Express.js | Fastify |
| :------------------ | :--------------------------------------------- | :------------------------------------------ | :------------------------------------------ |
| **Performans** | Yüksek (Fastify'den biraz düşük) | Orta (middleware zinciri performansı etkiler) | Çok Yüksek (minimalist yapı) |
| **Öğrenme Eğrisi** | Orta (OOP, TypeScript, özel yapılandırma) | Düşük (basit API) | Orta (schema tabanlı, güçlü validasyon) |
| **Ekosistem** | Zengin (modüler, entegrasyon dostu) | Çok Zengin (geniş kütüphane desteği) | Orta (hız odaklı, genç ekosistem) |
| **Topluluk** | Çok Aktif ve Büyüyen (kurumsal destekli) | Çok Büyük ve Olgun | Aktif ve Hızlı Gelişen |
| **Kurumsal Destek** | Yüksek (büyük şirketler tarafından kullanılıyor)| Orta (geniş kullanım alanı) | Orta (performans odaklı niş) |
| **Güvenlik Mekanizmaları** | Dahili Guard'lar, Pipe'lar, Interceptor'lar, Helmet, CORS modülleri, class-validator entegrasyonu. Yapısal olarak güvenli geliştirme teşvik eder. | Middleware tabanlı (Helmet, CORS, rate-limit vb. manuel entegrasyon gerektirir). Esneklik sunar ancak geliştiriciye daha fazla sorumluluk yükler. | Schema tabanlı validasyon, dahili güvenlik başlıkları, JWT entegrasyonları. Hızlı ve güvenli geliştirme için optimize edilmiştir. |
| **Kullanım Alanı** | Kurumsal API'ler, mikro servisler, büyük ölçekli uygulamalar | Hızlı prototipleme, küçük-orta ölçekli API'ler, web uygulamaları | Yüksek performans gerektiren API'ler, mikro servisler |
NestJS, güvenlik mekanizmalarını framework'ün kendisine entegre ederek geliştiricilere daha tutarlı ve yönetilebilir bir güvenlik katmanı sunar. Express.js daha esnek olsa da, güvenlik için her şeyi manuel olarak yapılandırmak ve yönetmek geliştiriciye daha fazla sorumluluk yükler. Fastify ise performans odaklı olmakla birlikte, schema tabanlı validasyonları ile güçlü bir güvenlik temeli sağlar. Ancak NestJS'in modüler yapısı ve TypeScript desteği, özellikle büyük ve karmaşık projelerde güvenlik yönetimini daha sistematik hale getirir.
## Kurulum ve İlk Adımlar: Güvenli NestJS Uygulaması 2026
NestJS uygulamanızı güvenli bir şekilde başlatmak, temel güvenlik modüllerini entegre etmekle başlar. 2026 itibarıyla, bu adımlar modern bir NestJS projesi için standart hale gelmiştir.
**Ön Gereksinimler:**
* Node.js (LTS sürümü, 2026'nın güncel LTS'i) kurulu olmalı.
* npm veya Yarn kurulu olmalı.
* NestJS CLI kurulu olmalı (`npm install -g @nestjs/cli`).
1. **Yeni Bir NestJS Projesi Oluşturma:**
İlk olarak, NestJS CLI kullanarak yeni bir proje oluşturalım. Bu, temel bir yapılandırma ile gelir.
```bash
nest new nestjs-guvenlik-2026
cd nestjs-guvenlik-2026
```
2. **Temel Güvenlik Modüllerini Yükleme:**
Uygulamanızı çeşitli yaygın web zafiyetlerine karşı korumak için `@nestjs/platform-express` ile uyumlu Helmet, CORS ve Rate Limiting (Throttler) modüllerini yükleyelim.
```bash
npm install --save @nestjs/platform-express helmet cors @nestjs/throttler
npm install --save-dev @types/helmet @types/cors
```
3. **Güvenlik Modüllerini Entegre Etme (main.ts):**
`src/main.ts` dosyasını düzenleyerek Helmet ve CORS'u global olarak etkinleştirelim. Throttler'ı daha sonra modül bazında yapılandıracağız.
```typescript
// src/main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import helmet from 'helmet';
import { ValidationPipe } from '@nestjs/common';
async function bootstrap() {
const app = await NestFactory.create(AppModule);
// 1. Güvenlik Başlıkları için Helmet kullanımı
app.use(helmet());
// 2. CORS yapılandırması (üretim ortamında daha kısıtlı olmalı)
app.enableCors({
origin: ['http://localhost:3000', 'https://your-frontend-domain.com'], // Güvenli frontend domainleri
methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
credentials: true,
});
// 3. Global Pipe olarak ValidationPipe ekleme
app.useGlobalPipes(new ValidationPipe({
whitelist: true, // Tanımlanmayan property'leri otomatik kaldırır
forbidNonWhitelisted: true, // Tanımlanmayan property'ler geldiğinde hata fırlatır
transform: true, // DTO'ları otomatik olarak tiplerine dönüştürür
}));
const port = process.env.PORT || 3000;
await app.listen(port);
console.log(`Uygulama ${port} portunda çalışıyor. (2026)`)
}
bootstrap();
```
> **Pro Tip:** Üretim ortamında `app.enableCors()` içindeki `origin` değerini kesinlikle sadece izin verilen frontend domainleri ile sınırlandırmalısınız. `*` kullanmak ciddi bir güvenlik zafiyetidir.
4. **Rate Limiting (Throttler) Modülünü Yapılandırma (app.module.ts):**
DDoS saldırılarına ve brute-force denemelerine karşı koruma sağlamak için `ThrottlerModule`'ü `AppModule`'e ekleyelim.
```typescript
// src/app.module.ts
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { ThrottlerModule, ThrottlerGuard } from '@nestjs/throttler';
import { APP_GUARD } from '@nestjs/core';
@Module({
imports: [
ThrottlerModule.forRoot({
ttl: 60, // 60 saniye içinde
limit: 10, // En fazla 10 istek
}),
],
controllers: [AppController],
providers: [
AppService,
{
provide: APP_GUARD,
useClass: ThrottlerGuard, // Tüm uygulama için ThrottlerGuard'ı uygula
},
],
})
export class AppModule {}
```
Bu adımlarla, NestJS uygulamanız 2026'nın temel güvenlik gereksinimlerini karşılayacak şekilde yapılandırılmıştır. Bir sonraki bölümde, daha ileri güvenlik mekanizmalarını inceleyeceğiz.
## Temel Güvenlik Kullanımı ve Örnekler
NestJS'in güvenlik modülleri ve yapıları, uygulamanızın farklı katmanlarında güvenlik sağlamak için esnek yollar sunar. İşte temel kullanım senaryoları ve çalışan kod örnekleri:
### 1. Kimlik Doğrulama (Authentication) - JWT Stratejisi
**Problem:** Kullanıcıların sisteme güvenli bir şekilde giriş yapmasını ve kimliklerinin doğrulanmasını sağlamak.
**Çözüm:** JWT (JSON Web Token) tabanlı kimlik doğrulama stratejisi kullanarak kullanıcıların kimliğini doğrulamak. NestJS'in `@nestjs/passport` ve `passport-jwt` modülleri bu iş için idealdir.
**Kod:**
Önce gerekli paketleri yükleyelim:
```bash
npm install --save @nestjs/passport passport passport-jwt @nestjs/jwt
npm install --save-dev @types/passport-jwt
```
`auth.module.ts`:
```typescript
// src/auth/auth.module.ts
import { Module } from '@nestjs/common';
import { AuthService } from './auth.service';
import { AuthController } from './auth.controller';
import { UsersModule } from '../users/users.module';
import { PassportModule } from '@nestjs/passport';
import { JwtModule } from '@nestjs/jwt';
import { JwtStrategy } from './jwt.strategy';
import { ConfigModule, ConfigService } from '@nestjs/config';
@Module({
imports: [
UsersModule,
PassportModule,
JwtModule.registerAsync({
imports: [ConfigModule],
useFactory: async (configService: ConfigService) => ({
secret: configService.get('JWT_SECRET'),
signOptions: { expiresIn: '60s' }, // Production'da daha uzun olabilir
}),
inject: [ConfigService],
}),
ConfigModule, // .env dosyalarını okumak için
],
providers: [AuthService, JwtStrategy],
controllers: [AuthController],
exports: [AuthService],
})
export class AuthModule {}
```
`jwt.strategy.ts`:
```typescript
// src/auth/jwt.strategy.ts
import { ExtractJwt, Strategy } from 'passport-jwt';
import { PassportStrategy } from '@nestjs/passport';
import { Injectable, UnauthorizedException } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { AuthService } from './auth.service';
@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
constructor(
private configService: ConfigService,
private authService: AuthService,
) {
super({
jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
ignoreExpiration: false,
secretOrKey: configService.get('JWT_SECRET'),
});
}
async validate(payload: any) {
// Kullanıcıyı veri tabanından kontrol edebiliriz
const user = await this.authService.validateUserById(payload.sub);
if (!user) {
throw new UnauthorizedException('Kullanıcı bulunamadı veya geçersiz token.');
}
return user; // İstek nesnesine eklenir (req.user)
}
}
```
`auth.controller.ts` (Login endpoint'i):
```typescript
// src/auth/auth.controller.ts
import { Controller, Post, Body, UseGuards, Request } from '@nestjs/common';
import { AuthService } from './auth.service';
import { AuthGuard } from '@nestjs/passport';
import { LoginDto } from './dto/login.dto'; // Login için DTO
@Controller('auth')
export class AuthController {
constructor(private authService: AuthService) {}
@Post('login')
async login(@Body() loginDto: LoginDto) {
const user = await this.authService.validateUser(loginDto.username, loginDto.password);
if (!user) {
throw new UnauthorizedException('Geçersiz kimlik bilgileri.');
}
return this.authService.login(user);
}
@UseGuards(AuthGuard('jwt'))
@Post('profile')
getProfile(@Request() req) {
return req.user; // Token ile gelen kullanıcı bilgisi
}
}
```
### 2. Yetkilendirme (Authorization) - Rol Tabanlı Erişim Kontrolü (RBAC)
**Problem:** Kimliği doğrulanmış kullanıcıların belirli kaynaklara veya işlemlere erişimini kısıtlamak.
**Çözüm:** Guard'lar ve dekoratörler kullanarak rol tabanlı erişim kontrolü uygulamak.
**Kod:**
`roles.guard.ts`:
```typescript
// src/auth/roles.guard.ts
import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { ROLES_KEY } from './roles.decorator';
import { Role } from './enums/role.enum';
@Injectable()
export class RolesGuard implements CanActivate {
constructor(private reflector: Reflector) {}
canActivate(context: ExecutionContext): boolean {
const requiredRoles = this.reflector.getAllAndOverride(ROLES_KEY, [
context.getHandler(),
context.getClass(),
]);
if (!requiredRoles) {
return true;
}
const { user } = context.switchToHttp().getRequest();
return requiredRoles.some((role) => user.roles?.includes(role));
}
}
```
`roles.decorator.ts`:
```typescript
// src/auth/roles.decorator.ts
import { SetMetadata } from '@nestjs/common';
import { Role } from './enums/role.enum';
export const ROLES_KEY = 'roles';
export const Roles = (...roles: Role[]) => SetMetadata(ROLES_KEY, roles);
```
`role.enum.ts`:
```typescript
// src/auth/enums/role.enum.ts
export enum Role {
User = 'user',
Admin = 'admin',
}
```
Controller'da kullanım:
```typescript
// src/items/items.controller.ts (örnek)
import { Controller, Get, UseGuards } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';
import { RolesGuard } from '../auth/roles.guard';
import { Roles } from '../auth/roles.decorator';
import { Role } from '../auth/enums/role.enum';
@Controller('items')
@UseGuards(AuthGuard('jwt'), RolesGuard) // Önce kimlik doğrulama, sonra yetkilendirme
export class ItemsController {
@Get('admin-only')
@Roles(Role.Admin)
getAdminItems() {
return 'Bu sadece yöneticilere özel içerik (2026).';
}
@Get('public')
getPublicItems() {
return 'Bu tüm kimliği doğrulanmış kullanıcılara açık içerik.';
}
}
```
### 3. Girdi Doğrulama (Input Validation) - Class-validator ve Pipes
**Problem:** Kötü niyetli veya hatalı kullanıcı girdileri nedeniyle uygulamanın kararsız hale gelmesini veya güvenlik açıklarının oluşmasını engellemek.
**Çözüm:** `class-validator` ve `class-transformer` kütüphanelerini NestJS'in `ValidationPipe`'ı ile kullanarak gelen verileri otomatik olarak doğrulamak ve dönüştürmek.
**Kod:**
Paketleri yükleyelim:
```bash
npm install --save class-validator class-transformer
```
`create-user.dto.ts`:
```typescript
// src/users/dto/create-user.dto.ts
import { IsString, IsEmail, MinLength, MaxLength, IsEnum } from 'class-validator';
import { Role } from '../../auth/enums/role.enum';
export class CreateUserDto {
@IsString()
@MinLength(3)
@MaxLength(50)
username: string;
@IsEmail()
email: string;
@IsString()
@MinLength(6, { message: 'Parola en az 6 karakter olmalı.' })
password: string;
@IsEnum(Role, { each: true, message: 'Geçersiz rol(ler) belirtildi.' })
roles: Role[];
}
```
Controller'da kullanım (global pipe zaten ayarlı):
```typescript
// src/users/users.controller.ts (örnek)
import { Controller, Post, Body } from '@nestjs/common';
import { CreateUserDto } from './dto/create-user.dto';
@Controller('users')
export class UsersController {
@Post()
async createUser(@Body() createUserDto: CreateUserDto) {
// DTO otomatik olarak doğrulanır. Geçersizse hata fırlatılır.
console.log('Kullanıcı oluşturuluyor:', createUserDto);
return { message: 'Kullanıcı başarıyla oluşturuldu (2026).' };
}
}
```
### 4. Güvenli Çerezler ve Oturum Yönetimi
**Problem:** Oturum bilgilerinin çalınması (örneğin XSS saldırılarıyla) veya manipüle edilmesi.
**Çözüm:** `HttpOnly`, `Secure`, `SameSite` gibi çerez özelliklerini kullanarak çerezleri güvenli hale getirmek ve oturum yönetimini dikkatli yapmak.
**Kod:**
NestJS, `res.cookie()` veya `@Res()` dekoratörü ile çerezleri ayarlarken bu seçenekleri sunar.
```typescript
// src/auth/auth.controller.ts (örnek bir oturum çerezi ayarlama)
import { Controller, Post, Res, Body } from '@nestjs/common';
import { Response } from 'express';
@Controller('auth')
export class AuthController {
@Post('set-secure-cookie')
setSecureCookie(@Res({ passthrough: true }) res: Response) {
res.cookie('session_token', 'your_secure_token_value',
{
httpOnly: true, // JavaScript erişemez
secure: process.env.NODE_ENV === 'production', // Sadece HTTPS üzerinden gönderilir
sameSite: 'Lax', // CSRF koruması için
maxAge: 3600000, // 1 saat
path: '/',
});
return { message: 'Güvenli çerez ayarlandı (2026).' };
}
}
```
> **Uyarı:** `SameSite` özelliğinin `None` olarak ayarlanması durumunda `Secure` özelliği zorunludur. Aksi takdirde çerez tarayıcılar tarafından reddedilir. `Lax` veya `Strict` genellikle daha güvenli seçeneklerdir.
## İleri Seviye NestJS Güvenlik Teknikleri (2026)
Uygulamanızı sadece temel saldırılardan korumak yeterli değildir. 2026'nın gelişmiş tehdit ortamında, derinlemesine güvenlik stratejileri uygulamak elzemdir. İşte senior developer'lar için NestJS'te ileri seviye güvenlik teknikleri:
### 1. Güvenli Konfigürasyon Yönetimi ve Sır Saklama
**Problem:** Hassas bilgilerin (API anahtarları, veritabanı şifreleri, JWT sırları) kod içinde veya versiyon kontrol sistemlerinde saklanması.
**Çözüm:** `ConfigModule` kullanarak ortam değişkenlerini yönetmek ve üretimde HashiCorp Vault gibi sır saklama çözümleriyle entegrasyon sağlamak.
**Nasıl Çalışır:** NestJS `ConfigModule`, `.env` dosyalarını okuyarak veya özel bir yükleyici ile sırları dinamik olarak almanızı sağlar. Üretimde, uygulama başlatılırken sırları bir Vault sunucusundan çekmek, kodun hassas bilgiler içermemesini garanti eder.
```typescript
// src/app.module.ts (ConfigModule yapılandırması)
import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import * as Joi from 'joi'; // Ortam değişkeni doğrulama için
@Module({
imports: [
ConfigModule.forRoot({
isGlobal: true,
envFilePath: `.env.${process.env.NODE_ENV || 'development'}`, // Ortama özel .env dosyaları
validationSchema: Joi.object({
NODE_ENV: Joi.string().valid('development', 'production', 'test').default('development'),
PORT: Joi.number().default(3000),
JWT_SECRET: Joi.string().required(), // JWT sırrının varlığını kontrol et
DATABASE_URL: Joi.string().required(),
}),
// Üretimde özel bir loader ile Vault'tan sırları çekebiliriz
// load: [vaultConfigLoader],
}),
// ... diğer modüller
],
// ...
})
export class AppModule {}
```
`.env.production` (örnek):
```env
NODE_ENV=production
PORT=4000
JWT_SECRET=SUPER_GIZLI_JWT_ANAHTARI_2026_COK_UZUN_VE_GUCLU
DATABASE_URL=postgresql://user:password@host:port/database
```
> **Experience:** Son projemde, sır yönetimi için AWS Secrets Manager ile `ConfigModule`'ü entegre ettik. Bu yaklaşım, CI/CD pipeline'ında hassas bilgilerin açığa çıkmasını engelledi ve güvenlik denetimlerinden sorunsuz geçmemizi sağladı.
### 2. Güvenlik Başlıkları ile Derinlemesine Savunma (Helmet)
**Problem:** Tarayıcı tabanlı saldırılar (XSS, Clickjacking, MIME-sniffing) ve güvenlik başlıklarının eksikliği.
**Çözüm:** Helmet kütüphanesini kullanarak HTTP güvenlik başlıklarını otomatik olarak ayarlamak. NestJS'te `app.use(helmet())` ile kolayca entegre edilir, ancak özel yapılandırmalarla daha da güçlendirilebilir.
**Nasıl Çalışır:** Helmet, Content Security Policy (CSP), X-XSS-Protection, X-Frame-Options, Strict-Transport-Security (HSTS) gibi başlıkları ayarlayarak tarayıcının kötü amaçlı içerikleri işlemesini engeller.
```typescript
// src/main.ts (Helmet'i özelleştirme)
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import helmet from 'helmet';
async function bootstrap() {
const app = await NestFactory.create(AppModule);
app.use(
helmet({
contentSecurityPolicy: {
directives: {
defaultSrc: [`'self'`],
styleSrc: [`'self'`, `'unsafe-inline'`],
imgSrc: [`'self'`, 'data:', 'res.cloudinary.com'],
scriptSrc: [`'self'`, `'unsafe-inline'`, `'unsafe-eval'`], // Dikkat: unsafe-eval sadece geliştirme için. Üretimde kaçının.
},
},
crossOriginResourcePolicy: { policy: 'same-origin' },
// Diğer başlıklar varsayılan olarak gelir veya burada özelleştirilebilir.
}),
);
// ... diğer yapılandırmalar
await app.listen(3000);
}
bootstrap();
```
> **Uyarı:** `Content-Security-Policy` (CSP) başlığını yapılandırırken çok dikkatli olunmalıdır. Yanlış yapılandırma, uygulamanızın bazı özelliklerinin çalışmamasına neden olabilir. Üretimde `unsafe-inline` ve `unsafe-eval` kullanmaktan kesinlikle kaçının ve mümkün olduğunca sıkı kurallar uygulayın.
### 3. API Anahtarı Yönetimi ve Erişimi
**Problem:** Üçüncü taraf hizmetlerin veya istemcilerin API'nize güvenli bir şekilde erişmesini sağlamak.
**Çözüm:** Özel bir Guard ile API anahtarlarını doğrulamak. Anahtarların veritabanında güvenli bir şekilde saklanması ve şifrelenmesi önemlidir.
**Kod:**
`api-key.guard.ts`:
```typescript
// src/auth/api-key.guard.ts
import { Injectable, CanActivate, ExecutionContext, UnauthorizedException } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
@Injectable()
export class ApiKeyGuard implements CanActivate {
constructor(private configService: ConfigService) {}
async canActivate(context: ExecutionContext): Promise {
const request = context.switchToHttp().getRequest();
const apiKey = request.headers['x-api-key'];
if (!apiKey) {
throw new UnauthorizedException('API anahtarı eksik.');
}
// Gerçek bir senaryoda, bu anahtarı veritabanından veya bir sır yöneticisinden doğrulamalısınız.
// Basit bir örnek için ortam değişkeninden okuyalım.
const validApiKey = this.configService.get('API_KEY');
if (apiKey !== validApiKey) {
throw new UnauthorizedException('Geçersiz API anahtarı.');
}
return true;
}
}
```
Controller'da kullanım:
```typescript
// src/data/data.controller.ts
import { Controller, Get, UseGuards } from '@nestjs/common';
import { ApiKeyGuard } from '../auth/api-key.guard';
@Controller('data')
export class DataController {
@UseGuards(ApiKeyGuard)
@Get('external')
getProtectedData() {
return { message: 'API anahtarı ile erişilen gizli veri (2026).' };
}
}
```
## Best Practices & Anti-Patterns (2026)
NestJS uygulamalarınızın 2026'da güvenli kalmasını sağlamak için dikkat etmeniz gereken en iyi uygulamalar ve kaçınmanız gereken anti-pattern'ler:
* ✅ **Girdi Doğrulamayı Her Yerde Uygulayın:** Kullanıcıdan gelen her türlü veriyi (body, query, params, headers) `class-validator` ve `ValidationPipe` ile mutlaka doğrulayın. Bu, SQL Injection, XSS ve diğer birçok enjeksiyon saldırısını önler.
* ❌ **Input Sanitization'ı İhmal Etmeyin:** Doğrulama yeterli değildir. Gelen verileri kaydetmeden veya kullanmadan önce potansiyel kötü amaçlı karakterlerden arındırın (örneğin, `DOMPurify` veya benzeri kütüphanelerle HTML sanitization).
* ✅ **Şifreleri Güvenli Bir Şekilde Saklayın:** Parolaları asla düz metin olarak saklamayın. `bcrypt` gibi güçlü tek yönlü şifreleme algoritmaları kullanarak hash'leyin. 2026 itibarıyla `bcrypt`'in güncel ve güvenli bir sürümünü kullanın.
* ❌ **Zayıf JWT Sırları Kullanmayın:** JWT imzaları için kullanılan sır anahtarları uzun, karmaşık ve tahmin edilemez olmalıdır. Ortam değişkenlerinden veya sır yöneticilerinden alınmalıdır.
* ✅ **CORS Ayarlarını Kısıtlayın:** Üretim ortamında `app.enableCors({ origin: '*' })` kullanmaktan kaçının. Yalnızca uygulamanızın ihtiyaç duyduğu belirli domainlere izin verin.
* ❌ **Hata Mesajlarında Hassas Bilgileri Açıklamayın:** Üretim ortamında, hata mesajları yığın izlerini (stack traces) veya veritabanı hatalarını içermemelidir. Genel hata mesajları döndürün ve detayları log sisteminize yazın.
* ✅ **Güvenlik Başlıklarını Kullanın:** Helmet kütüphanesini kullanarak uygulamanızın HTTP güvenlik başlıklarını güçlendirin. Özellikle `Content-Security-Policy`'yi dikkatlice yapılandırın.
* ❌ **Bağımlılık Güvenlik Açıklarını Göz Ardı Etmeyin:** Düzenli olarak `npm audit` veya Snyk gibi araçlarla bağımlılıklarınızdaki güvenlik açıklarını tarayın ve güncelleyin. Eski kütüphaneler ciddi riskler taşır.
* ✅ **Rate Limiting Uygulayın:** Brute-force saldırılarını ve DDoS denemelerini önlemek için `ThrottlerModule` gibi araçlarla API endpoint'lerinize hız sınırlaması getirin.
* ❌ **Varsayılan Ayarlara Güvenmeyin:** Birçok framework ve kütüphane varsayılan güvenlik ayarlarıyla gelir, ancak bunlar genellikle en katı değildir. Uygulamanızın özel ihtiyaçlarına göre güvenlik ayarlarını gözden geçirin ve sıkılaştırın.
* ✅ **HTTPS Kullanımını Zorunlu Kılın:** Tüm iletişim kanallarınızda (API, veritabanı, mikro servisler arası) HTTPS/TLS şifrelemesini zorunlu kılın. `Strict-Transport-Security` başlığını kullanın.
* ❌ **CSRF Korumasını Unutmayın:** Oturum tabanlı kimlik doğrulama kullanıyorsanız, CSRF (Cross-Site Request Forgery) saldırılarına karşı koruma sağlamak için `csurf` gibi kütüphaneleri veya `SameSite` çerez özelliklerini kullanın.
## Yaygın NestJS Güvenlik Hataları ve Çözümleri (2026)
NestJS geliştiricilerinin 2026'da sıkça karşılaştığı güvenlik odaklı hatalar ve bunların pratik çözümleri:
1. **Problem:** JWT sırrının `.env` dosyasında veya kodda açıkta bırakılması.
**Sebep:** `JWT_SECRET` gibi hassas bir bilginin versiyon kontrol sistemine yanlışlıkla dahil edilmesi veya üretim ortamında güvensiz bir şekilde yönetilmesi.
**Çözüm:** `ConfigModule` ve ortam değişkenlerini doğru kullanarak sırrı `.env` dosyaları dışında tutun ve üretimde HashiCorp Vault, AWS Secrets Manager gibi bir sır yönetimi servisi kullanın. `.gitignore` dosyanıza `.env*` eklemeyi unutmayın.
2. **Problem:** CORS politikalarının `origin: '*'` olarak ayarlanması.
**Sebep:** Geliştirme kolaylığı için tüm domainlere erişim izni verilmesi ve üretimde bu ayarın unutulması, bu da Cross-Site Scripting (XSS) saldırılarına kapı aralayabilir.
**Çözüm:** `src/main.ts` içinde `app.enableCors()` metodunda `origin` özelliğini yalnızca izin verilen frontend domainleriyle sınırlayın. Örneğin: `origin: ['https://app.example.com', 'https://admin.example.com']`.
3. **Problem:** Girdi doğrulamasının (Validation) yetersiz veya eksik olması.
**Sebep:** Kullanıcıdan gelen verilerin (örneğin, `req.body`, `req.query`) `class-validator` veya özel Pipe'lar ile yeterince kontrol edilmemesi, enjeksiyon saldırılarına yol açabilir.
**Çözüm:** `app.useGlobalPipes(new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true }));` kullanarak tüm gelen verileri otomatik olarak doğrulayın. Her DTO için `@IsString()`, `@IsEmail()`, `@MinLength()` gibi dekoratörleri eksiksiz kullanın.
4. **Problem:** Parolaların düz metin olarak veya zayıf hash algoritmalarıyla saklanması.
**Sebep:** Geliştiricilerin güvenlik bilincinin eksikliği veya eski yöntemlerin kullanılması.
**Çözüm:** Parolaları kaydederken mutlaka `bcrypt` gibi güçlü, tek yönlü bir hashing algoritması kullanın. `bcrypt.hash()` ile parolayı hash'leyin ve `bcrypt.compare()` ile doğr