wpaudit - WPAUDIT: Advanced WordPress security auditing suit

项目说明

WPAUDIT - Ad WordPress Security Auditing Suite

![Python 3.7+]()
![GitHub stars]()
![GitHub forks]()
![GitHub issues]()
![GitHub last commit]()

Welcome to the official WPAUDIT documentation! This comprehensi provides an in-depth o of WPAUDIT, a powerful WordPress security audit tool designed for ethical hackers, penetration testers, and security professionals. Learn about its ad features, setup, and effecti for conducting thorough WordPress scanning and WordPress penetration testing.

Table of Contents

WPAUDIT - Ad WordPress Security Auditing Suite

- Table of Contents
- O
- Key Features of WPAUDIT - Your Expert WordPress Scanner
- Technical Architecture: How WPAUDIT Works
- Extending WPAUDIT
- Understanding Scan Profiles
- The ScanState Object
- Prerequisites
- Software:
- External Tools Integration:
- Installation Guide for WPAUDIT
- General Setup
- Kali Linux Specific Setup
- De Setup
- Usage
- Configuration
- Scan Phases
- Output and Reporting
- Contributing to WPAUDIT
- Support the Project
- Troubleshooting Common Issues
- Roadmap / Future Enhancements
- License

O

WPAUDIT is a hyper-configurable, modular WordPress security auditing suite engineered to automate and streamline the process of identifying and security weaknesses in WordPress installations. As a leading automated WordPress security tool, WPAUDIT empowers users to perform detailed security assessments, making it an essential utility for any WordPress penetration testing tool kit, especially when operating on platforms like Kali Linux. Its modular architecture allows for highly customized scans tailored to specific target en and auditing requirements.

Key Features of WPAUDIT - Your Expert WordPress Scanner

* Modular Scan Phases: Executes distinct security checks in sequence (Preflight, Nmap, WPScan, REST API Analysis, Parameter Fuzzing, Nuclei, SQLMap, Exploit Intel).
* Configurable Profiles: Supports different scan profiles (default, stealth, aggressive) for levels of intensity and stealthiness.
* Flexible Configuration: Uses YAML/JSON configuration files for detailed control over tool paths, API keys, scan parameters, and output settings.
* Command-Line O: Allows o specific configuration settings directly via CLI arguments for quick adjustments.
* Phase Skipping: Users can choose to skip specific scan phases.
* Tool Dependency Checking: the presence and configuration of required external tools before starting the scan.
* State Management: Tracks scan progress and findings, saving the state incrementally.
* Reporting: Generates a console summary, a comprehensive JSON state file, and an interactive HTML report for easy analysis and sharing.
* Interactive Mode: Optionally prompts the user for confirmation before potentially intrusi, ensuring control over the scan.
* Cross-Platform Compatibility: While optimized for en like Kali Linux, WPAUDIT is a Python-based tool and can run on operating systems where Python and the external tools are supported.

Technical Architecture: How WPAUDIT Works

WPAUDIT operates through a coordinated system of core components and specialized scanner modules:

* main.py (Orchestrator): The central script that parses command-line arguments, loads configurations, initializes the scan state, and sequentially executes the defined scan phases.
* core/ Modules:
* config_loader.py: Manages loading and merging of YAML configuration files.
* state.py: Handles the ScanState object, which stores all findings, metadata, and progress throughout the scan. It supports saving and loading the state.
* tool_checker.py: the a and (optionally) of required external command-line tools.
* tool_runner.py: A robust wrapper for executing external tools, managing timeouts, and capturing output.
* utils.py: Contains helper functions used across the application.
* modules/ Directory: Contains indi Python scripts for each scan phase or specific tool integration (e.g., nmap_scanner.py, wpscan_auditor.py, wp_analyzer/ sub-package for detailed WordPress checks). Each module typically has a run_scan or run_analysis function called by main.py.
* reporting/ Directory:
* generator.py: Responsible for creating the text summary and HTML reports from the final ScanState.
* report_template.html: A Jinja2 template used to render the HTML report.
* config/ Directory: Contains default configuration files (default_config.yaml) that users can adapt.

