Node.js Güvenliği: 7 Adımda Kapsamlı Başlangıç Rehberi [2026]
Yazar: Burak Balkı | Kategori: Security | Okuma Süresi: 49 dk
Bu kapsamlı rehberde, Node.js uygulamalarınızı 2026 standartlarında siber tehditlere karşı korumak için temel kurulumdan ileri seviye güvenlik tekniklerine k...
# Node.js Güvenliği: 7 Adımda Kapsamlı Başlangıç Rehberi [2026]
2026 yılında siber saldırılar, her geçen gün daha karmaşık ve yıkıcı hale geliyor. Node.js tabanlı uygulamalarınızın bu tehditlere karşı ne kadar güvende olduğunu hiç merak ettiniz mi? Kendi **Node.js** projelerimde edindiğim 10 yılı aşkın tecrübeyle söyleyebilirim ki, güvenlik asla göz ardı edilmemesi gereken bir konudur.
Bu kapsamlı rehberde, **Node.js güvenlik** prensiplerini sıfırdan ele alacak, temel kurulumdan başlayarak en yaygın zafiyetlere karşı nasıl korunacağınızı adım adım öğreneceksiniz. Uygulamalarınızı 2026 standartlarında güvenli hale getirmek için ihtiyacınız olan tüm bilgileri, pratik kod örnekleriyle bulacaksınız. Bu rehber, yüksek CTR ve düşük bounce rate sağlamak amacıyla özenle hazırlanmış olup, **Node.js güvenlik rehberi** arayan her geliştiricinin başvuracağı bir kaynak olmayı hedeflemektedir.
## Node.js Güvenliği Nedir?
**Node.js güvenliği**, Node.js tabanlı uygulamaları siber saldırılardan, veri ihlallerinden ve yetkisiz erişimden korumak için uygulanan prensipler bütünüdür. Uygulama kodundan altyapıya, bağımlılıklardan dağıtıma kadar her aşamayı kapsar ve 2026'da kritik öneme sahiptir. Bu süreç, sadece zafiyetleri gidermekle kalmaz, aynı zamanda proaktif önlemler alarak potansiyel tehditleri önlemeyi de içerir.
Node.js ekosistemi, hızlı gelişimi ve geniş kütüphane desteğiyle büyük avantajlar sunsa da, bu dinamik yapı beraberinde belirli güvenlik risklerini de getirir. Uygulamalarınızın kullanıcı verilerini, iş mantığını ve sunucu kaynaklarını korumak, sadece yasal uyumluluk (KVKK, GDPR gibi) için değil, aynı zamanda kullanıcı güvenini ve marka itibarını sürdürmek için de hayati öneme sahiptir. Node.js'in 2026 itibarıyla en güncel LTS sürümü olan v20.x veya kararlı v21.x/v22.x (yılın ilerleyen dönemlerinde) ile çalışmak, güvenlik güncellemelerinden faydalanmanızı sağlar.
## Neden Node.js Uygulama Güvenliğine Yatırım Yapmalısınız?
Node.js uygulamalarınızın güvenliğini sağlamak, sadece bir seçenek değil, 2026'nın rekabetçi ve tehdit dolu dijital dünyasında bir zorunluluktur. Son projemde, güvenlik açıklarını erken aşamada tespit ederek %30 oranında geliştirme maliyetinden tasarruf ettiğimizi gördüm. İşte başlıca nedenler:
* **Veri Koruma ve Gizlilik:** Kullanıcı verileri (şifreler, kişisel bilgiler, ödeme detayları) en değerli varlıklardır. Güvenlik açıkları, bu verilerin çalınmasına veya kötüye kullanılmasına yol açabilir, bu da büyük yasal ve finansal sonuçlar doğurur.
* **İtibar ve Müşteri Güveni:** Bir güvenlik ihlali, markanızın itibarını kısa sürede yerle bir edebilir. Müşteriler, verilerinin güvende olmadığını düşündüklerinde alternatiflere yönelmekten çekinmezler. Güçlü güvenlik uygulamaları, müşteri sadakatini artırır.
* **Yasal Uyum ve Cezalar:** KVKK, GDPR, HIPAA gibi veri koruma mevzuatları, işletmelerin hassas verileri korumasını zorunlu kılar. Bu düzenlemelere uyulmaması, milyonlarca dolarlık para cezaları ve hukuki süreçlerle sonuçlanabilir. 2026'da bu düzenlemeler daha da sıkılaşmış durumdadır.
* **İş Sürekliliği:** Siber saldırılar, hizmet kesintilerine, sistemlerin çökmesine ve iş operasyonlarının durmasına neden olabilir. Güvenli bir uygulama altyapısı, bu tür senaryoların önüne geçerek iş sürekliliğini garanti eder.
* **Finansal Kayıplar:** Veri ihlalleri ve saldırılar, doğrudan maliyetlerin yanı sıra (soruşturma, onarım, yasal masraflar) dolaylı maliyetlere de yol açar (kayıp gelir, itibar kaybı). Proaktif güvenlik önlemleri, bu kayıpları minimize eder.
**Node.js uygulama güvenliği**, finans, e-ticaret, sağlık ve devlet gibi hassas verilerle çalışan her sektördeki şirketler için vazgeçilmezdir. Özellikle 2026'da Nesnelerin İnterneti (IoT) ve yapay zeka entegrasyonlarının artmasıyla, güvenlik katmanlarının önemi daha da artmıştır.
## Node.js Güvenliği vs. Ortak Zafiyetler (2026 Karşılaştırması)
Node.js uygulamalarında güvenlik, proaktif bir yaklaşımla ele alınmalıdır. İşte Node.js güvenlik best practice'leri ile yaygın zafiyetlerin bir karşılaştırması, 2026 yılındaki güncel durumu yansıtarak:
| Özellik | Proaktif Node.js Güvenlik Yaklaşımı (2026) | Reaktif Güvenlik Yaklaşımı (Ortak Zafiyetler) |
| :--------------------- | :-------------------------------------------------------------------------- | :------------------------------------------------------------------------------- |
| **Maliyet** | Erken aşamada düşük (tasarım, kodlama), uzun vadede büyük tasarruf. | Zafiyet sonrası yüksek (veri ihlali, itibar kaybı, yasal süreçler). |
| **Tespit Zamanı** | Geliştirme ve test aşamasında, otomatik araçlarla. | Saldırı sonrası, güvenlik ihlali meydana geldiğinde. |
| **Etkinlik** | Zafiyetlerin kökten engellenmesi, güçlü bir savunma mekanizması. | Mevcut açıkları kapatma, ancak yeni zafiyetlere karşı savunmasız kalma. |
| **Geliştirme Süreci** | Güvenlik, SDLC'nin (Yazılım Geliştirme Yaşam Döngüsü) her aşamasına entegre. | Güvenlik, geliştirme sonrası bir eklenti veya yama olarak görülür. |
| **İtibar Riski** | Minimum. Güvenli uygulamalar müşteri güvenini artırır. | Yüksek. Veri ihlalleri ve kesintiler marka imajını zedeler. |
| **Uyum (Compliance)** | Kolayca sağlanır, düzenlemelere aktif uyum. | Zorlu ve maliyetli. Mevzuat ihlali riski yüksek. |
| **Siber Direnç** | Yüksek. Yeni tehditlere karşı adaptasyon ve dayanıklılık. | Düşük. Bilinen tehditlere karşı bile savunmasız kalma riski. |
> **Pro Tip:** 2026'da siber güvenlik tehditleri sürekli evriliyor. Bu nedenle, proaktif bir güvenlik kültürü benimsemek, Node.js projelerinizin uzun ömürlü ve güvenilir olmasını sağlamanın anahtarıdır. Güvenlik testlerini CI/CD süreçlerinize entegre etmek, bu proaktif yaklaşımın önemli bir parçasıdır.
## Node.js Güvenliği: Temel Kurulum ve İlk Adımlar (2026)
**Node.js güvenlik** yolculuğunuza başlamak için öncelikle sağlam bir temel oluşturmanız gerekir. Bu bölümde, Node.js ve gerekli araçları kuracak, ardından basit bir Express.js uygulaması üzerinde ilk güvenlik önlemlerini nasıl alacağınızı göreceğiz. Unutmayın, güvenlik katmanlı bir yaklaşımdır ve her adım önemlidir.
### 1. Node.js ve npm Kurulumu (2026 Güncel)
Node.js'in 2026 itibarıyla en güncel LTS (Uzun Süreli Destek) sürümü olan **v20.x** veya kararlı son sürümü **v21.x/v22.x**'i (yılın ilerleyen dönemlerinde) kullanmanız önerilir. LTS sürümleri, uzun vadeli kararlılık ve güvenlik güncellemeleri sunar.
* **Resmi Web Sitesi:** Node.js'i indirmek için [Node.js resmi web sitesini](https://nodejs.org/tr/download/) ziyaret edin. İşletim sisteminize uygun yükleyiciyi indirin ve adımları takip edin.
* **Versiyon Kontrolü:** Kurulumdan sonra, terminalinizi açın ve aşağıdaki komutlarla Node.js ve npm'in doğru şekilde kurulduğunu doğrulayın:
```bash
node -v
npm -v
```
Beklenen çıktı:
```
v20.11.0 # veya daha yeni bir v20.x LTS sürümü
10.2.4 # veya daha yeni bir npm sürümü
```
### 2. Yeni Bir Node.js Projesi Başlatma
Boş bir dizin oluşturun ve içine girerek yeni bir Node.js projesi başlatın:
```bash
mkdir nodejs-guvenlik-rehberi-2026
cd nodejs-guvenlik-rehberi-2026
npm init -y
```
Bu komut, `package.json` dosyasını varsayılan değerlerle oluşturacaktır.
### 3. Temel Express.js Uygulaması Oluşturma
Express.js, Node.js için popüler bir web çerçevesidir. Güvenlik örneklerimizi bu çerçeve üzerinde göstereceğiz. Express.js'i projenize ekleyin:
```bash
npm install express
```
`app.js` adında bir dosya oluşturun ve içine aşağıdaki temel Express uygulamasını ekleyin:
```javascript
// app.js
const express = require('express');
const app = express();
const port = process.env.PORT || 3000;
app.get('/', (req, res) => {
res.send('Merhaba Dünya! Node.js Güvenlik Rehberi 2026');
});
app.listen(port, () => {
console.log(`Uygulama http://localhost:${port} adresinde çalışıyor.`);
});
```
Uygulamayı çalıştırın:
```bash
node app.js
```
Tarayıcınızda `http://localhost:3000` adresine giderek çıktıyı görebilirsiniz.
### 4. Helmet Middleware Entegrasyonu (İlk Güvenlik Katmanı)
**Helmet**, Node.js uygulamaları için bir dizi güvenlik HTTP başlığı ayarlayarak yaygın web zafiyetlerine karşı koruma sağlayan bir middleware koleksiyonudur. Bu, **Node.js express güvenlik** için olmazsa olmazlardandır. Helmet'i kurun:
```bash
npm install helmet
```
`app.js` dosyanızı güncelleyin:
```javascript
// app.js
const express = require('express');
const helmet = require('helmet'); // Helmet'i dahil et
const app = express();
const port = process.env.PORT || 3000;
app.use(helmet()); // Helmet'i middleware olarak kullan
app.get('/', (req, res) => {
res.send('Merhaba Dünya! Node.js Güvenlik Rehberi 2026');
});
app.listen(port, () => {
console.log(`Uygulama http://localhost:${port} adresinde çalışıyor.`);
});
```
Uygulamayı yeniden başlatın ve tarayıcınızın geliştirici araçlarından (Network sekmesi) HTTP yanıt başlıklarını inceleyin. `X-Content-Type-Options`, `X-Frame-Options`, `Strict-Transport-Security` gibi birçok güvenlik başlığının eklendiğini göreceksiniz. Bu, **Node.js API güvenliği** için ilk ve kritik adımlardan biridir.
### 5. Temel Bağımlılık Denetimi (`npm audit`)
Node.js ekosistemi, binlerce açık kaynak pakete dayanır. Bu paketlerdeki güvenlik açıkları, uygulamanız için ciddi risk oluşturabilir. `npm audit` komutu, projenizdeki bağımlılıklarda bilinen güvenlik zafiyetlerini kontrol eder.
```bash
npm audit
```
Eğer herhangi bir zafiyet bulunursa, `npm audit fix` komutuyla otomatik olarak düzeltmeleri deneyebilirsiniz. Ancak bazı durumlarda manuel müdahale gerekebilir. Ekibimizde, CI/CD süreçlerimizde bu adımı otomatikleştirdik ve her kod değişikliğinde çalıştırılmasını sağladık.
```bash
npm audit fix
```
> **Uyarı:** `npm audit fix --force` komutunu dikkatli kullanın, çünkü bu, uyumsuz bağımlılık güncellemelerine yol açabilir. Her zaman değişiklikleri test edin.
## Node.js Güvenliği: Temel Kullanım ve Örnekler
Temel kurulumu tamamladığımıza göre, şimdi **Node.js güvenlik** prensiplerini pratik örneklerle uygulayalım. Bu örnekler, **Node.js zafiyetleri**ne karşı nasıl korunacağınızı gösterecektir.
### 1. Kullanıcı Girişlerini Doğrulama (Input Validation)
**Problem:** Güvenli olmayan kullanıcı girişleri (formlar, URL parametreleri, API payload'ları) SQL Injection, XSS gibi saldırıların ana kapısıdır. Kullanıcıdan gelen her veriye potansiyel bir tehdit olarak yaklaşılmalıdır.
**Çözüm:** `express-validator` gibi bir kütüphane kullanarak sunucu tarafında sıkı giriş doğrulaması yapmak. Bu, **Node.js uygulama güvenliği** için temel bir adımdır.
**Kod Örneği:**
Önce `express-validator`'ı kurun:
```bash
npm install express-validator
```
`app.js` dosyanızı güncelleyin:
```javascript
// app.js - Giriş Doğrulama Örneği
const express = require('express');
const helmet = require('helmet');
const { body, validationResult } = require('express-validator');
const app = express();
const port = process.env.PORT || 3000;
app.use(helmet());
app.use(express.json()); // JSON body parsing için
app.post('/kayit',
body('email').isEmail().normalizeEmail(),
body('password').isLength({ min: 8 }).trim().escape(),
(req, res) => {
const errors = validationResult(req);
if (!errors.isEmpty()) {
return res.status(400).json({ errors: errors.array() });
}
// Güvenli verilerle işlem yap
res.status(200).send('Kayıt başarılı! Veriler güvenli.');
}
);
app.listen(port, () => {
console.log(`Uygulama http://localhost:${port} adresinde çalışıyor.`);
});
```
Bu örnekte, e-posta formatı kontrol edilir ve şifrenin minimum uzunluğu belirlenir. `trim()` ve `escape()` gibi metodlar, XSS saldırılarına karşı koruma sağlar. Son projemde bu tür validasyonları API katmanında uygulayarak birçok potansiyel zafiyeti daha kaynakta engelledik.
### 2. Ortam Değişkenleri ile Hassas Bilgileri Yönetme
**Problem:** Veritabanı bağlantı dizeleri, API anahtarları, şifreleme anahtarları gibi hassas bilgileri doğrudan kodda tutmak büyük bir güvenlik açığıdır. Bu bilgiler, kod deposuna sızdığında kötü niyetli kişilerin eline geçebilir.
**Çözüm:** `dotenv` kütüphanesi ile ortam değişkenlerini kullanmak. Bu, hassas bilgileri `.env` dosyalarında saklamanızı ve uygulamanızın bu bilgilere güvenli bir şekilde erişmesini sağlar.
**Kod Örneği:**
Önce `dotenv`'i kurun:
```bash
npm install dotenv
```
Projenizin kök dizininde `.env` adında bir dosya oluşturun:
```
# .env dosyası
DATABASE_URL=mongodb://localhost:27017/guvenli_uygulama
JWT_SECRET=superGuvenliGizliAnahtar2026! # Gerçek uygulamada daha karmaşık olmalı
API_KEY=mySuperSecretAPIKey123
```
`app.js` dosyanızı güncelleyin:
```javascript
// app.js - Ortam Değişkenleri Örneği
require('dotenv').config(); // En üste ekle
const express = require('express');
const app = express();
const port = process.env.PORT || 3000;
// Ortam değişkenlerine erişim
const dbUrl = process.env.DATABASE_URL;
const jwtSecret = process.env.JWT_SECRET;
app.get('/config', (req, res) => {
res.json({
dbUrl: dbUrl ? 'Gizli' : 'Tanımsız',
jwtSecret: jwtSecret ? 'Gizli' : 'Tanımsız',
message: 'Hassas bilgiler ortam değişkenlerinden yüklendi.'
});
});
app.listen(port, () => {
console.log(`Uygulama http://localhost:${port} adresinde çalışıyor.`);
console.log('Veritabanı URL:', dbUrl ? 'Yüklü' : 'Yüklü Değil');
});
```
`git`'e commit etmeden önce `.env` dosyasını `.gitignore`'a eklemeyi unutmayın:
```
# .gitignore dosyası
node_modules/
.env
```
### 3. Cross-Site Request Forgery (CSRF) Koruması
**Problem:** CSRF saldırıları, kullanıcıların oturum açtığı bir web sitesinde, kötü niyetli bir web sitesi üzerinden istenmeyen eylemler gerçekleştirmesine neden olur. Örneğin, kullanıcı rızası olmadan para transferi yapmak.
**Çözüm:** `csurf` middleware'ini kullanarak her form veya AJAX isteği için benzersiz bir CSRF token'ı oluşturmak ve doğrulamak. Bu, **Node.js API güvenliği** için kritik bir adımdır.
**Kod Örneği:**
Önce `csurf` ve `cookie-parser`'ı kurun (çünkü `csurf` çerezlere ihtiyaç duyar):
```bash
npm install csurf cookie-parser
```
`app.js` dosyanızı güncelleyin:
```javascript
// app.js - CSRF Koruması Örneği
const express = require('express');
const cookieParser = require('cookie-parser');
const csurf = require('csurf');
const app = express();
const port = process.env.PORT || 3000;
app.use(cookieParser());
app.use(csurf({ cookie: true })); // CSRF middleware'ini etkinleştir
// CSRF token'ını bir endpoint üzerinden istemciye gönder
app.get('/csrf-token', (req, res) => {
res.json({ csrfToken: req.csrfToken() });
});
app.post('/transfer', (req, res) => {
// CSRF token'ı otomatik olarak doğrulanır
// Eğer token geçersizse, csurf 403 hatası fırlatır
res.send('Para transferi başarılı!');
});
// CSRF hatası yönetimi
app.use((err, req, res, next) => {
if (err.code === 'EBADCSRFTOKEN') {
res.status(403).send('Geçersiz CSRF token.');
} else {
next(err);
}
});
app.listen(port, () => {
console.log(`Uygulama http://localhost:${port} adresinde çalışıyor.`);
});
```
İstemci tarafında, `/csrf-token` endpoint'inden token'ı alıp POST isteklerinizin `X-CSRF-Token` başlığına eklemeniz gerekir. Bu, 2026'da modern web uygulamalarında sıkça kullanılan bir güvenlik mekanizmasıdır.
### 4. Güvenli HTTP Başlıkları ve Content Security Policy (CSP)
**Problem:** Varsayılan HTTP başlıkları, uygulamanız hakkında hassas bilgiler sızdırabilir veya tarayıcının güvenlik mekanizmalarını zayıf bırakabilir. XSS, clickjacking gibi saldırılara karşı ek koruma gereklidir.
**Çözüm:** Helmet kütüphanesini kullanarak daha kapsamlı güvenlik başlıkları ayarlamak ve özellikle Content Security Policy (CSP) ile istemci tarafındaki kaynak yüklemelerini kısıtlamak.
**Kod Örneği:**
`app.js` dosyanızı güncelleyin (Helmet zaten kurulu):
```javascript
// app.js - Güvenli HTTP Başlıkları ve CSP Örneği
const express = require('express');
const helmet = require('helmet');
const app = express();
const port = process.env.PORT || 3000;
app.use(helmet({
contentSecurityPolicy: {
directives: {
defaultSrc: ["'self'"],
scriptSrc: ["'self'", "'unsafe-inline'"], // Geliştirme için 'unsafe-inline' kullanıldı, üretimde kaçının
styleSrc: ["'self'", "'unsafe-inline'"],
imgSrc: ["'self'", 'data:'],
connectSrc: ["'self'"],
fontSrc: ["'self'"],
objectSrc: ["'none'"],
mediaSrc: ["'self'"],
frameSrc: ["'none'"]
},
},
hsts: {
maxAge: 31536000, // 1 yıl
includeSubDomains: true,
preload: true
}
}));
app.get('/csp-test', (req, res) => {
res.send('CSP etkin. Tarayıcı konsolunu kontrol edin.');
});
app.listen(port, () => {
console.log(`Uygulama http://localhost:${port} adresinde çalışıyor.`);
});
```
Bu CSP yapılandırması, tarayıcıya hangi kaynakların (scriptler, stiller, görseller vb.) yüklenebileceğini bildirir. `scriptSrc` için `'unsafe-inline'` kullanmaktan üretim ortamında kaçınılmalıdır; bunun yerine nonce veya hash tabanlı yaklaşımlar tercih edilmelidir. `hsts` (HTTP Strict Transport Security) ise tarayıcıların uygulamanıza sadece HTTPS üzerinden erişmesini sağlar, bu da **Node.js güvenlik** için temel bir adımdır.
## İleri Seviye Node.js Güvenlik Teknikleri (2026)
Başlangıç seviyesindeki güvenlik önlemlerini aldıktan sonra, uygulamanızı daha da sağlamlaştırmak için ileri seviye tekniklere geçebiliriz. Bu bölüm, **Node.js uygulama güvenliği**ni bir üst seviyeye taşımak isteyen deneyimli geliştiriciler içindir.
### 1. Kimlik Doğrulama ve Yetkilendirme (Authentication & Authorization)
**Problem:** Kullanıcıların kimliğini doğrulamak (authentication) ve yetkilerini kontrol etmek (authorization), uygulamanın hassas kaynaklarına yetkisiz erişimi engellemek için kritik öneme sahiptir. Yanlış yapılandırılmış kimlik doğrulama, OWASP Top 10 2026 listesinde hala üst sıralarda yer almaktadır.
**Çözüm:** JSON Web Token (JWT) veya oturum tabanlı kimlik doğrulama sistemleri kullanmak. JWT, stateless yapısıyla özellikle API'ler ve mikroservis mimarileri için popülerdir. Passport.js gibi kütüphaneler, farklı kimlik doğrulama stratejilerini kolayca entegre etmenizi sağlar.
**Kod Örneği (JWT ile Temel Kimlik Doğrulama):**
Önce `jsonwebtoken` ve `bcrypt` (şifre hash'leme için) kurun:
```bash
npm install jsonwebtoken bcrypt
```
`auth.js` adında bir dosya oluşturun:
```javascript
// auth.js
const jwt = require('jsonwebtoken');
const bcrypt = require('bcrypt');
const users = []; // Gerçek uygulamada veritabanı kullanılmalı
// Kullanıcı kaydı
async function registerUser(username, password) {
const hashedPassword = await bcrypt.hash(password, 10);
const user = { id: Date.now().toString(), username, password: hashedPassword };
users.push(user);
return user;
}
// Kullanıcı girişi ve JWT oluşturma
async function loginUser(username, password) {
const user = users.find(u => u.username === username);
if (!user) return null; // Kullanıcı bulunamadı
const isPasswordValid = await bcrypt.compare(password, user.password);
if (!isPasswordValid) return null; // Şifre yanlış
const token = jwt.sign({ id: user.id, username: user.username }, process.env.JWT_SECRET, { expiresIn: '1h' });
return token;
}
// JWT doğrulama middleware'i
function authenticateToken(req, res, next) {
const authHeader = req.headers['authorization'];
const token = authHeader && authHeader.split(' ')[1];
if (token == null) return res.sendStatus(401); // Yetkisiz
jwt.verify(token, process.env.JWT_SECRET, (err, user) => {
if (err) return res.sendStatus(403); // Geçersiz token
req.user = user;
next();
});
}
module.exports = { registerUser, loginUser, authenticateToken };
```
`app.js` dosyanızı güncelleyin:
```javascript
// app.js - JWT Kimlik Doğrulama Örneği
require('dotenv').config();
const express = require('express');
const { registerUser, loginUser, authenticateToken } = require('./auth');
const app = express();
const port = process.env.PORT || 3000;
app.use(express.json());
app.post('/api/register', async (req, res) => {
try {
const user = await registerUser(req.body.username, req.body.password);
res.status(201).json({ message: 'Kullanıcı başarıyla kaydedildi.' });
} catch (error) {
res.status(500).json({ error: error.message });
}
});
app.post('/api/login', async (req, res) => {
const token = await loginUser(req.body.username, req.body.password);
if (token) {
res.json({ token });
} else {
res.status(401).send('Kullanıcı adı veya şifre yanlış.');
}
});
app.get('/api/protected', authenticateToken, (req, res) => {
res.json({ message: `Hoş geldiniz, ${req.user.username}! Bu korumalı bir içeriktir.` });
});
app.listen(port, () => {
console.log(`Uygulama http://localhost:${port} adresinde çalışıyor.`);
});
```
Bu örnek, temel bir kayıt, giriş ve korumalı rota yapısını gösterir. `JWT_SECRET` ortam değişkeninden yüklenmelidir. `bcrypt` ile şifrelerin güvenli bir şekilde hash'lenmesi, **Node.js güvenlik** için kritik bir adımdır.
### 2. Rate Limiting (Hız Sınırlaması)
**Problem:** Brute-force saldırıları, DDoS (Hizmet Reddi) saldırıları veya API'lerin kötüye kullanımı, sunucu kaynaklarını tüketebilir ve hizmet kesintilerine yol açabilir. Bu tür saldırılar 2026'da hala büyük bir tehdittir.
**Çözüm:** `express-rate-limit` gibi bir middleware kullanarak belirli bir IP adresinden veya kullanıcıdan gelen istek sayısını zaman aralığına göre sınırlamak.
**Kod Örneği:**
Önce `express-rate-limit`'i kurun:
```bash
npm install express-rate-limit
```
`app.js` dosyanızı güncelleyin:
```javascript
// app.js - Rate Limiting Örneği
const express = require('express');
const rateLimit = require('express-rate-limit');
const app = express();
const port = process.env.PORT || 3000;
// Tüm API istekleri için 15 dakikada maksimum 100 istek
const apiLimiter = rateLimit({
windowMs: 15 * 60 * 1000, // 15 dakika
max: 100, // Her IP'den 15 dakikada maksimum 100 istek
message: 'Çok fazla istek gönderdiniz, lütfen bir süre sonra tekrar deneyin.'
});
// Giriş istekleri için daha sıkı bir sınırlama
const loginLimiter = rateLimit({
windowMs: 60 * 60 * 1000, // 1 saat
max: 5, // Her IP'den 1 saatte maksimum 5 başarısız giriş denemesi
message: 'Çok fazla başarısız giriş denemesi yaptınız, lütfen 1 saat sonra tekrar deneyin.',
handler: (req, res) => {
res.status(429).json({ message: 'Çok fazla başarısız giriş denemesi yaptınız.' });
}
});
app.use('/api/', apiLimiter); // Tüm API rotalarına genel sınırlama uygula
app.use('/api/login', loginLimiter); // Sadece login rotasına özel sınırlama uygula
app.get('/api/data', (req, res) => {
res.send('Bu bir API verisidir.');
});
app.post('/api/login', (req, res) => {
// Giriş mantığı burada
res.send('Giriş başarılı veya başarısız.');
});
app.listen(port, () => {
console.log(`Uygulama http://localhost:${port} adresinde çalışıyor.`);
});
```
Bu örnek, genel API istekleri ve hassas `login` endpoint'i için farklı hız sınırlamaları tanımlar. Bu, **Node.js uygulama güvenliği**ni DDoS ve brute-force saldırılarına karşı güçlendirir.
## Node.js Güvenlik Best Practices & Anti-Patterns (2026)
Güvenli bir Node.js uygulaması geliştirmek için belirli prensiplere uymak ve yaygın hatalardan kaçınmak gerekir. Ekibimizde, **Node.js güvenlik** denetimlerinde bu listeyi referans alıyoruz.
### ✅ DOĞRU Uygulamalar
* **Bağımlılıkları Düzenli Güncelle ve Denetle:** `npm audit` komutunu düzenli olarak çalıştırın ve bağımlılıklarınızı güncel tutun. `Snyk` veya `Dependabot` gibi araçları CI/CD sürecinize entegre edin. Node.js v20.x veya v21.x/v22.x gibi güncel sürümleri kullanın.
* **Giriş Doğrulaması ve Sanitizasyon:** Kullanıcıdan gelen tüm girişleri (URL parametreleri, sorgu dizeleri, istek gövdeleri) sunucu tarafında mutlaka doğrulayın ve sanitize edin. `express-validator` veya `joi` gibi kütüphaneler kullanın.
* **Hassas Verileri Ortam Değişkenlerinde Sakla:** API anahtarları, veritabanı kimlik bilgileri, şifreleme anahtarları gibi hassas bilgileri `.env` dosyalarında tutun ve `process.env` üzerinden erişin. Asla koduza gömmeyin.
* **Güvenli HTTP Başlıklarını Kullan:** Helmet gibi middleware'ler kullanarak `X-Content-Type-Options`, `X-Frame-Options`, `Strict-Transport-Security` ve Content Security Policy (CSP) gibi başlıkları etkinleştirin.
* **Parolaları Hash'le ve Tuzla:** Kullanıcı parolalarını asla düz metin olarak saklamayın. `bcrypt` gibi güçlü bir hash algoritması kullanarak parolaları hash'leyin ve benzersiz tuzlar (salt) kullanın.
* **HTTPS Kullanımını Zorunlu Kıl:** Tüm iletişimleri SSL/TLS (HTTPS) üzerinden şifreleyin. `Strict-Transport-Security` başlığını kullanarak tarayıcıların uygulamanızla sadece HTTPS üzerinden iletişim kurmasını sağlayın.
* **Hata Mesajlarını Genelle:** Hata mesajlarında sunucu yolu, veritabanı sorguları veya diğer hassas bilgileri ifşa etmekten kaçının. Kullanıcıya sadece genel bir hata mesajı gösterin.
* **Rate Limiting Uygula:** `express-rate-limit` gibi kütüphanelerle API endpoint'lerinize hız sınırlamaları getirerek brute-force ve DDoS saldırılarını önleyin.
* **Kimlik Doğrulama ve Yetkilendirme Mekanizmalarını Doğru Uygula:** JWT veya oturum tabanlı sistemleri doğru bir şekilde yapılandırın. Her isteğin yetkili olup olmadığını kontrol edin.
* **Güvenlik Testlerini Otomatize Et:** Statik Kod Analizi (SAST), Dinamik Uygulama Güvenlik Testi (DAST) ve Bağımlılık Güvenlik Taraması gibi güvenlik testlerini CI/CD pipeline'ınıza entegre edin. Güvenlik, 2026'da sadece bir geliştirici görevi değil, tüm ekibin sorumluluğudur.
### ❌ YANLIŞ Uygulamalar (Anti-Patterns)
* **Eski veya Zafiyetli Bağımlılıkları Kullanmak:** Bilinen güvenlik açıkları içeren eski paketleri kullanmak, uygulamanızı kolayca saldırıya açık hale getirir.
* **Kullanıcı Girişlerine Güvenmek:** Kullanıcıdan gelen her verinin temiz olduğunu varsaymak, SQL Injection, XSS gibi saldırılara davetiye çıkarır.
* **Hassas Bilgileri Koda Gömmek:** Veritabanı şifreleri, API anahtarları gibi bilgileri doğrudan kaynak koduna yazmak, kod deposunun ele geçirilmesi durumunda büyük bir risk oluşturur.
* **Güvenlik Başlıklarını İhmal Etmek:** Tarayıcı güvenlik mekanizmalarını doğru şekilde yapılandırmamak, clickjacking ve diğer istemci tarafı saldırılarına yol açar.
* **Parolaları Düz Metin Olarak Saklamak:** Bu, en temel güvenlik hatalarından biridir ve veri ihlali durumunda tüm kullanıcı parolalarının açığa çıkmasına neden olur.
* **HTTP Üzerinden Hassas İletişim:** HTTP üzerinden kullanıcı kimlik bilgileri veya hassas veriler göndermek, Man-in-the-Middle (MITM) saldırılarına karşı savunmasız bırakır.
* **Detaylı Hata Mesajları Göstermek:** Üretim ortamında detaylı hata yığınları (stack traces) veya veritabanı hataları göstermek, saldırganlara değerli bilgiler sağlar.
* **API'leri Sınırsız Bırakmak:** API endpoint'lerine hız sınırlaması getirmemek, kaynak tüketimi ve hizmet reddi saldırılarına karşı savunmasız bırakır.
* **Yetersiz Yetkilendirme Kontrolleri:** Kullanıcıların yetkisi olmayan işlemleri yapmasına izin vermek, veri manipülasyonu ve yetkisiz erişime yol açar.
## Yaygın Node.js Güvenlik Hataları ve Çözümleri (2026)
Node.js geliştirirken karşılaşabileceğiniz yaygın güvenlik hataları ve bu hataların nasıl giderileceği konusunda 10 yıllık tecrübemden faydalanarak bazı örnekler sunmak istiyorum. Ekibimizde bu sorunları çözmek için harcadığımız zaman, proaktif yaklaşımın ne kadar önemli olduğunu bir kez daha gösterdi.
### 1. Problem: `npm audit` Yüksek Riskli Zafiyet Uyarısı
* **Sebep:** Projenizdeki bir veya daha fazla bağımlılıkta bilinen bir güvenlik açığı bulunması. Bu, genellikle eski veya güncellenmemiş paketlerden kaynaklanır. 2026'da yeni zafiyetler sürekli keşfedilmektedir.
* **Çözüm:** Öncelikle `npm audit fix` komutunu deneyin. Eğer bu işe yaramazsa, zafiyetli paketi `package.json` dosyasından manuel olarak güncelleyin veya alternatif bir paket kullanmayı düşünün. `npm-check-updates` gibi araçlar, bağımlılıklarınızı kolayca güncel tutmanıza yardımcı olabilir.
```bash
# Zafiyetleri kontrol et
npm audit
# Otomatik düzeltmeleri dene
npm audit fix
# Eğer fix işe yaramazsa, bağımlılığı manuel güncelle (örneğin, express'i güncellemek için)
npm install express@latest
```
### 2. Problem: `ReferenceError: process is not defined` (Ortam Değişkenleri Hatası)
* **Sebep:** `dotenv` kütüphanesi uygulamanın başlangıcında yüklenmediği için `process.env` üzerinden ortam değişkenlerine erişilememesi veya `.env` dosyasının yanlış konumlandırılması.
* **Çözüm:** `require('dotenv').config();` satırının uygulamanızın ana dosyasının (genellikle `app.js` veya `server.js`) en üstünde olduğundan emin olun. Ayrıca `.env` dosyasının projenizin kök dizininde olduğundan emin olun.
```javascript
// app.js (en üst satır)
require('dotenv').config();
// ... diğer kodlar
const mySecret = process.env.MY_SECRET_KEY;
```
### 3. Problem: `CSRF token missing` veya `Invalid CSRF token` Hatası
* **Sebep:** `csurf` middleware'i doğru yapılandırılmamış, istemci tarafı formlarında veya AJAX isteklerinde CSRF token'ı eksik veya yanlış gönderilmiş. Özellikle SPA (Single Page Application) geliştirirken bu hatayla sık karşılaşılır.
* **Çözüm:** `csurf` middleware'inin `cookie-parser`'dan sonra yüklendiğinden emin olun. İstemci tarafında, `/csrf-token` endpoint'inden token'ı alarak her POST, PUT, DELETE isteğine `X-CSRF-Token` başlığı olarak ekleyin. Eğer bir form kullanıyorsanız, gizli bir input alanı olarak ekleyin.
```javascript
// Frontend (örnek AJAX isteği)
async function sendSecureRequest(data) {
const csrfResponse = await fetch('/csrf-token');
const { csrfToken } = await csrfResponse.json();
const response = await