ai-developer-skill-os 8.1.7 → 8.1.9

package/.agents/skills/qk-code-review/references/cross-cutting/security-review-guide.md

@@ -0,0 +1,318 @@
+# Hướng dẫn Review Bảo mật (Security Review Guide)
+
+Checklist code review tập trung vào Bảo mật dựa trên OWASP Top 10 và các best practice của ngành.
+
+## Authentication & Authorization (Xác thực & Phân quyền)
+
+### Authentication (Xác thực)
+- [ ] Passwords được băm (hash) bằng thuật toán mạnh (bcrypt, argon2)
+- [ ] Bắt buộc độ phức tạp của password (Complexity requirements)
+- [ ] Khóa tài khoản (Account lockout) sau nhiều lần đăng nhập sai
+- [ ] Luồng reset password an toàn
+- [ ] Xác thực đa yếu tố (MFA) cho các thao tác nhạy cảm
+- [ ] Session tokens là chuỗi ngẫu nhiên chuẩn mật mã học (cryptographically random)
+- [ ] Cài đặt timeout cho Session
+
+### Authorization (Phân quyền)
+- [ ] Có bước kiểm tra phân quyền (Authorization checks) trên MỌI request
+- [ ] Áp dụng nguyên tắc Đặc quyền tối thiểu (Principle of least privilege)
+- [ ] Phân quyền dựa trên Role (RBAC) được triển khai đúng cách
+- [ ] Không có lỗ hổng leo thang đặc quyền (Privilege escalation paths)
+- [ ] Kiểm tra tham chiếu đối tượng trực tiếp (IDOR prevention)
+- [ ] Các endpoint API được bảo vệ thích hợp
+
+### Bảo mật JWT
+```typescript
+// ❌ Cấu hình JWT không an toàn (Secret yếu)
+jwt.sign(payload, 'weak-secret');
+
+// ✅ Cấu hình JWT an toàn
+jwt.sign(payload, process.env.JWT_SECRET, {
+  algorithm: 'RS256',
+  expiresIn: '15m',
+  issuer: 'your-app',
+  audience: 'your-api'
+});
+
+// ❌ Không xác minh JWT đàng hoàng
+const decoded = jwt.decode(token);  // Không verify chữ ký!
+
+// ✅ Xác minh chữ ký và các claims
+const decoded = jwt.verify(token, publicKey, {
+  algorithms: ['RS256'],
+  issuer: 'your-app',
+  audience: 'your-api'
+});
+```
+
+## Input Validation (Kiểm duyệt đầu vào)
+
+### Phòng chống SQL Injection
+
+**Quy tắc số #1**: Luôn luôn sử dụng Parameterized queries (Truy vấn có tham số). Tuyệt đối không nối chuỗi input của user vào lệnh SQL.
+
+Mọi ngôn ngữ và framework lớn đều hỗ trợ:
+- Python: `cursor.execute("SELECT ...", params)` / ORM filter methods
+- Java: `PreparedStatement` / JPA `@Query` với `@Param`
+- Go: `db.Query("SELECT ...", args...)`
+- Node.js: `client.query("SELECT ...", [args])` / Prisma ORM
+- PHP: PDO prepared statements / Laravel Eloquent
+- C#: ADO.NET `SqlParameter` / Dapper / EF Core LINQ
+
+### Phòng chống XSS (Cross-Site Scripting)
+
+**Quy tắc số #1**: Phụ thuộc vào tính năng auto-escaping của Framework. Kiểm toán gắt gao mọi "lỗ hổng thoát" (escape hatch).
+
+Các framework hiện đại đều auto-escape theo mặc định:
+- React: JSX tự động escape. Kiểm toán `dangerouslySetInnerHTML`.
+- Vue: `{{ }}` tự động escape. Kiểm toán `v-html`.
+- Angular: Interpolation tự động escape. Kiểm toán `bypassSecurityTrustHtml`.
+- Svelte: `{ }` tự động escape. Kiểm toán `{@html}`.
+- C# (Razor): `@` tự động escape. Kiểm toán `@Html.Raw()`.
+
+Để phòng thủ sâu (defense-in-depth), hãy cấu hình Content Security Policy (CSP) với `script-src` dựa trên nonce.
+
+### Phòng chống CSRF (Cross-Site Request Forgery)
+
+**Triển khai CSRF Token**
+```typescript
+// ✅ Server: Sinh và xác nhận CSRF token
+import crypto from 'node:crypto';
+
+function generateCsrfToken(): string {
+  return crypto.randomBytes(32).toString('hex');
+}
+
+// Middleware: Validate token trên các request thay đổi trạng thái
+app.post('/api/data', (req, res) => {
+  const token = req.headers['x-csrf-token'];
+  const sessionToken = req.session.csrfToken;
+  if (!token || token !== sessionToken) {
+    return res.status(403).json({ error: 'Invalid CSRF token' });
+  }
+  // ...xử lý request
+});
+```
+
+**C# / ASP.NET Core**
+```csharp
+// ✅ ASP.NET Core: CSRF token (Antiforgery) được tích hợp sẵn
+builder.Services.AddAntiforgery(options => 
+{
+    options.HeaderName = "X-CSRF-TOKEN";
+});
+
+// Middleware
+app.UseAntiforgery();
+```
+
+**SameSite Cookie**
+```typescript
+// ✅ Set SameSite cookie làm hàng rào phòng thủ phụ
+res.cookie('session', sessionId, {
+  httpOnly: true,
+  secure: true,
+  sameSite: 'strict',  // Hoặc 'lax' nếu cho phép điều hướng GET
+  maxAge: 3600000,
+});
+```
+
+### Phòng chống SSRF (Server-Side Request Forgery)
+
+```typescript
+// ❌ Lỗ hổng SSRF: URL bị điều khiển bởi người dùng
+const url = req.query.url;
+const response = await fetch(url);
+
+// ✅ Validate URL trước khi fetch
+const ALLOWED_DOMAINS = ['api.internal.com'];
+
+function isSafeUrl(url: string): boolean {
+  try {
+    const parsed = new URL(url);
+    // Block IP nội bộ (localhost)
+    if (parsed.hostname === 'localhost' || parsed.hostname === '127.0.0.1') {
+      return false;
+    }
+    // Block dải mạng Private IP
+    if (parsed.hostname.match(/^10\.|^172\.(1[6-9]|2\d|3[01])\.|^192\.168\./)) {
+      return false; 
+    }
+    return ALLOWED_DOMAINS.includes(parsed.hostname);
+  } catch {
+    return false;
+  }
+}
+```
+
+### IDOR (Insecure Direct Object Reference)
+
+```csharp
+// ❌ Lỗ hổng: Không kiểm tra quyền sở hữu
+[HttpGet("api/orders/{id}")]
+public async Task<IActionResult> GetOrder(int id)
+{
+    var order = await _db.Orders.FindAsync(id); // Bất kỳ ai cũng lấy được đơn hàng của người khác
+    return Ok(order);
+}
+
+// ✅ Validate quyền sở hữu trước khi trả dữ liệu
+[HttpGet("api/orders/{id}")]
+public async Task<IActionResult> GetOrder(int id)
+{
+    var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
+    var order = await _db.Orders.FirstOrDefaultAsync(o => o.Id == id && o.UserId == userId); // Giới hạn theo Current User
+    if (order == null) return NotFound();
+    return Ok(order);
+}
+```
+
+**UUID vs Tự tăng ID (Auto-increment ID)**
+```text
+// ❌ ID tự tăng dễ bị cào dữ liệu (Enumeration)
+// GET /api/users/1, /api/users/2, /api/users/3 ...
+
+// ✅ UUID không thể đoán trước
+// GET /api/users/550e8400-e29b-41d4-a716-446655440000
+
+// ⚠️ UUID chỉ chống cào dữ liệu, KHÔNG PHẢI là chốt chặn bảo mật.
+// VẪN PHẢI kiểm tra Current User có quyền truy cập UUID đó không!
+```
+
+### Phòng chống Command Injection (Tiêm lệnh)
+
+**C#**
+```csharp
+// ❌ Lỗ hổng: Nối chuỗi vào lệnh gọi Shell
+Process.Start("cmd.exe", "/c convert " + filename + " output.png");
+
+// ✅ Truyền arguments tách biệt rõ ràng
+var startInfo = new ProcessStartInfo
+{
+    FileName = "convert",
+    Arguments = $"{filename} output.png" // Vẫn có rủi ro, cần validate input
+};
+Process.Start(startInfo);
+
+// ❌ CỰC KỲ NGUY HIỂM: Truyền input của user thẳng vào Shell
+Process.Start("sh", "-c \"echo " + userInput + "\""); 
+```
+
+## Data Protection (Bảo vệ Dữ liệu)
+
+### Xử lý Dữ liệu Nhạy cảm
+- [ ] Không lưu trữ secret (password, API keys) trong source code.
+- [ ] Secrets phải được lưu ở Environment Variables hoặc Secret Manager (Azure Key Vault, AWS Secrets Manager).
+- [ ] Mã hóa dữ liệu nhạy cảm khi nghỉ (Encrypted at rest).
+- [ ] Mã hóa dữ liệu khi truyền tải (HTTPS / Encrypted in transit).
+- [ ] PII (Dữ liệu cá nhân) được xử lý theo chuẩn (GDPR, v.v.).
+- [ ] KHÔNG log dữ liệu nhạy cảm.
+
+### Cấu hình Bảo mật
+```yaml
+# ❌ Lưu lộ liễu trong file cấu hình
+database:
+  password: "super-secret-password"
+
+# ✅ Trỏ tới biến môi trường
+database:
+  password: ${DATABASE_PASSWORD}
+```
+
+### Thông báo lỗi (Error Messages)
+```csharp
+// ❌ Làm lộ cấu trúc hệ thống qua Exception
+catch (Exception ex) {
+  return StatusCode(500, new {
+    error = ex.StackTrace,  // Lộ mã nguồn bên trong
+    query = sqlQuery        // Lộ cấu trúc DB
+  });
+}
+
+// ✅ Trả về thông báo lỗi chung chung (Generic)
+catch (Exception ex) {
+  _logger.LogError(ex, "Lỗi Database");  // Log lại ở nội bộ
+  return StatusCode(500, new {
+    error = "Đã xảy ra lỗi không xác định"
+  });
+}
+```
+
+## Bảo mật API
+
+### Rate Limiting (Giới hạn tốc độ)
+- [ ] Áp dụng Rate limiting cho tất cả public endpoint.
+- [ ] Giới hạn gắt gao hơn cho các endpoint Login / Đăng ký.
+- [ ] Xử lý khéo léo (Graceful handling) khi người dùng vượt quá Limit.
+
+### Cấu hình CORS
+```csharp
+// ❌ CORS mở toang cửa cho tất cả (*)
+app.UseCors(builder => builder.AllowAnyOrigin().AllowAnyMethod());
+
+// ✅ CORS giới hạn chặt chẽ
+app.UseCors(builder => builder
+    .WithOrigins("https://your-app.com")
+    .WithMethods("GET", "POST")
+    .AllowCredentials());
+```
+
+## Mật mã học (Cryptography)
+
+### Best Practice
+- [ ] Sử dụng các thuật toán chuẩn (AES-256, RSA-2048+).
+- [ ] KHÔNG TỰ CHẾ thuật toán mã hóa (Not implementing custom cryptography).
+- [ ] Dùng hàm sinh số ngẫu nhiên an toàn (Cryptographically secure random).
+- [ ] Quản lý và luân chuyển Key (Key rotation) đàng hoàng.
+
+### Sai lầm phổ biến
+```csharp
+// ❌ Sinh token ngẫu nhiên yếu (Dùng Random class)
+var token = new Random().Next().ToString();
+
+// ✅ Sinh ngẫu nhiên bảo mật (Cryptographically secure)
+using var rng = RandomNumberGenerator.Create();
+var bytes = new byte[32];
+rng.GetBytes(bytes);
+var token = Convert.ToBase64String(bytes);
+
+// ❌ Dùng MD5/SHA1 để băm mật khẩu
+var hash = MD5.HashData(Encoding.UTF8.GetBytes(password));
+
+// ✅ Dùng BCrypt hoặc Argon2
+var hash = BCrypt.Net.BCrypt.HashPassword(password);
+```
+
+## Dependency Security (Bảo mật Thư viện phụ thuộc)
+
+### Checklist
+- [ ] Chỉ dùng thư viện từ nguồn uy tín (Trusted sources).
+- [ ] Quét lỗ hổng định kỳ (`dotnet list package --vulnerable`).
+- [ ] Cập nhật thư viện thường xuyên.
+- [ ] Xác minh giấy phép mã nguồn mở (License compliance).
+
+## Logging & Monitoring
+
+### Ghi Log An toàn
+- [ ] Không log Password, Token, PII.
+- [ ] Bảo vệ file log khỏi bị giả mạo.
+- [ ] Log lại các sự kiện an ninh mạng (Đăng nhập sai, đổi quyền).
+- [ ] Phòng chống Log Injection.
+
+```csharp
+// ❌ Log lộ thông tin nhạy cảm
+_logger.LogInformation($"User login: {email}, password: {password}");
+
+// ✅ Log an toàn
+_logger.LogInformation("Thử đăng nhập", new { email, success = true });
+```
+
+## Security Review Severity Levels (Mức độ Nghiêm trọng)
+
+| Severity | Mô tả | Hành động |
+|----------|-------------|--------|
+| 🔴 **Critical** | Có thể bị khai thác ngay lập tức, nguy cơ lộ data | Block merge, sửa NGAY LẬP TỨC |
+| 🟡 **High** | Lỗ hổng lớn, nhưng cần điều kiện cụ thể mới khai thác được | Block merge, sửa trước khi release |
+| 🟡 **Medium** | Rủi ro vừa phải | Nên sửa, có thể merge và track lại |
+| 🟢 **Low** | Vấn đề nhỏ, vi phạm best practice | Nên sửa nếu có thể, không block |
+| 💡 **Info** | Đề xuất tối ưu | Không bắt buộc |