The scan proceeds through phases defined in main.py, with each phase potentially updating the shared ScanState object. This state is sa and at the end of the scan, forming the basis for the final reports.

Extending WPAUDIT

WPAUDIT is designed to be modular, allowing for the addition of new scanning capabilities. If you wish to add a new scanner module:

1. Create a New Module File: Add a new Python file in the modules/ directory (or a sub-directory like modules/wp_analyzer/ for more specific WordPress checks). For example, modules/new_scanner_module.py.
2. Implement the Scan Logic:
* Your module should typically define a main function, e.g., run_scan(target_url, scan_state, config, tool_runner, logger).
* This function will receive the target URL, the current ScanState object, the global configuration, an instance of ToolRunner (if external tools are needed), and a logger instance.
* Perform your checks and update the scan_state.findings dictionary with your results. For example: scan_state.findings['new_scanner_results'] = {'': [...]}.
* Use the provided logger for any output specific to your module.
3. Integrate into Main Workflow (main.py):
* Import your module's run_scan function at the top of main.py.
* Add a unique string key for your new phase (e.g., 'new_scanner_phase') to the PHASES list in main.py, placing it in the desired order of execution.
* In the main scan loop within main.py (the for phase in acti: loop), add an elif phase == 'new_scanner_phase': block to call your module's run_scan function.
* Ensure you pass all necessary arguments (target URL, scan state, config, tool runner, logger).
4. Configuration (Optional):
* If your module requires specific configurations (e.g., API keys, special parameters), add them to config/default_config.yaml.
* Access these configurations within your module via the config object passed to your run_scan function.
5. Tool Dependencies (If any):
* If your module uses new external tools, add them to the tool_paths section in config/default_config.yaml and update core/tool_checker.py to include checks for these tools.
6. Update Documentation: Add details about your new module to this README, including its purpose, any new configuration options, and the nature of the output it produces. Also, mention it in the "Scan Phases" section.
7. Add Tests: Write unit tests for your new module's functionality and place them in the tests/ directory (you might need to create this directory and a tests/test_new_scanner_module.py file).

This modular approach helps keep the codebase organized and makes it easier to contribute new functionalities.

Understanding Scan Profiles

WPAUDIT offers scan profiles (default, stealth, aggressive) to tailor the scan intensity and techniques:

* default: A balanced profile suitable for most initial assessments, pro good co without being overly intrusive.
* stealth: Designed for less noisy scans. This profile typically uses passi where possible, makes fewer requests, employs slower timings for tools like Nmap, and may use a more restricted set of Nuclei templates. Ideal when trying to minimize the scan's footprint or avoid detection by WAFs/IPS.
* aggressive: A comprehensive and potentially noisy profile. It enables more checks, deeper fuzzing (if configured), scans all TCP ports with Nmap using more intrusi, and utilizes a broader set of Nuclei templates. This profile provides the most thorough assessment but should be used with caution and only with explicit authorization due to its potential impact on the target system.

Each profile in config.yaml allows customization of options for Nmap (nmap_options, nmap_ports, nmap_scripts), WPScan (wpscan_options), Nuclei (nuclei_templates), SQLMap (sqlmap_options_profile, sqlmap_tamper_scripts_profile), and other modules, giving you fine-grained control over the tools' behavior within each profile.

The ScanState Object

Throughout its execution, WPAUDIT maintains a central ScanState object (managed by core/state.py). This object is crucial as it serves as the li for:

* Scan Metadata: Information about the target (URL, IP), scan start/end times, and the configuration profile used.
* Tool Check Results: Status of required external tools (e.g., if Nmap was found and its ).
* Module Findings: All data collected by each executed module is stored here, typically organized by module name (e.g., findings['nmap_results'], findings['wpscan_results'], findings['wp_analyzer']['security_headers_analysis']).
* Actionable Intelligence: Lists of critical alerts, summary points for quick review, and detailed remediation suggestions.
* Tool Errors: Any errors encountered during the execution of external tools.

The entire ScanState is saved as a JSON file (e.g., wpaudit_state_target_timestamp_FULL_REPORT.json) in the configured output directory. This file allows for:
* Detailed post-scan analysis and data mining.
* Auditing the scan process itself.
* Potentially resuming scans or re-processing data in future of WPAUDIT.
* Feeding data into other security information and event management (SIEM) systems or reporting tools.

