Web Bị Hack Qua SQL và Command Injection - Giải Pháp Bảo Mật

// User đăng ký với username: admin'--
// Lưu vào DB: INSERT INTO users (username) VALUES ('admin'--')

// Sau đó, khi query:
// SELECT * FROM posts WHERE author = 'admin'--'
// Comment out phần sau, bypass logic

// ✅ AN TOÀN
const [rows] = await connection.execute(
  'SELECT * FROM products WHERE id = ?',
  [productId]
);

// Sequelize (Node.js)
const product = await Product.findOne({
  where: { id: productId }
});

// Sequelize tự động sử dụng Prepared Statement
// Query thực tế: SELECT * FROM products WHERE id = ? [productId]

// Validate productId phải là số
function getProduct(productId) {
  // Kiểm tra kiểu dữ liệu
  if (!/^\d+$/.test(productId)) {
    throw new Error('Invalid product ID');
  }

  // Chuyển sang số nguyên
  const safeId = parseInt(productId, 10);

  // Dùng Prepared Statement
  return db.query('SELECT * FROM products WHERE id = ?', [safeId]);
}

// ❌ MÃ NGUY HIỂM
const express = require('express');
const { exec } = require('child_process');

app.get('/ping', (req, res) => {
  const host = req.query.host;

  // Ghép chuỗi trực tiếp - RẤT NGUY HIỂM!
  exec(`ping -c 4 ${host}`, (error, stdout) => {
    res.send(stdout);
  });
});

// ❌ NGUY HIỂM
exec(`ping ${userInput}`);

// ✅ AN TOÀN - Dùng thư viện thay vì shell
const ping = require('ping');
const result = await ping.promise.probe(userInput);

const { spawn } = require('child_process');

// ✅ AN TOÀN - Arguments được tách biệt
const ping = spawn('ping', ['-c', '4', userInput]);

ping.stdout.on('data', (data) => {
  console.log(data.toString());
});

// userInput = "google.com; rm -rf /" sẽ KHÔNG thực thi rm
// Vì spawn coi toàn bộ làm 1 argument cho ping

function isValidHostname(host) {
  // Chỉ cho phép: chữ cái, số, dấu chấm, dấu gạch
  const regex = /^[a-zA-Z0-9.-]+$/;
  return regex.test(host);
}

app.get('/ping', (req, res) => {
  const host = req.query.host;

  // Validate trước khi dùng
  if (!isValidHostname(host)) {
    return res.status(400).send('Invalid hostname');
  }

  const ping = spawn('ping', ['-c', '4', host]);
  // ...
});

// Dùng Docker container với quyền hạn chế
// Dockerfile:
// USER nobody
// RUN chmod -R 755 /app

// Nếu bị tấn công, hacker chỉ chiếm được container
// Không ảnh hưởng host system

// ❌ NGUY HIỂM
child_process.exec(cmd);
child_process.execSync(cmd);

// ✅ AN TOÀN (nếu dùng đúng cách)
child_process.spawn(command, args);
child_process.spawnSync(command, args);

// ❌ MÃ NGUY HIỂM
app.get('/search', (req, res) => {
  const query = req.query.q;
  res.send(`<h1>Search results for: ${query}</h1>`);
});

// ❌ NGUY HIỂM - Lưu comment trực tiếp
app.post('/comment', async (req, res) => {
  const comment = req.body.comment;
  await db.query('INSERT INTO comments (text) VALUES (?)', [comment]);
});

// Hiển thị comment
app.get('/posts', async (req, res) => {
  const comments = await db.query('SELECT * FROM comments');
  const html = comments.map(c => `<p>${c.text}</p>`).join('');
  res.send(html);
});

// ❌ NGUY HIỂM
const hash = location.hash.substring(1);
document.getElementById('welcome').innerHTML = 'Welcome ' + hash;

