@sun-asterisk/sunlint 1.3.16 → 1.3.17

package/rules/security/S010_no_insecure_encryption/README.md

@@ -1,15 +1,20 @@
 # S010 - Must use cryptographically secure random number generators (CSPRNG)
 
 ## Overview
+
 Quy tắc này phát hiện việc sử dụng các hàm tạo số ngẫu nhiên không an toàn (như `Math.random()`) cho các mục đích bảo mật, có thể dẫn đến các lỗ hổng bảo mật nghiêm trọng do tính có thể dự đoán được.
 
+**Analyzer Version**: 2.0 (AST-based with ts-morph) - Context-aware detection with minimal false positives
+
 ## OWASP Classification
+
 - **Category**: A02:2021 - Cryptographic Failures
 - **CWE**: CWE-338 - Use of Cryptographically Weak Pseudo-Random Number Generator (PRNG)
 - **Severity**: Error
 - **Impact**: High (Predictable tokens, weak encryption keys, authentication bypass)
 
 ## Vấn đề
+
 Khi sử dụng các hàm tạo số ngẫu nhiên không an toàn cho mục đích bảo mật:
 
 1. **Tính dự đoán**: `Math.random()` và các hàm tương tự có thể được dự đoán bởi kẻ tấn công
@@ -20,6 +25,7 @@ Khi sử dụng các hàm tạo số ngẫu nhiên không an toàn cho mục đ
 ## Các trường hợp vi phạm
 
 ### 1. Sử dụng Math.random() cho security tokens
+
 ```javascript
 // ❌ Vi phạm - Math.random() không an toàn cho security
 const sessionToken = Math.random().toString(36).substring(2);
@@ -37,6 +43,7 @@ const jwtSecret = Math.random().toString(36);
 ```
 
 ### 2. Sử dụng timestamp cho random generation
+
 ```javascript
 // ❌ Vi phạm - timestamp có thể dự đoán được
 const userId = Date.now().toString();
@@ -48,6 +55,7 @@ const token = Date.now() + '-' + Math.random().toString(36);
 ```
 
 ### 3. Sử dụng cho mã hóa và authentication
+
 ```javascript
 // ❌ Vi phạm - tạo encryption key không an toàn
 const encryptionKey = Math.random().toString(36).repeat(3);
@@ -61,6 +69,7 @@ const csrfToken = Math.floor(Math.random() * 1000000000);
 ```
 
 ### 4. Tạo unique identifiers không an toàn
+
 ```javascript
 // ❌ Vi phạm - tạo user ID
 const generateUserId = () => Math.random().toString(36).substring(2);
@@ -75,6 +84,7 @@ const tempFile = `temp_${Date.now()}_${Math.random()}.tmp`;
 ## Giải pháp an toàn
 
 ### 1. Sử dụng crypto.randomBytes()
+
 ```javascript
 // ✅ An toàn - sử dụng crypto.randomBytes()
 const crypto = require('crypto');
@@ -85,6 +95,7 @@ const resetCode = crypto.randomBytes(3).toString('hex'); // 6 hex chars
 ```
 
 ### 2. Sử dụng crypto.randomUUID()
+
 ```javascript
 // ✅ An toàn - sử dụng crypto.randomUUID()
 const sessionId = crypto.randomUUID();
@@ -93,6 +104,7 @@ const requestId = crypto.randomUUID();
 ```
 
 ### 3. Sử dụng crypto.randomInt()
+
 ```javascript
 // ✅ An toàn - sử dụng crypto.randomInt()
 const otpCode = crypto.randomInt(100000, 999999); // 6-digit OTP
@@ -101,6 +113,7 @@ const challengeNumber = crypto.randomInt(1, 1000000);
 ```
 
 ### 4. Sử dụng cho mã hóa an toàn
+
 ```javascript
 // ✅ An toàn - tạo encryption key
 const encryptionKey = crypto.randomBytes(32); // 256-bit key