Prerequisites

Software:

* Python: 3.7 or higher.
* Python Libraries: PyYAML, requests (Install via pip install -r requirements.txt).

External Tools Integration:

WPAUDIT seamlessly integrates with a suite of industry-standard security tools. For optimal performance, especially on systems like Kali Linux for ethical hacking, ensure these are installed and correctly configured (accessible in your system's PATH or specified in config.yaml):
* Nmap: Essential for network discovery, port scanning, and service detection.
* WPScan: The core WordPress scanner for identifying issues in WordPress core, plugins, and themes. (A WPScan API token is highly recommended for up-to-date data).
* Nuclei: Powerful template-based scanner for finding a wide range of using community-curated templates.
* SQLMap: The leading tool for detecting and exploiting SQL injection flaws.
* SearchSploit: Command-line interface for Exploit-DB, used to find relevant public exploits.
* Metasploit Framework (msfconsole): For le exploit modules and auxiliary tools (use with extreme caution and authorization).
* Subfinder: For efficient passi enumeration.
* ffuf: Fast web fuzzer used for directory and path bruteforcing.
* Arjun: HTTP parameter discovery suite.
* *(Other tools might be implicitly required by specific modules - refer to module code if needed. WPAUDIT is designed to be a comprehensi security audit tool.)*

Installation Guide for WPAUDIT

Follow these steps to get WPAUDIT up and running on your system.

General Setup

1. Clone the repository:

2. Install Python dependencies (Recommended: Use a En):
It's highly recommended to use a Python en to manage dependencies and avoid conflicts with system-wide packages.
* Create a en:

(Replace venv with your preferred en name if desired)
* Activate the en:
* On Linux/macOS:

* On Windows:

* Install dependencies:

3. Install External Tools: WPAUDIT relies on several external security tools. Ensure they are installed and accessible in your system's PATH, or their paths are correctly specified in your config.yaml. Refer to the "External Tools Integration" section for a list of tools. Installation methods vary by OS and tool.

4. Configure:
* Copy or rename config/default_config.yaml to config/config.yaml (or use a custom path).
* Edit the configuration file (config.yaml) to:
* Set the correct paths for the external tools if they are not in your system's PATH.
* Add your WPScan API token under api_keys.
* Adjust profile settings and other parameters as needed.

Kali Linux Specific Setup

Kali Linux has specific considerations for Python package management and comes with many security tools pre-installed or easily a.

1. Clone the repository (if not already done):

2. Set up Python En (Highly Recommended on Kali):
Kali Linux uses an "externally managed" Python en. To avoid issues, always use a en for Python projects.

Your terminal prompt should change to indicate the en is active (e.g., (venv) user:~/wpaudit$).

3. Install Python Dependencies:
With the en activated:

4. Install/ External Tools on Kali Linux:
Many tools are a via apt. You can try to install them using:

Notes on Kali Tool Installation:
* wpscan: The command apt install wpscan should work on most up-to-date Kali systems. If it doesn't, or if you need a newer than what apt provides, you can install/update it using RubyGems:

* searchsploit: This tool is part of the exploitdb package. The command sudo apt install -y exploitdb should install it. If you encounter issues or want the very latest , you can clone it directly: git clone /opt/exploitdb (and then add /opt/exploitdb to your PATH or symlink searchsploit).
* nuclei, subfinder, ffuf, arjun: These are often Go-based tools. If not a via apt or if you need the latest , you might need to download their precompiled binaries from their official GitHub release pages or install them using go install -.com/projectdiscovery/nuclei/v2/cmd/nuclei (requires Go to be installed: sudo apt install golang-go).
* Always that the tools are correctly installed and accessible in your PATH. WPAUDIT's tool_paths in config.yaml can be used to specify direct paths if needed.
* metasploit-framework is a large package and might take time to install.

5. Configure WPAUDIT:
Proceed with the configuration steps mentioned in the "General Setup" (copying default_config.yaml to config.yaml and editing it).

De Setup

For those looking to contribute to WPAUDIT de, here's how to set up your en:

1. Follow the Installation Guide: Ensure you have a working installation, preferably within a en.
2. Install De Dependencies: To ensure code quality and run tests, install the necessary de tools.

3. Code Style & Linting: We use black for formatting, flake8 for linting, isort for import sorting, and mypy for type checking.
* It's recommended to configure your IDE to use these tools. Alternatively, run them manually from the project root:

*(Note: --ignore-missing-imports for mypy can be useful initially if stubs for all dependencies are not present.)*
4. Running Tests: Ensure all tests pass before submitting contributions. We use pytest.

To include co reports:

This will generate an HTML co report in htmlco.html.
Refer to CONTRIBUTING.md for more details on code style and contribution processes.

Usage

Run the main script from the project's root directory:

Arguments:

* target_url: (Required) The target WordPress URL (e.g., ).

Common Options:

* --config <path/to/config.yaml>: Specify a custom configuration file.
* --profile <profile_name>: Select a scan profile (default, stealth, aggressive). Default is default.
* --skip-phases <phase1> <phase2> ...: List of phases to skip (e.g., --skip-phases nmap sqlmap).
* --wpscan-api-token <token>: O the WPScan API token from the config file.
* --wordlist <path/to/wordlist>: O the wordlist path for WPScan password attacks.
* --interactive / --no-interactive: Enable/disable interacti (o config).
* --sqlmap-targets <url1> <url2> ...: Provide specific URLs for SQLMap to test, in addition to those found by Nuclei.
* --output-dir <path/to/output>: O the output directory specified in the config.

Examples:

* Basic Scan (Default Profile):

* Aggressive Scan with Custom Config:

* Skip Nmap and SQLMap:

* O WPScan Token and Output Directory:

Configuration

The primary configuration is managed through a YAML file (e.g., config/config.yaml, based on config/default_config.yaml). Key sections include:
* tool_paths: Paths to external tool executables.
* api_keys: API keys for services like WPScan.
* output_dir: Directory to store scan results and reports.
* interacti: Enable/disable user confirmation prompts.
* scan_profiles: Defines settings for default, stealth, and aggressive profiles, controlling parameters for each tool/phase.
* wordlist_path: Default path to the wordlist for password attacks.

Refer to config/default_config.yaml for detailed structure and options.

Scan Phases

The tool executes the following phases in order (unless skipped):

1. Preflight: Initial checks (e.g., target reachability, basic WordPress detection).
2. Nmap: Performs network scanning using Nmap based on the selected profile's configuration.
3. WPScan: Runs WPScan to identify WordPress , themes, plugins, users, and known .
4. REST API / Parameter Fuzzing (wp_analyzer): Analyzes the WordPress REST API endpoints and potentially fuzzes parameters (details depend on wp_analyzer.py implementation).
5. Nuclei: Executes Nuclei scans using WordPress-related templates to find . Hints for potential SQL injection points might be gathered here.
6. SQLMap: Attempts to detect and exploit SQL injection using SQLMap, potentially using hints from Nuclei or user-provided targets.
7. Exploit Intel: Gathers information about potential exploits for discovered (details depend on exploit_intel.py implementation).

Output and Reporting

WPAUDIT provides comprehensi to detail the findings of your WordPress security audit:
* Console Output: Real-time feedback and progress updates during the scan.
* JSON State File: A detailed JSON file (wpaudit_state_<hostname>_<timestamp>.json) is saved in the output directory. This file contains all raw data, findings, and configurations from each module, serving as a complete record of the WordPress scanning process.
* Text Summary Report: A human-readable summary (wpaudit_summary_<hostname>_<timestamp>.txt) highlighting key findings and critical alerts.
* HTML Report: An interactive HTML report (wpaudit_report_<hostname>_<timestamp>.html) offering a structured and user-friendly view of the scan results, ideal for sharing and analysis.

Contributing to WPAUDIT

We welcome contributions to WPAUDIT! If you're interested in improving this WordPress penetration testing tool, please read our Contributing Guidelines (CONTRIBUTING.md) and our Code of Conduct (CODE_OF_CONDUCT.md).

Key ways to contribute:
* Reporting Bugs: Submit detailed bug reports via the project's issue tracker. Include steps to reproduce, WPAUDIT , Python , OS, and relevant logs.
* Suggesting Features: Propose new features or enhancements that would benefit the automated WordPress security capabilities of WPAUDIT. Explain the use case and potential benefits.
* Submitting Pull Requests: Fork the repository, make your changes in a separate feature branch, and submit a pull request with a clear description of your contributions. Please adhere to the guidelines in CONTRIBUTING.md, including coding style (e.g., PEP 8 for Python) and ensure your changes are well-tested. Adding unit tests for new functionality is highly encouraged.

Support the Project

If you find WPAUDIT useful and would like to support its de, consider buying me a coffee!

![Buy Me A Coffee]()

Troubleshooting Common Issues

* Tool Not Found Errors:
* Ensure the external tool (e.g., Nmap, WPScan) is installed correctly and its executable is in your system's PATH.
* Alternatively, specify the full path to the tool's executable in your config.yaml under the tool_paths section.
* the tool key name in config.yaml matches the one used internally by WPAUDIT (see core/tool_checker.py).
* WPScan API Key Issues:
* If WPScan data seems limited, ensure you have a valid WPScan API token specified in config.yaml (api_keys.wpscan) or via the --wpscan-api-token CLI argument.
* Check the WPScan dashboard to ensure your API key is active and has not exceeded its quota.
* Permission Denied Errors:
* Some tools or operations (like Nmap SYN scans or writing to certain directories) may require root/administrator pri. Run WPAUDIT with sudo if necessary and appropriate for your en, but understand the security implications.
* Ensure WPAUDIT has write permissions to the specified output_dir.
* Python Dependency Errors:
* Make sure all Python libraries listed in requirements.txt are installed in your Python en (pip install -r requirements.txt).
* Scan Hangs or Times Out:
* Increase tool-specific timeouts in config.yaml (e.g., wpscan_timeout, nuclei_timeout) if scanning a slow or complex target.
* Check network connectivity to the target.
* A WAF or IPS might be blocking or rate-limiting requests; consider using a "stealth" profile or adjusting rate limits.

Roadmap / Future Enhancements

WPAUDIT is an e project. Potential future enhancements include:
* Ad Reporting: More report formats (e.g., CSV, XML), customizable report templates, and integration with management platforms.
* Scan Resumption: Ability to resume interrupted scans from the last sa.
* Plugin/Theme Specific Checks: Deeper analysis of specific popular plugins/themes for known misconfigurations or beyond what WPScan/Nuclei cover.
* Enhanced WAF/IPS E Techniques: More sophisticated options for stealthy scanning.
* Automated Exploit Chaining (Highly Experimental): Exploring safe ways to test if combined could lead to greater impact.

License

WPAUDIT is released under the MIT License. Please see the LICENSE.txt file for full details.

This tool is intended for legal and ethical use only. The de assume no liability and are not responsible for any misuse or damage caused by this program. Always ensure you ha, written authorization before performing any security testing on a target system.

项目信息

开发语言：Python

Star 数：41

技术要点

该项目属于安全软件方向的开源资源，代码结构清晰，适合安全研究人员学习参考。项目围绕WPAUDIT: Advanced WordPress security auditing suite & vulnerability scanner. Automates pentesting with Nmap, WPScan, Nuclei, SQLMap. Comprehensive reports. Ideal for ethical hackers & Kali Linux.展开，提供了可运行的实现，对理解相关安全机制、工具原理与攻防技术具有较高的研究价值。

从技术实现角度看，此类项目的核心在于对底层原理的深入理解与工程化落地。开发者在研究过程中可以结合官方文档与社区讨论，梳理项目的初始化流程、核心模块职责与数据流转，逐步掌握其中的技术细节与设计思路。

使用与学习建议

1. 下载源码压缩包，解压到本地环境。

2. 根据项目类型准备对应的运行环境与依赖。

3. 按照 README 中的步骤完成配置与部署。

4. 在隔离的测试环境中运行验证，避免影响生产系统。

免责声明

本资源来源于开源社区，仅供安全研究、技术学习与合法授权范围内的攻防演练使用，请勿用于任何非法或侵害他人权益的用途。使用本项目产生的一切后果由使用者自行承担。