// ✅ AN TOÀN - Encode HTML entities
function escapeHtml(text) {
  const map = {
    '&': '&',
    '<': '&lt;',
    '>': '&gt;',
    '"': '&quot;',
    "'": '&#039;'
  };
  return text.replace(/[&<>"']/g, m => map[m]);
}

app.get('/search', (req, res) => {
  const query = escapeHtml(req.query.q);
  res.send(`<h1>Search results for: ${query}</h1>`);
});

// Thiết lập CSP header
app.use((req, res, next) => {
  res.setHeader(
    'Content-Security-Policy',
    "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'"
  );
  next();
});

// Khi cần cho phép HTML (ví dụ: editor)
import DOMPurify from 'dompurify';

const dirty = req.body.content; // Có thể chứa HTML
const clean = DOMPurify.sanitize(dirty);

// DOMPurify loại bỏ script, onerror, v.v. nhưng giữ lại HTML an toàn
await db.query('INSERT INTO posts (content) VALUES (?)', [clean]);

// Ngăn JavaScript đọc cookie
res.cookie('sessionId', sessionId, {
  httpOnly: true,  // JavaScript không đọc được
  secure: true,    // Chỉ gửi qua HTTPS
  sameSite: 'strict'
});

// HTML context
`<div>${escapeHtml(data)}</div>` // ✅

// JavaScript context - cần JSON.stringify
`<script>var data = ${JSON.stringify(data)};</script>` // ✅

// URL context - cần encodeURIComponent
`<a href="/search?q=${encodeURIComponent(data)}">` // ✅

// CSS context - TRÁNH nếu có thể
`<style>.class { color: ${data}; }</style>` // ❌ Rất khó escape đúng

// ❌ MÃ NGUY HIỂM
app.post('/upload', upload.single('avatar'), (req, res) => {
  const file = req.file;

  // Chỉ check extension - Dễ bypass!
  if (!file.originalname.endsWith('.jpg')) {
    return res.status(400).send('Only JPG allowed');
  }

  // Lưu với tên gốc - NGUY HIỂM!
  const uploadPath = './uploads/' + file.originalname;
  fs.writeFileSync(uploadPath, file.buffer);

  res.send('Upload success!');
});

const fileType = require('file-type');

app.post('/upload', upload.single('avatar'), async (req, res) => {
  const file = req.file;

  // ✅ Kiểm tra MIME type thực (đọc magic bytes)
  const type = await fileType.fromBuffer(file.buffer);

  if (!type || !['image/jpeg', 'image/png'].includes(type.mime)) {
    return res.status(400).send('Only JPG/PNG allowed');
  }

  // ...
});

const crypto = require('crypto');
const path = require('path');

app.post('/upload', upload.single('avatar'), async (req, res) => {
  const file = req.file;

  // ✅ Tạo tên file random
  const randomName = crypto.randomBytes(16).toString('hex');
  const ext = path.extname(file.originalname);
  const safeFilename = randomName + ext;

  // ✅ Lưu NGOÀI thư mục public
  const uploadPath = '/var/uploads/' + safeFilename; // Không truy cập trực tiếp qua web
  fs.writeFileSync(uploadPath, file.buffer);

  // ✅ Lưu reference vào database
  await db.query('INSERT INTO files (filename, path) VALUES (?, ?)',
    [safeFilename, uploadPath]);

  res.json({ fileId: insertId });
});

// ✅ Serve file qua endpoint riêng
app.get('/file/:id', async (req, res) => {
  const file = await db.query('SELECT * FROM files WHERE id = ?', [req.params.id]);

  // Set Content-Type để trình duyệt không thực thi
  res.setHeader('Content-Type', 'image/jpeg');
  res.setHeader('Content-Disposition', 'inline'); // Hoặc 'attachment' để download

  res.sendFile(file.path);
});

const multer = require('multer');

const upload = multer({
  limits: {
    fileSize: 5 * 1024 * 1024 // 5MB
  },
  fileFilter: (req, file, cb) => {
    // Whitelist extension
    const allowedExts = ['.jpg', '.jpeg', '.png', '.gif'];
    const ext = path.extname(file.originalname).toLowerCase();

    if (!allowedExts.includes(ext)) {
      return cb(new Error('Invalid file type'));
    }

    cb(null, true);
  }
});

const ClamScan = require('clamscan');

const clamscan = await new ClamScan().init();

app.post('/upload', upload.single('file'), async (req, res) => {
  const file = req.file;

  // ✅ Quét virus
  const { isInfected, viruses } = await clamscan.scanFile(file.path);

  if (isInfected) {
    fs.unlinkSync(file.path); // Xóa file độc hại
    return res.status(400).send(`Virus detected: ${viruses}`);
  }

  // ...
});

// ✅ Upload lên S3/GCS thay vì server
const AWS = require('aws-sdk');
const s3 = new AWS.S3();

app.post('/upload', upload.single('avatar'), async (req, res) => {
  const file = req.file;

  const params = {
    Bucket: 'my-bucket',
    Key: `avatars/${randomName}`,
    Body: file.buffer,
    ContentType: file.mimetype,
    ACL: 'public-read'
  };

  await s3.upload(params).promise();

  // File được lưu trên S3, không thực thi được trên server
});

// Bypass bằng shell.php.jpg, shell.PhP, shell.php%00.jpg
if (filename.endsWith('.jpg')) { }

// Hacker có thể giả mạo header
if (req.file.mimetype === 'image/jpeg') { } // Không an toàn!

// Path traversal: ../../etc/passwd, shell.php
const path = './uploads/' + req.file.originalname;