Fuzzing

  1. Types of Fuzzers
    1. By Input Awareness
      1. Black-Box Fuzzing
        1. Random Input Generation
          1. Lack of Target Feedback
            1. Use Cases and Limitations
            2. White-Box Fuzzing
              1. Symbolic Execution
                1. Path Constraint Solving
                  1. Generating Inputs for Unexplored Paths
                  2. Concolic Execution
                    1. Combining Concrete and Symbolic Execution
                      1. Advantages and Challenges
                    2. Grey-Box Fuzzing
                      1. Coverage-Guided Fuzzing
                        1. Feedback Mechanisms
                          1. Maximizing Code Coverage
                          2. Instrumentation-Based Fuzzing
                            1. Lightweight Instrumentation
                              1. Performance Considerations
                          3. By Input Generation Method
                            1. Mutation-Based Fuzzing
                              1. Modifying Existing Inputs
                                1. Mutation Strategies
                                2. Generation-Based Fuzzing
                                  1. Defining Input Grammars
                                    1. Generating Valid Inputs
                                    2. Hybrid Approaches
                                      1. Combining Mutation and Generation
                                        1. Adaptive Strategies
                                      2. By Target Type
                                        1. Application Fuzzing
                                          1. User-Facing Applications
                                            1. Command-Line Tools
                                            2. Protocol Fuzzing
                                              1. Network Protocols
                                                1. State Machines
                                                2. File Format Fuzzing
                                                  1. Structured File Inputs
                                                    1. Parsing Logic
                                                    2. Kernel Fuzzing
                                                      1. System Call Interfaces
                                                        1. Privilege Escalation Risks
                                                        2. API Fuzzing
                                                          1. Public and Private APIs
                                                            1. Input Validation
                                                            2. Web Application Fuzzing
                                                              1. HTTP Parameter Fuzzing
                                                                1. Authentication Bypass
                                                                2. Binary Fuzzing
                                                                  1. Executable Files
                                                                    1. Library Functions

                                                                Previous

                                                                2. Core Concepts and Architecture

                                                                Go to top

                                                                Next

                                                                4. Input Generation and Mutation Strategies