@@ -115,6 +128,7 @@ const cipher = crypto.createCipher('aes-256-cbc', key, iv);
 ```
 
 ### 5. Sử dụng thư viện an toàn
+
 ```javascript
 // ✅ An toàn - sử dụng nanoid
 const { nanoid } = require('nanoid');
@@ -130,6 +144,7 @@ const randomBytes = secureRandom(32, { type: 'Buffer' });
 ```
 
 ### 6. Express.js session security
+
 ```javascript
 // ✅ An toàn - cấu hình Express session
 const session = require('express-session');
@@ -148,6 +163,7 @@ app.use(session({
 ```
 
 ### 7. JWT token generation
+
 ```javascript
 // ✅ An toàn - tạo JWT với secure secret
 const jwtSecret = crypto.randomBytes(64).toString('hex');
@@ -215,10 +231,72 @@ const mockData = Array.from({length: 10}, () => ({
 }));
 ```
 
+## Analyzer v2.0 - AST-based Context Detection
+
+### Cải tiến chính
+
+Analyzer mới sử dụng **ts-morph** để phân tích AST (Abstract Syntax Tree), cho phép:
+
+1. **Context-aware detection**: Phân biệt security context vs non-security context
+2. **Security function detection**: Phát hiện generic variable names trong security functions
+3. **Minimal false positives**: Không flag filename, timestamp, request ID, logging
+
+### Security Context Detection
+
+**Sẽ flag (Security contexts):**
+
+```javascript
+// ❌ Security variable names
+const otp = Math.random() * 1000000;
+const sessionToken = Date.now().toString(36);
+const apiKey = Math.random().toString(36);
+const resetToken = Math.random();
+
+// ❌ Generic names trong security functions
+function generateOTP() {
+  const random = Math.random() * 1000000; // ← Flagged!
+  return random;
+}
+```
+
+**Sẽ KHÔNG flag (Non-security contexts):**
+
+```javascript
+// ✅ Filenames
+const zipFileName = `customer_${Date.now()}.zip`;
+const backupFile = `backup_${Date.now()}.sql`;
+
+// ✅ Expiration time calculations
+const expriedTime = new Date(Date.now() + TTL);
+
+// ✅ Request tracking / Logging
+const requestId = `req_${Date.now()}`;
+const logId = Date.now().toString(36);
+const traceId = `trace_${Date.now()}`;
+
+// ✅ Temporary files
+const tempFile = `/tmp/upload_${Date.now()}.tmp`;
+```
+
+### Technical Details
+
+- **Library**: ts-morph (TypeScript AST parser)
+- **Detection method**: Variable name analysis + Function context analysis
+- **Languages**: JavaScript, TypeScript (.js, .jsx, .ts, .tsx)
+- **Security keywords**: otp, token, session, apikey, password, verify, reset, magic, secret, etc.
+- **Non-security keywords**: filename, log, request, trace, expire, temp, backup, etc.
+
+### Migration from v1.0
+
+- **v1.0**: Regex-based, 79 patterns, 89% accuracy, false positives with timestamps/filenames
+- **v2.0**: AST-based, context-aware, 95%+ accuracy, minimal false positives
+- **Backward compatibility**: Legacy analyzer backed up as `analyzer-regex-legacy.js`
+
 ## Tài liệu tham khảo
 
 - [OWASP A02:2021 - Cryptographic Failures](https://owasp.org/Top10/A02_2021-Cryptographic_Failures/)
 - [CWE-338: Use of Cryptographically Weak Pseudo-Random Number Generator](https://cwe.mitre.org/data/definitions/338.html)
 - [Node.js Crypto Documentation](https://nodejs.org/api/crypto.html)
 - [NIST Guidelines for Random Number Generation](https://csrc.nist.gov/publications/detail/sp/800-90a/rev-1/final)
+- [ts-morph Documentation](https://ts-morph.com/)
 - [Secure Random Number Generation Best Practices](https://cheatsheetseries.owasp.org/cheatsheets/Cryptographic_Storage_Cheat_Sheet.html)