@sun-asterisk/sunlint 1.2.2 → 1.3.1

package/rules/parser/rule-parser.js

@@ -221,8 +221,12 @@ class RuleParser {
   // Process lines with keywords
   processKeywordLine(line, rule, state) {
     if (this.containsKeyword(line, "OBJECTIVE")) {
-      rule.description = this.extractValueAfterKeyword(line, "OBJECTIVE")
-      this.resetParsingState(state)
+      state.currentSection = "objective"
+      const objectiveText = this.extractValueAfterKeyword(line, "OBJECTIVE")
+      if (objectiveText) {
+        rule.description = objectiveText
+      }
+      this.resetParsingFlags(state)
     } else if (this.containsKeyword(line, "DETAILS")) {
       state.currentSection = "details"
       const detailText = this.extractValueAfterKeyword(line, "DETAILS")
@@ -279,6 +283,13 @@ class RuleParser {
       state.currentSection = null
       state.currentConfigType = this.extractConfigType(line)
       console.log(`Found config section in rule ${rule.id}: ${line} (type: ${state.currentConfigType})`)
+    } else if (state.currentSection === "objective" && line.trim() && !line.trim().startsWith("**") && !line.trim().startsWith("-")) {
+      // Continue reading objective content on next lines
+      if (rule.description) {
+        rule.description += " " + line.trim()
+      } else {
+        rule.description = line.trim()
+      }
     } else if (state.currentSection === "details" && line.trim() && !line.trim().startsWith("**")) {
       rule.details.push(line.trim())
     }

package/rules/security/S005_no_origin_auth/README.md

@@ -0,0 +1,226 @@
+# S005: No Origin Header Authentication
+
+## Tổng quan
+
+Rule S005 phát hiện việc sử dụng Origin header cho authentication hoặc access control. Origin header có thể bị giả mạo (spoofed) và không an toàn để sử dụng làm cơ chế xác thực.
+
+## Mô tả
+
+Origin header trong HTTP request chỉ ra domain nào đã gửi request. Tuy nhiên, header này có thể dễ dàng bị giả mạo bởi attacker và không nên được sử dụng làm cơ chế authentication hoặc authorization.
+
+## Tại sao quan trọng?
+
+- **Bảo mật**: Origin header có thể bị spoofed, dẫn đến bypass authentication
+- **Reliability**: Không phải tất cả browser đều gửi Origin header
+- **Standards**: Không tuân thủ best practices về web security
+
+## Các pattern được phát hiện
+
+### ❌ Không hợp lệ
+
+```javascript
+// 1. Sử dụng Origin header trực tiếp cho authentication
+function authenticate(req, res, next) {
+    const origin = req.headers.origin;
+    if (origin === 'https://trusted.com') {
+        req.authenticated = true;
+        next();
+    } else {
+        res.status(401).json({ error: 'Unauthorized' });
+    }
+}
+
+// 2. Middleware sử dụng Origin cho access control
+app.use('/api', (req, res, next) => {
+    if (req.get('origin') === 'https://admin.example.com') {
+        req.isAdmin = true;
+    }
+    next();
+});
+
+// 3. Conditional authentication dựa trên Origin
+function checkAccess(req, res) {
+    if (req.headers.origin && req.headers.origin.includes('admin')) {
+        return res.json({ access: 'granted', token: generateToken() });
+    }
+    return res.status(403).json({ error: 'Access denied' });
+}
+
+// 4. CORS configuration mixed với authentication
+app.use(cors({
+    origin: function(origin, callback) {
+        if (adminOrigins.includes(origin)) {
+            callback(null, { credentials: true, authenticated: true });
+        } else {
+            callback(null, false);
+        }
+    }
+}));
+```
+
+### ✅ Hợp lệ
+
+```javascript
+// 1. JWT token authentication
+function authenticate(req, res, next) {
+    const token = req.headers.authorization;
+    jwt.verify(token, secret, (err, decoded) => {
+        if (err) return res.status(401).json({ error: 'Invalid token' });
+        req.user = decoded;
+        next();
+    });
+}
+
+// 2. Origin header chỉ để logging
+function logRequest(req) {
+    console.log('Request from origin:', req.headers.origin);
+    logger.info(`Origin: ${req.get('origin')}`);
+}
+
+// 3. CORS configuration đúng (không mixing với auth)
+app.use(cors({
+    origin: ['https://example.com', 'https://app.example.com'],
+    credentials: true
+}));
+
+// 4. Origin cho CORS preflight handling
+function handlePreflight(req, res) {
+    const origin = req.headers.origin;
+    if (allowedOrigins.includes(origin)) {
+        res.setHeader('Access-Control-Allow-Origin', origin);
+    }
+    res.end();
+}
+```
+
+## Các loại vi phạm
+
+| Type | Severity | Mô tả |
+|------|----------|--------|
+| `origin_header_auth` | error | Trực tiếp sử dụng req.headers.origin cho authentication |
+| `origin_header_method` | error | Sử dụng req.get('origin') cho authentication |
+| `conditional_origin_auth` | error | Conditional logic dựa trên Origin cho authentication |
+| `middleware_origin_auth` | error | Middleware authentication dựa trên Origin |
+| `cors_origin_auth` | warning | CORS configuration mixing với authentication |
+| `express_origin_auth` | error | Express routes sử dụng Origin cho authentication |
+
+## Cách khắc phục
+
+### 1. Sử dụng JWT Tokens
+
+```javascript
+// Thay vì
+if (req.headers.origin === 'trusted.com') {
+    req.authenticated = true;
+}
+
+// Sử dụng
+const token = req.headers.authorization?.replace('Bearer ', '');
+const decoded = jwt.verify(token, process.env.JWT_SECRET);
+req.user = decoded;
+```
+
+### 2. Session-based Authentication
+
+```javascript
+// Thay vì
+if (req.get('origin') === 'admin.com') {
+    req.isAdmin = true;
+}
+
+// Sử dụng
+if (req.session && req.session.user && req.session.user.role === 'admin') {
+    req.isAdmin = true;
+}
+```
+
+### 3. API Key Authentication
+
+```javascript
+// Thay vì
+const origin = req.headers.origin;
+if (trustedOrigins.includes(origin)) {
+    next();
+}
+
+// Sử dụng
+const apiKey = req.headers['x-api-key'];
+if (validateApiKey(apiKey)) {
+    next();
+}
+```
+
+### 4. Proper CORS Configuration
+
+```javascript
+// Đúng: CORS không làm authentication
+app.use(cors({
+    origin: function(origin, callback) {
+        if (!origin || allowedOrigins.includes(origin)) {
+            callback(null, true);
+        } else {
+            callback(new Error('Not allowed by CORS'));
+        }
+    },
+    credentials: true
+}));
+
+// Authentication riêng biệt
+app.use('/api', authenticateToken);
+```
+
+## Configuration
+
+Rule có thể được cấu hình trong `config.json`:
+
+```json
+{
+  "checkAuthContext": true,
+  "checkMiddleware": true,
+  "checkConditionals": true,
+  "checkCORSMixing": true,
+  "contextDepth": 3,
+  "ignoreComments": true
+}
+```
+
+## Technology Stack
+
+- **AST Analysis**: Babel parser với TypeScript/JavaScript support
+- **Fallback**: Regex patterns cho edge cases
+- **Accuracy**: 95% với AST, 85% với regex
+- **Languages**: TypeScript, JavaScript
+
+## Testing
+
+Rule được test với:
+- Valid code patterns (không có violations)
+- Invalid authentication patterns (có violations)
+- Edge cases và syntax errors
+- Context detection scenarios
+
+## Best Practices
+
+1. **Luôn sử dụng proper authentication mechanisms**:
+   - JWT tokens
+   - Session-based auth
+   - API keys
+   - OAuth 2.0
+
+2. **Tách biệt CORS và Authentication**:
+   - CORS chỉ để control resource sharing
+   - Authentication để verify identity
+
+3. **Origin header chỉ dùng cho**:
+   - Logging và monitoring
+   - CORS preflight handling
+   - Analytics (không sensitive)
+
+4. **Không bao giờ trust Origin header cho security decisions**
+
+## Tài liệu tham khảo
+
+- [OWASP: CORS Origin Header Scrutiny](https://owasp.org/www-community/vulnerabilities/CORS_OriginHeaderScrutiny)
+- [MDN: Origin Header](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Origin)
+- [Auth0: JWT Best Practices](https://auth0.com/docs/secure/tokens/json-web-tokens)
+- [OWASP: Authentication Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Authentication_Cheat_Sheet.html)

package/rules/security/S005_no_origin_auth/analyzer.js

@@ -0,0 +1,184 @@
+/**
+ * Hybrid analyzer for S005 - No Origin Header Authentication
+ * Uses AST analysis with regex fallback for comprehensive coverage
+ * Detects usage of Origin header for authentication/access control
+ */
+
+const S005ASTAnalyzer = require('./ast-analyzer');
+
+class S005Analyzer {
+  constructor() {
+    this.ruleId = 'S005';
+    this.ruleName = 'No Origin Header Authentication';
+    this.description = 'Do not use Origin header for authentication or access control';
+    this.astAnalyzer = new S005ASTAnalyzer();
+  }
+
+  async analyze(files, language, options = {}) {
+    const violations = [];
+    
+    if (options.verbose) {
+      console.log(`🔍 Running S005 analysis on ${files.length} files...`);
+    }
+
+    // Use AST analysis as primary method
+    const astViolations = await this.astAnalyzer.analyze(files, language, options);
+    violations.push(...astViolations);
+
+    // Add regex-based patterns for edge cases AST might miss
+    for (const filePath of files) {
+      try {
+        const content = require('fs').readFileSync(filePath, 'utf8');
+        const regexViolations = this.analyzeWithRegexPatterns(content, filePath, options);
+        
+        // Filter out duplicates (same line, same type)
+        const filteredRegexViolations = regexViolations.filter(regexViolation => 
+          !astViolations.some(astViolation => 
+            astViolation.line === regexViolation.line && 
+            astViolation.filePath === regexViolation.filePath
+          )
+        );
+        
+        violations.push(...filteredRegexViolations);
+      } catch (error) {
+        if (options.verbose) {
+          console.warn(`⚠️ S005 regex analysis failed for ${filePath}: ${error.message}`);
+        }
+      }
+    }
+
+    if (options.verbose && violations.length > 0) {
+      console.log(`📊 S005 found ${violations.length} violations`);
+    }
+
+    return violations;
+  }
+
+  analyzeWithRegexPatterns(content, filePath, options = {}) {
+    const violations = [];
+    const lines = content.split('\n');
+
+    lines.forEach((line, index) => {
+      const lineNumber = index + 1;
+      
+      // Pattern 1: Direct origin header access for authentication
+      // req.headers.origin, req.get('origin'), req.header('origin')
+      const originHeaderPattern = /(?:req\.headers\.origin|req\.get\s*\(\s*['"`]origin['"`]\s*\)|req\.header\s*\(\s*['"`]origin['"`]\s*\)|headers\[['"`]origin['"`]\])/i;
+      if (originHeaderPattern.test(line)) {
+        // Check if this line is used for authentication/authorization
+        const authContextPattern = /(?:auth|login|verify|check|validate|permission|access|allow|deny|secure|token|session)/i;
+        if (authContextPattern.test(line) || this.isInAuthContext(lines, index)) {
+          violations.push({
+            ruleId: this.ruleId,
+            severity: 'error',
+            message: 'Origin header should not be used for authentication. Origin can be spoofed and is not secure for access control.',
+            line: lineNumber,
+            column: line.search(originHeaderPattern) + 1,
+            filePath: filePath,
+            type: 'origin_header_auth'
+          });
+        }
+      }
+
+      // Pattern 2: Origin-based CORS validation for authentication
+      const corsOriginAuthPattern = /(?:cors|origin).*(?:auth|login|permission|access|allow|token)/i;
+      if (corsOriginAuthPattern.test(line) && !line.includes('//') && !line.includes('*')) {
+        violations.push({
+          ruleId: this.ruleId,
+          severity: 'warning',
+          message: 'CORS origin validation should not replace proper authentication mechanisms.',
+          line: lineNumber,
+          column: line.search(corsOriginAuthPattern) + 1,
+          filePath: filePath,
+          type: 'cors_origin_auth'
+        });
+      }
+
+      // Pattern 3: Origin header in conditional authentication logic
+      const conditionalAuthPattern = /if\s*\([^)]*origin[^)]*\)\s*\{[^}]*(?:auth|login|token|permission|access)/i;
+      if (conditionalAuthPattern.test(line)) {
+        violations.push({
+          ruleId: this.ruleId,
+          severity: 'error',
+          message: 'Conditional authentication based on Origin header is insecure. Use proper authentication tokens.',
+          line: lineNumber,
+          column: line.search(/origin/i) + 1,
+          filePath: filePath,
+          type: 'conditional_origin_auth'
+        });
+      }
+
+      // Pattern 4: Origin in middleware authentication
+      const middlewarePattern = /(middleware|auth|guard).*origin.*(?:next\(\)|return|allow|permit)/i;
+      if (middlewarePattern.test(line)) {
+        violations.push({
+          ruleId: this.ruleId,
+          severity: 'error',
+          message: 'Authentication middleware should not rely on Origin header. Use proper authentication mechanisms.',
+          line: lineNumber,
+          column: line.search(/origin/i) + 1,
+          filePath: filePath,
+          type: 'middleware_origin_auth'
+        });
+      }
+
+      // Pattern 5: Origin header whitelisting for access control
+      const whitelistPattern = /(?:whitelist|allowlist|allowed.*origins?).*(?:auth|access|permission)/i;
+      if (whitelistPattern.test(line) && /origin/i.test(line)) {
+        violations.push({
+          ruleId: this.ruleId,
+          severity: 'warning',
+          message: 'Origin whitelisting should complement, not replace, proper authentication and authorization.',
+          line: lineNumber,
+          column: line.search(/origin/i) + 1,
+          filePath: filePath,
+          type: 'origin_whitelist_auth'
+        });
+      }
+
+      // Pattern 6: Express.js specific patterns
+      const expressPattern = /(?:app\.use|router\.).*origin.*(?:auth|protect|secure)/i;
+      if (expressPattern.test(line)) {
+        violations.push({
+          ruleId: this.ruleId,
+          severity: 'error',
+          message: 'Express routes should not use Origin header for authentication or authorization.',
+          line: lineNumber,
+          column: line.search(/origin/i) + 1,
+          filePath: filePath,
+          type: 'express_origin_auth'
+        });
+      }
+    });
+
+    return violations;
+  }
+
+  /**
+   * Check if the current line is within an authentication context
+   * by looking at surrounding lines
+   */
+  isInAuthContext(lines, currentIndex) {
+    const contextRange = 3; // Check 3 lines before and after
+    const startIndex = Math.max(0, currentIndex - contextRange);
+    const endIndex = Math.min(lines.length - 1, currentIndex + contextRange);
+    
+    const authKeywords = [
+      'authenticate', 'authorize', 'login', 'logout', 'auth',
+      'permission', 'access', 'token', 'session', 'user',
+      'verify', 'validate', 'check', 'guard', 'protect',
+      'middleware', 'passport', 'jwt', 'bearer'
+    ];
+    
+    for (let i = startIndex; i <= endIndex; i++) {
+      const line = lines[i].toLowerCase();
+      if (authKeywords.some(keyword => line.includes(keyword))) {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+}
+
+module.exports = S005Analyzer;