Static Code Analysis

  1. Common Findings and Detected Issues
    1. Security Vulnerabilities (SAST)
      1. Injection Flaws
        1. SQL Injection (SQLi)
          1. Union-Based Attacks
            1. Blind SQL Injection
              1. Time-Based Attacks
              2. Cross-Site Scripting (XSS)
                1. Reflected XSS
                  1. Stored XSS
                    1. DOM-Based XSS
                    2. Command Injection
                      1. OS Command Injection
                        1. Code Injection
                        2. LDAP Injection
                          1. NoSQL Injection
                            1. Header Injection
                            2. Broken Authentication and Session Management
                              1. Weak Password Handling
                                1. Password Storage Issues
                                  1. Password Policy Violations
                                  2. Session Fixation
                                    1. Session Hijacking Vulnerabilities
                                      1. Insufficient Session Expiration
                                        1. Weak Session Token Generation
                                        2. Sensitive Data Exposure
                                          1. Hardcoded Secrets
                                            1. Passwords
                                              1. API Keys
                                                1. Database Credentials
                                                  1. Encryption Keys
                                                  2. Weak Cryptographic Algorithms
                                                    1. Deprecated Hash Functions
                                                      1. Insecure Encryption Modes
                                                        1. Weak Key Generation
                                                        2. Information Disclosure
                                                          1. Debug Information Leakage
                                                            1. Error Message Exposure
                                                          2. XML External Entities (XXE)
                                                            1. External Entity Processing
                                                              1. XML Parser Configuration Issues
                                                                1. Billion Laughs Attack
                                                                2. Broken Access Control
                                                                  1. Privilege Escalation
                                                                    1. Vertical Privilege Escalation
                                                                      1. Horizontal Privilege Escalation
                                                                      2. Insecure Direct Object References
                                                                        1. Missing Function Level Access Control
                                                                          1. Forced Browsing Vulnerabilities
                                                                          2. Security Misconfiguration
                                                                            1. Default Credentials
                                                                              1. Insecure Permissions
                                                                                1. Unnecessary Services Enabled
                                                                                  1. Missing Security Headers
                                                                                  2. Insecure Deserialization
                                                                                    1. Object Injection Attacks
                                                                                      1. Remote Code Execution
                                                                                        1. Data Tampering
                                                                                        2. Memory Management Errors
                                                                                          1. Buffer Overflows and Overruns
                                                                                            1. Stack-Based Overflows
                                                                                              1. Heap-Based Overflows
                                                                                              2. Integer Overflows
                                                                                                1. Arithmetic Overflow
                                                                                                  1. Integer Wraparound
                                                                                                  2. Use-After-Free
                                                                                                    1. Double-Free Errors
                                                                                                      1. Memory Leaks
                                                                                                        1. Heap Memory Leaks
                                                                                                          1. Resource Handle Leaks
                                                                                                      2. Code Quality and Reliability Defects
                                                                                                        1. Null Pointer Dereferences
                                                                                                          1. Null Check Violations
                                                                                                            1. Optional Type Misuse
                                                                                                            2. Uninitialized Variables
                                                                                                              1. Local Variable Initialization
                                                                                                                1. Field Initialization Issues
                                                                                                                2. Resource Leaks
                                                                                                                  1. Files
                                                                                                                    1. File Handle Leaks
                                                                                                                      1. Stream Closure Issues
                                                                                                                      2. Sockets
                                                                                                                        1. Network Connection Leaks
                                                                                                                          1. Socket Closure Problems
                                                                                                                          2. Database Connections
                                                                                                                            1. Connection Pool Exhaustion
                                                                                                                              1. Transaction Management Issues
                                                                                                                              2. Memory Resources
                                                                                                                              3. Unreachable Code (Dead Code)
                                                                                                                                1. Conditional Dead Code
                                                                                                                                  1. Exception Handler Dead Code
                                                                                                                                    1. Method-Level Dead Code
                                                                                                                                    2. Concurrency Issues
                                                                                                                                      1. Race Conditions
                                                                                                                                        1. Data Race Detection
                                                                                                                                          1. Time-of-Check-Time-of-Use
                                                                                                                                          2. Deadlocks
                                                                                                                                            1. Circular Wait Conditions
                                                                                                                                              1. Lock Ordering Issues
                                                                                                                                              2. Improper Synchronization
                                                                                                                                                1. Missing Synchronization
                                                                                                                                                  1. Over-Synchronization
                                                                                                                                                  2. Atomic Operation Violations
                                                                                                                                                  3. Logic Errors
                                                                                                                                                    1. Off-by-One Errors
                                                                                                                                                      1. Array Boundary Errors
                                                                                                                                                        1. Loop Condition Errors
                                                                                                                                                        2. Incorrect Conditionals
                                                                                                                                                          1. Boolean Logic Errors
                                                                                                                                                            1. Comparison Operator Misuse
                                                                                                                                                            2. Algorithm Implementation Errors
                                                                                                                                                          2. Coding Standard and Style Violations
                                                                                                                                                            1. Adherence to Naming Conventions
                                                                                                                                                              1. Variable Naming Standards
                                                                                                                                                                1. Function Naming Conventions
                                                                                                                                                                  1. Class and Interface Naming
                                                                                                                                                                  2. Code Formatting and Layout
                                                                                                                                                                    1. Indentation Standards
                                                                                                                                                                      1. Line Length Limits
                                                                                                                                                                        1. Whitespace Usage
                                                                                                                                                                        2. Code Complexity Metrics
                                                                                                                                                                          1. Cyclomatic Complexity
                                                                                                                                                                            1. Decision Point Counting
                                                                                                                                                                              1. Complexity Thresholds
                                                                                                                                                                              2. Cognitive Complexity
                                                                                                                                                                                1. Mental Model Complexity
                                                                                                                                                                                  1. Nested Structure Analysis
                                                                                                                                                                                  2. Halstead Complexity Measures
                                                                                                                                                                                  3. Use of Deprecated Functions or APIs
                                                                                                                                                                                    1. Legacy API Usage
                                                                                                                                                                                      1. Version Compatibility Issues
                                                                                                                                                                                        1. Migration Path Identification
                                                                                                                                                                                        2. Commenting and Documentation Standards
                                                                                                                                                                                          1. Code Documentation Requirements
                                                                                                                                                                                            1. API Documentation Standards
                                                                                                                                                                                              1. Inline Comment Guidelines

                                                                                                                                                                                          Previous

                                                                                                                                                                                          3. Types of Static Analysis

                                                                                                                                                                                          Go to top

                                                                                                                                                                                          Next

                                                                                                                                                                                          5. Integration into the Development Process