package/.agents/skills/qk-code-review/references/cross-cutting/sql-injection-prevention.md

@@ -0,0 +1,308 @@
+# SQL Injection Prevention Guide
+
+Language-agnostic SQL injection prevention strategies with cross-language code examples.
+
+> **Related**: [Security Review Guide](../security-review-guide.md) for comprehensive security checklist and decision framework.
+
+## Attack Types
+
+SQL injection (SQLi) is ranked #3 in the OWASP Top 10 (2021). Three common variants:
+
+| Type | Description | Risk |
+|------|-------------|------|
+| **Classic (In-band)** | Attacker receives results directly in the HTTP response | Data exfiltration, authentication bypass |
+| **Blind (Boolean/Time-based)** | Attacker infers data from response differences or timing | Slower but still viable for data extraction |
+| **Out-of-band** | Attacker uses DNS/HTTP callbacks to exfiltrate data | Less common but harder to detect |
+
+## Universal Prevention Strategy
+
+1. **Parameterized queries** — always (the #1 defense)
+2. **ORM safe usage** — understand what your ORM escapes
+3. **Input validation** — whitelist over blacklist
+4. **Least privilege** — database user with minimal permissions
+5. **WAF** — web application firewall as defense-in-depth
+
+---
+
+## Cross-Language Examples
+
+### Python
+
+```python
+# ❌ Vulnerable: string formatting
+query = f"SELECT * FROM users WHERE id = {user_id}"
+cursor.execute(query)
+
+# ❌ Vulnerable: % formatting
+cursor.execute("SELECT * FROM users WHERE id = %s" % user_id)
+
+# ✅ Parameterized (DB-API)
+cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))
+
+# ✅ SQLAlchemy ORM
+User.query.filter(User.id == user_id).all()
+
+# ❌ SQLAlchemy raw SQL with string interpolation
+session.execute(text(f"SELECT * FROM users WHERE id = {user_id}"))
+
+# ✅ SQLAlchemy raw SQL with bound parameters
+session.execute(text("SELECT * FROM users WHERE id = :id"), {"id": user_id})
+
+# ✅ Django ORM
+User.objects.filter(id=user_id)
+
+# ❌ Django extra() with string interpolation
+User.objects.extra(where=[f"username = '{username}'"])
+
+# ✅ Django raw() with parameters
+User.objects.raw("SELECT * FROM users WHERE id = %s", [user_id])
+```
+
+### Java
+
+```java
+// ❌ Vulnerable: string concatenation
+String query = "SELECT * FROM users WHERE id = " + userId;
+Statement stmt = connection.createStatement();
+ResultSet rs = stmt.executeQuery(query);
+
+// ✅ JDBC PreparedStatement
+String query = "SELECT * FROM users WHERE id = ?";
+PreparedStatement stmt = connection.prepareStatement(query);
+stmt.setLong(1, userId);
+ResultSet rs = stmt.executeQuery();
+
+// ✅ JPA parameter binding
+@Query("SELECT u FROM User u WHERE u.id = :id")
+User findById(@Param("id") Long id);
+
+// ✅ Spring Data JPA method naming
+User findById(Long id);
+
+// ❌ JPA native query with string concatenation
+entityManager.createNativeQuery(
+    "SELECT * FROM users WHERE name = '" + name + "'"
+);
+
+// ✅ JPA native query with parameter binding
+Query query = entityManager.createNativeQuery(
+    "SELECT * FROM users WHERE name = :name"
+);
+query.setParameter("name", name);
+```
+
+### Go
+
+```go
+// ❌ Vulnerable: fmt.Sprintf
+query := fmt.Sprintf("SELECT * FROM users WHERE id = %s", userID)
+rows, err := db.Query(query)
+
+// ✅ database/sql parameterized
+rows, err := db.Query("SELECT * FROM users WHERE id = ?", userID)
+
+// ✅ Named parameters (sqlx)
+rows, err := db.NamedQuery(
+    "SELECT * FROM users WHERE id = :id",
+    map[string]interface{}{"id": userID},
+)
+
+// ⚠️ Dynamic identifiers (table/column names) can't use placeholders
+// Must validate against whitelist
+var allowedColumns = map[string]bool{
+    "id": true, "name": true, "email": true, "created_at": true,
+}
+
+func queryWithOrder(db *sql.DB, orderBy string) (*sql.Rows, error) {
+    if !allowedColumns[orderBy] {
+        return nil, fmt.Errorf("invalid column: %s", orderBy)
+    }
+    return db.Query(
+        fmt.Sprintf("SELECT * FROM users ORDER BY %s", orderBy),
+    )
+}
+```
+
+### Node.js
+
+```typescript
+// ❌ Vulnerable: template literal
+const query = `SELECT * FROM users WHERE id = ${userId}`;
+const result = await client.query(query);
+
+// ✅ pg parameterized ($1, $2, ...)
+const result = await client.query(
+    "SELECT * FROM users WHERE id = $1",
+    [userId]
+);
+
+// ✅ Prisma ORM (parameterized by default)
+const user = await prisma.user.findUnique({
+    where: { id: userId },
+});
+
+// ❌ Prisma $queryRawUnsafe with string interpolation
+await prisma.$queryRawUnsafe(
+    `SELECT * FROM users WHERE id = ${userId}`
+);
+
+// ✅ Prisma $queryRaw with tagged template (safe)
+await prisma.$queryRaw`
+    SELECT * FROM users WHERE id = ${userId}
+`;
+```
+
+### PHP
+
+```php
+<?php
+
+// ❌ Vulnerable: string concatenation
+$sql = "SELECT * FROM users WHERE email = '" . $_GET['email'] . "'";
+$user = $pdo->query($sql)->fetch();
+
+// ✅ PDO prepared statements
+$stmt = $pdo->prepare("SELECT * FROM users WHERE email = :email");
+$stmt->execute(['email' => $email]);
+$user = $stmt->fetch(PDO::FETCH_ASSOC);
+
+// ✅ PDO positional placeholders
+$stmt = $pdo->prepare("SELECT * FROM users WHERE id = ?");
+$stmt->execute([$id]);
+
+// ❌ mysqli with string interpolation
+$result = mysqli_query($conn,
+    "SELECT * FROM users WHERE id = " . $id
+);
+
+// ✅ mysqli prepared statements
+$stmt = mysqli_prepare($conn, "SELECT * FROM users WHERE id = ?");
+mysqli_stmt_bind_param($stmt, "i", $id);
+mysqli_stmt_execute($stmt);
+
+// ✅ Laravel Eloquent ORM
+User::where('id', $id)->first();
+
+// ❌ Laravel DB::raw with interpolation
+DB::select(DB::raw("SELECT * FROM users WHERE id = {$id}"));
+
+// ✅ Laravel parameterized raw
+DB::select("SELECT * FROM users WHERE id = ?", [$id]);
+```
+
+### C# / .NET
+
+```csharp
+// ❌ Vulnerable: string concatenation
+var query = $"SELECT * FROM Users WHERE Id = {userId}";
+using var cmd = new SqlCommand(query, connection);
+var reader = cmd.ExecuteReader();
+
+// ✅ ADO.NET parameterized
+var query = "SELECT * FROM Users WHERE Id = @Id";
+using var cmd = new SqlCommand(query, connection);
+cmd.Parameters.AddWithValue("@Id", userId);
+
+// ✅ Dapper parameterized
+var users = connection.Query<User>(
+    "SELECT * FROM Users WHERE Id = @Id",
+    new { Id = userId }
+);
+
+// ❌ Dapper with string interpolation
+var users = connection.Query<User>(
+    $"SELECT * FROM Users WHERE Id = {userId}"
+);
+
+// ✅ EF Core (parameterized by default)
+var user = await context.Users
+    .Where(u => u.Id == userId)
+    .FirstOrDefaultAsync();
+
+// ❌ EF Core FromSqlRaw with interpolation
+var users = context.Users
+    .FromSqlRaw($"SELECT * FROM Users WHERE Id = {userId}")
+    .ToList();
+
+// ✅ EF Core FromSql with FormattableString (parameterized)
+var users = context.Users
+    .FromSql($"SELECT * FROM Users WHERE Id = {userId}")
+    .ToList();
+```
+
+---
+
+## ORM Unsafe Usage Patterns
+
+ORMs do NOT automatically prevent SQL injection in all cases:
+
+```python
+# ❌ SQLAlchemy: text() with f-string
+session.execute(text(f"SELECT * FROM users WHERE id = {user_id}"))
+
+# ❌ Django: extra() / RawSQL() with string interpolation
+User.objects.extra(where=[f"username = '{username}'"])
+User.objects.annotate(
+    val=RawSQL(f"SELECT col FROM other WHERE id = {user_id}")
+)
+
+# ❌ JPA: createNativeQuery with string concatenation
+entityManager.createNativeQuery("SELECT * FROM users WHERE name = '" + name + "'")
+
+# ❌ EF Core: FromSqlRaw with string interpolation
+context.Users.FromSqlRaw($"SELECT * FROM Users WHERE Id = {userId}")
+```
+
+**Rule**: Every ORM has a "raw SQL" escape hatch. String interpolation in that escape hatch = SQL injection. Always use the ORM's parameter binding mechanism.
+
+---
+
+## Dynamic Identifiers (Table/Column Names)
+
+Placeholders can only bind **values**, not table names, column names, or SQL keywords. For dynamic identifiers:
+
+```python
+# ✅ Whitelist validation
+ALLOWED_COLUMNS = {"id", "name", "email", "created_at"}
+ALLOWED_DIRECTIONS = {"ASC", "DESC"}
+
+def get_users(order_by: str, direction: str) -> list[User]:
+    if order_by not in ALLOWED_COLUMNS:
+        raise ValueError(f"Invalid column: {order_by}")
+    if direction.upper() not in ALLOWED_DIRECTIONS:
+        raise ValueError(f"Invalid direction: {direction}")
+
+    return User.objects.order_by(
+        f"{'-' if direction.upper() == 'DESC' else ''}{order_by}"
+    )
+```
+
+---
+
+## Detection & Testing
+
+```bash
+# Automated scanning
+sqlmap -u "https://example.com/api/users?id=1" --batch
+
+# Static analysis (Python)
+bandit -r src/ -f custom
+
+# Static analysis (Java)
+spotbugs -textui build/classes
+
+# Code review keywords to search for
+grep -rn "f\".*SELECT\|f'.*SELECT\|fmt.Sprintf.*SELECT\|format.*SELECT" src/
+grep -rn "query.*\+.*\|query.*&\|query.*concat" src/
+```
+
+---
+
+## Review Checklist
+
+- [ ] All SQL queries use parameterized queries (no string interpolation)
+- [ ] ORM raw SQL methods use bound parameters, not string formatting
+- [ ] Dynamic identifiers (table/column names) validated against whitelist
+- [ ] Database user has least privilege (no DROP/ALTER for app user)
+- [ ] No SQL queries constructed from user input without parameterization
+- [ ] Static analysis tools (Bandit, SpotBugs, SonarQube) run in CI