@sun-asterisk/sunlint 1.3.1 → 1.3.3

package/rules/security/S035_path_session_cookies/symbol-based-analyzer.js

@@ -0,0 +1,373 @@
+/**
+ * S035 Symbol-Based Analyzer - Set Path attribute for Session Cookies
+ * Uses TypeScript compiler API for semantic analysis
+ */
+
+const { SyntaxKind } = require("typescript");
+
+class S035SymbolBasedAnalyzer {
+  constructor(semanticEngine = null) {
+    this.semanticEngine = semanticEngine;
+    this.ruleId = "S035";
+    this.ruleName = "Set Path attribute for Session Cookies";
+    this.category = "security";
+    this.violations = [];
+
+    // Session cookie indicators
+    this.sessionIndicators = [
+      "session",
+      "sessionid",
+      "sessid",
+      "jsessionid",
+      "phpsessid",
+      "asp.net_sessionid",
+      "connect.sid",
+      "auth",
+      "token",
+      "jwt",
+      "csrf",
+      "refresh",
+      "user",
+      "login",
+      "authentication",
+      "session_id",
+      "sid",
+      "auth_token",
+      "userid",
+      "user_id",
+    ];
+
+    // Cookie methods that need security checking
+    this.cookieMethods = [
+      "setCookie",
+      "cookie",
+      "set",
+      "append",
+      "session",
+      "setHeader",
+      "writeHead",
+    ];
+
+    // Acceptable Path values - should be specific paths, not just "/"
+    this.acceptableValues = [
+      "/app",
+      "/admin",
+      "/api",
+      "/auth",
+      "/user",
+      "/secure",
+      "/dashboard",
+      "/login",
+    ];
+
+    // Root path "/" is acceptable but not recommended for security
+    this.rootPath = "/";
+  }
+
+  /**
+   * Initialize analyzer with semantic engine
+   */
+  async initialize(semanticEngine) {
+    this.semanticEngine = semanticEngine;
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [S035] Symbol analyzer initialized`);
+    }
+  }
+
+  /**
+   * Main analysis method for source file
+   */
+  async analyze(sourceFile, filePath) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔍 [S035] Symbol analysis starting for: ${filePath}`);
+    }
+
+    this.violations = [];
+    this.currentFile = sourceFile;
+    this.currentFilePath = filePath;
+
+    this.visitNode(sourceFile);
+
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(
+        `🔍 [S035] Symbol analysis completed: ${this.violations.length} violations`
+      );
+    }
+
+    return this.violations;
+  }
+
+  visitNode(node) {
+    // Check for res.cookie() calls
+    if (this.isCallExpression(node)) {
+      this.checkCookieCall(node);
+      this.checkSetHeaderCall(node);
+    }
+
+    // Check for session middleware configuration
+    if (this.isSessionMiddleware(node)) {
+      this.checkSessionMiddleware(node);
+    }
+
+    // Recursively visit child nodes
+    node.forEachChild((child) => this.visitNode(child));
+  }
+
+  isCallExpression(node) {
+    return node.getKind() === SyntaxKind.CallExpression;
+  }
+
+  isSessionMiddleware(node) {
+    if (node.getKind() !== SyntaxKind.CallExpression) {
+      return false;
+    }
+
+    const expression = node.getExpression();
+    const text = expression.getText();
+
+    return text === "session" || text.includes("session(");
+  }
+
+  checkCookieCall(node) {
+    const expression = node.getExpression();
+
+    // Check if it's res.cookie() call
+    if (expression.getKind() === SyntaxKind.PropertyAccessExpression) {
+      const propertyAccess = expression;
+      const property = propertyAccess.getName();
+
+      if (property === "cookie") {
+        const args = node.getArguments();
+        if (args.length >= 1) {
+          const cookieName = this.extractStringValue(args[0]);
+
+          if (cookieName && this.isSessionCookie(cookieName)) {
+            this.checkCookieOptions(node, args, cookieName);
+          }
+        }
+      }
+    }
+  }
+
+  checkSetHeaderCall(node) {
+    const expression = node.getExpression();
+
+    if (expression.getKind() === SyntaxKind.PropertyAccessExpression) {
+      const propertyAccess = expression;
+      const property = propertyAccess.getName();
+
+      if (property === "setHeader") {
+        const args = node.getArguments();
+        if (args.length >= 2) {
+          const headerName = this.extractStringValue(args[0]);
+
+          if (headerName && headerName.toLowerCase() === "set-cookie") {
+            const headerValue = this.extractStringValue(args[1]);
+            if (headerValue) {
+              this.checkSetCookieHeader(node, headerValue);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  checkSessionMiddleware(node) {
+    const args = node.getArguments();
+    if (
+      args.length >= 1 &&
+      args[0].getKind() === SyntaxKind.ObjectLiteralExpression
+    ) {
+      const config = args[0];
+      const nameProperty = this.findProperty(config, "name");
+      const cookieProperty = this.findProperty(config, "cookie");
+
+      if (nameProperty) {
+        const nameValue = this.extractStringValue(
+          nameProperty.getInitializer()
+        );
+        if (nameValue && this.isSessionCookie(nameValue)) {
+          // Check if cookie configuration has path
+          if (
+            cookieProperty &&
+            cookieProperty.getInitializer().getKind() ===
+              SyntaxKind.ObjectLiteralExpression
+          ) {
+            const cookieConfig = cookieProperty.getInitializer();
+            this.checkCookieConfigForPath(node, cookieConfig, nameValue);
+          } else {
+            this.addViolation(
+              node,
+              `Session middleware cookie "${nameValue}" should specify Path attribute to limit access scope`
+            );
+          }
+        }
+      }
+    }
+  }
+
+  checkCookieOptions(node, args, cookieName) {
+    if (
+      args.length >= 3 &&
+      args[2].getKind() === SyntaxKind.ObjectLiteralExpression
+    ) {
+      const options = args[2];
+      this.checkCookieConfigForPath(node, options, cookieName);
+    } else {
+      this.addViolation(
+        node,
+        `Session cookie "${cookieName}" should specify Path attribute to limit access scope`
+      );
+    }
+  }
+
+  checkCookieConfigForPath(node, config, cookieName) {
+    const pathProperty = this.findProperty(config, "path");
+
+    if (!pathProperty) {
+      this.addViolation(
+        node,
+        `Session cookie "${cookieName}" should specify Path attribute to limit access scope`
+      );
+      return;
+    }
+
+    const pathValue = this.extractStringValue(pathProperty.getInitializer());
+    if (!pathValue) {
+      this.addViolation(
+        node,
+        `Session cookie "${cookieName}" should have a valid Path attribute value`
+      );
+      return;
+    }
+
+    // Check if path is too broad (root path "/")
+    if (pathValue === this.rootPath) {
+      this.addViolation(
+        node,
+        `Session cookie "${cookieName}" uses root path "/", consider using a more specific path to limit access scope`
+      );
+    }
+  }
+
+  checkSetCookieHeader(node, headerValue) {
+    // Extract cookie name from Set-Cookie header
+    const cookieMatch = headerValue.match(/^([^=]+)=/);
+    if (!cookieMatch) return;
+
+    const cookieName = cookieMatch[1].trim();
+    if (!this.isSessionCookie(cookieName)) return;
+
+    // Check if Path attribute is present
+    const pathMatch = headerValue.match(/Path=([^;\\s]*)/i);
+    if (!pathMatch) {
+      this.addViolation(
+        node,
+        `Session cookie "${cookieName}" in Set-Cookie header should specify Path attribute`
+      );
+      return;
+    }
+
+    const pathValue = pathMatch[1];
+    if (pathValue === this.rootPath) {
+      this.addViolation(
+        node,
+        `Session cookie "${cookieName}" uses root path "/", consider using a more specific path`
+      );
+    }
+  }
+
+  isSessionCookie(cookieName) {
+    const lowerName = cookieName.toLowerCase();
+    return this.sessionIndicators.some((indicator) =>
+      lowerName.includes(indicator.toLowerCase())
+    );
+  }
+
+  extractStringValue(node) {
+    if (!node) return null;
+
+    const kind = node.getKind();
+
+    if (kind === SyntaxKind.StringLiteral) {
+      return node.getLiteralValue();
+    }
+
+    if (kind === SyntaxKind.NoSubstitutionTemplateLiteral) {
+      return node.getLiteralValue();
+    }
+
+    return null;
+  }
+
+  findProperty(objectLiteral, propertyName) {
+    const properties = objectLiteral.getProperties();
+
+    for (const property of properties) {
+      if (property.getKind() === SyntaxKind.PropertyAssignment) {
+        const name = property.getName();
+        if (name === propertyName) {
+          return property;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  addViolation(node, message) {
+    const start = node.getStart();
+    const sourceFile = node.getSourceFile();
+    const lineAndColumn = sourceFile.getLineAndColumnAtPos(start);
+
+    // Debug output to understand position issues
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(
+        `🔍 [S035] Violation at node kind: ${node.getKindName()}, text: "${node
+          .getText()
+          .substring(0, 50)}..."`
+      );
+      console.log(
+        `🔍 [S035] Position: line ${lineAndColumn.line + 1}, column ${
+          lineAndColumn.column + 1
+        }`
+      );
+    }
+
+    // Fix line number calculation - ts-morph may have offset issues
+    // Use actual line calculation based on source file text
+    const sourceText = sourceFile.getFullText();
+    const actualLine = this.calculateActualLine(sourceText, start);
+
+    this.violations.push({
+      ruleId: this.ruleId,
+      ruleName: this.ruleName,
+      severity: "warning",
+      message: message,
+      line: actualLine,
+      column: lineAndColumn.column + 1,
+      source: "symbol-based",
+    });
+
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔍 [S035] Added violation: ${message}`);
+    }
+  }
+
+  calculateActualLine(sourceText, position) {
+    // Count newlines up to the position to get accurate line number
+    let lineCount = 1;
+    for (let i = 0; i < position; i++) {
+      if (sourceText[i] === "\n") {
+        lineCount++;
+      }
+    }
+    return lineCount;
+  }
+
+  cleanup() {
+    this.violations = [];
+  }
+}
+
+module.exports = S035SymbolBasedAnalyzer;

package/rules/security/S048_no_current_password_in_reset/README.md

@@ -0,0 +1,222 @@
+# S048 - No Current Password in Reset Process
+
+## Mô tả
+
+Rule này kiểm tra xem các quy trình đặt lại mật khẩu có yêu cầu mật khẩu hiện tại hay không. Việc yêu cầu mật khẩu hiện tại trong quy trình reset mật khẩu vi phạm nguyên tắc bảo mật và làm mất đi mục đích của tính năng "quên mật khẩu".
+
+## Mục tiêu
+
+- Ngăn chặn việc yêu cầu mật khẩu hiện tại trong quy trình reset mật khẩu
+- Đảm bảo quy trình reset mật khẩu được thiết kế an toàn và hợp lý
+- Tuân thủ OWASP A04:2021 - Insecure Design và CWE-640
+
+## Chi tiết Rule
+
+### Phát hiện lỗi khi:
+
+1. **API endpoints yêu cầu current password trong reset**:
+   ```javascript
+   app.post('/reset-password', (req, res) => {
+     const { currentPassword, newPassword } = req.body; // ❌ Yêu cầu mật khẩu hiện tại
+     if (!validateCurrentPassword(currentPassword)) {
+       return res.status(400).json({ error: 'Current password incorrect' });
+     }
+   });
+   ```
+
+2. **Form validation yêu cầu current password**:
+   ```typescript
+   const resetPasswordSchema = {
+     currentPassword: { type: String, required: true }, // ❌ Bắt buộc mật khẩu hiện tại
+     newPassword: { type: String, required: true }
+   };
+   ```
+
+3. **Service methods kiểm tra current password trong reset**:
+   ```javascript
+   async resetPassword(userId, currentPassword, newPassword) {
+     const user = await User.findById(userId);
+     if (!user.validatePassword(currentPassword)) { // ❌ Validate mật khẩu hiện tại
+       throw new Error('Current password is incorrect');
+     }
+   }
+   ```
+
+4. **React components với current password field**:
+   ```typescript
+   function ResetPasswordForm() {
+     return (
+       <form>
+         <input name="currentPassword" required /> {/* ❌ Trường mật khẩu hiện tại */}
+         <input name="newPassword" required />
+       </form>
+     );
+   }
+   ```
+
+### Cách khắc phục:
+
+1. **Sử dụng token-based reset**:
+   ```javascript
+   app.post('/reset-password', (req, res) => {
+     const { token, newPassword } = req.body; // ✅ Sử dụng token thay vì current password
+     if (!validateResetToken(token)) {
+       return res.status(400).json({ error: 'Invalid reset token' });
+     }
+   });
+   ```
+
+2. **Schema với reset token**:
+   ```typescript
+   const resetPasswordSchema = {
+     resetToken: { type: String, required: true }, // ✅ Token reset an toàn
+     newPassword: { type: String, required: true }
+   };
+   ```
+
+3. **Service method an toàn**:
+   ```javascript
+   async resetPasswordWithToken(resetToken, newPassword) {
+     const tokenData = await validateResetToken(resetToken); // ✅ Validate token
+     if (!tokenData.valid) {
+       throw new Error('Invalid or expired reset token');
+     }
+   }
+   ```
+
+4. **Form với email verification**:
+   ```typescript
+   function ForgotPasswordForm() {
+     return (
+       <form>
+         <input name="email" type="email" required /> {/* ✅ Chỉ cần email */}
+         <button>Send Reset Link</button>
+       </form>
+     );
+   }
+   ```
+
+## Tại sao đây là vấn đề bảo mật?
+
+### 1. **Mâu thuẫn logic**
+- Nếu người dùng nhớ mật khẩu hiện tại, họ không cần reset
+- Yêu cầu mật khẩu hiện tại làm vô hiệu hóa tính năng "quên mật khẩu"
+
+### 2. **Tạo điểm yếu bảo mật**
+- Kẻ tấn công có thể lợi dụng để brute force mật khẩu
+- Tăng surface attack cho account takeover
+
+### 3. **Trải nghiệm người dùng kém**
+- Người dùng quên mật khẩu không thể hoàn thành quy trình reset
+- Dẫn đến khóa tài khoản và frustration
+
+## Các trường hợp ngoại lệ
+
+### Trường hợp hợp lệ (không phải lỗi):
+
+1. **Password Change (không phải Reset)**:
+   ```javascript
+   // ✅ Thay đổi mật khẩu khi đã đăng nhập - hợp lệ
+   app.post('/change-password', authenticateUser, (req, res) => {
+     const { currentPassword, newPassword } = req.body;
+     // Hợp lệ vì đây là thay đổi, không phải reset
+   });
+   ```
+
+2. **Profile settings**:
+   ```javascript
+   // ✅ Cập nhật mật khẩu trong settings - hợp lệ
+   function ProfileSettings() {
+     return (
+       <div>
+         <h2>Change Password</h2> {/* Đây là change, không phải reset */}
+         <input name="currentPassword" />
+         <input name="newPassword" />
+       </div>
+     );
+   }
+   ```
+
+## Phương pháp detect
+
+Rule này sử dụng **heuristic analysis** với các pattern:
+
+1. **Context Detection**: Phát hiện ngữ cảnh password reset
+   - Keywords: `reset`, `forgot`, `recover`, `forgotpassword`
+   - Endpoints: `/reset-password`, `/forgot-password`
+   - Functions: `resetPassword()`, `forgotPassword()`
+
+2. **Violation Detection**: Tìm yêu cầu current password
+   - Field names: `currentPassword`, `oldPassword`, `existingPassword`
+   - Validation patterns: `validateCurrentPassword()`, `checkOldPassword()`
+   - Schema fields: `currentPassword: { required: true }`
+
+3. **Context Filtering**: Loại bỏ false positives
+   - Bỏ qua password change contexts
+   - Bỏ qua test files và documentation
+   - Bỏ qua comments và type definitions
+
+## Tham khảo
+
+- [OWASP A04:2021 - Insecure Design](https://owasp.org/Top10/A04_2021-Insecure_Design/)
+- [CWE-640: Weak Password Recovery Mechanism for Forgotten Password](https://cwe.mitre.org/data/definitions/640.html)
+- [OWASP Authentication Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Authentication_Cheat_Sheet.html#forgot-password)
+- [NIST SP 800-63B - Digital Identity Guidelines](https://pages.nist.gov/800-63-3/sp800-63b.html#sec5)
+
+## Ví dụ
+
+### Violation Examples
+
+```javascript
+// ❌ Express.js với current password requirement
+app.post('/reset-password', (req, res) => {
+  if (!req.body.currentPassword) {
+    return res.status(400).json({ error: 'Current password required' });
+  }
+});
+
+// ❌ NestJS với validation current password
+@Post('reset-password')
+async resetPassword(@Body() data: { currentPassword: string, newPassword: string }) {
+  await this.authService.validateCurrentPassword(data.currentPassword);
+}
+
+// ❌ Mongoose schema yêu cầu current password
+const resetSchema = new Schema({
+  currentPassword: { type: String, required: true }, // Vi phạm
+  newPassword: { type: String, required: true }
+});
+
+// ❌ React form với current password field
+<input 
+  name="currentPassword" 
+  placeholder="Enter current password" 
+  required 
+/>
+```
+
+### Secure Examples
+
+```javascript
+// ✅ Token-based reset
+app.post('/reset-password', (req, res) => {
+  const { token, newPassword } = req.body;
+  if (!validateResetToken(token)) {
+    return res.status(400).json({ error: 'Invalid reset token' });
+  }
+});
+
+// ✅ Email-based forgot password
+app.post('/forgot-password', (req, res) => {
+  const { email } = req.body;
+  sendResetEmail(email);
+  res.json({ message: 'Reset link sent to email' });
+});
+
+// ✅ Secure reset schema
+const resetSchema = new Schema({
+  resetToken: { type: String, required: true },
+  newPassword: { type: String, required: true },
+  tokenExpiry: { type: Date, required: true }
+});
+```