WP Auditory analyzes technical vulnerabilities, misconfigurations, data exposure, and structural risks that could compromise the security, reputation, and functionality of a website. Below are the main problems that can be identified:
Files such as wp-config.php, .env, or backups (.zip, .sql) are publicly accessible.
Server configurations that do not block direct access to these files.
Risk of hacker attack: Leakage of database credentials, secret keys, and source code, allowing complete takeover of the site (intrusion, data theft).
Without a patch, an attacker can download these files and compromise the entire system, leading to data loss, defacement, or ransomware. It’s a basic and common vulnerability exploited by automated bots.
The server displays the contents of folders (e.g., /wp-content/uploads/) when there is no index file.
Default server configuration without blocking (Options +Indexes in Apache).
Enumeration of sensitive files, backups, or hidden configurations, facilitating targeted attacks.
It reveals the site’s structure, allowing hackers to find weaknesses to exploit (e.g., shell uploads via exposed directories). It’s an open door for reconnaissance.
The .git folder (containing code history) is publicly accessible.
Incorrect deployment or lack of server lockout.
Risk of hacker attack: Complete download of source code, including hardcoded passwords, API keys, and old commits.
It exposes all the website’s code, allowing reverse engineering and custom exploits. This can lead to leaks of sensitive data or backdoors.
There is a lack of protection against the site being loaded in an iframe from another domain.
Security headers not configured on the server.
Risk of hacker attack: Clickjacking (overlaying iframes to steal clicks, such as logins or payments).
It protects users from advanced phishing where the real website is used to deceive actions. It’s a basic measure against UI redressing.
It does not force the browser to use only HTTPS for future connections.
Header not added on the HTTPS server.
Risk of hacker attack: Downgrade attacks (forcing HTTP to intercept traffic on public Wi-Fi networks).
It ensures that traffic remains encrypted, preventing man-in-the-middle (MITM) attacks and the theft of sensitive data such as passwords.
It does not prevent the browser from guessing the file type (MIME sniffing).
Header not configured.
Risk of hacker attack: XSS attacks via uploaded files that are misinterpreted (e.g., image as a script).
It prevents the exploitation of malicious uploads, reducing the risk of code injection into browsers.
It does not control the sending of source information (referrers) to other websites.
Default header not defined.
Risk of hacker attack: Leakage of sensitive URLs (e.g., containing tokens) to third parties.
It protects privacy and prevents tracking or exploitation of leaked internal links.
It does not define rules for loading resources (scripts, styles), or allow ‘unsafe-inline’ elements.
Header not implemented or misconfigured.
High exposure to XSS (malicious script injection).
It drastically reduces injection attacks, protecting users from data theft via malicious JavaScript.
The header server reveals the server name/version (e.g., Apache/2.4).
Default server configuration.
It facilitates known exploits for specific versions.
It reduces fingerprinting, making it more difficult for hackers to choose targeted attacks.
The server allows methods such as TRACE or PUT in addition to GET/POST.
Default configuration with no restrictions.
Leak of headers (TRACE) or malicious upload (PUT).
It avoids the overuse of unnecessary methods, reducing the attack surface.
Meta tags or query strings reveal the WordPress version.
Standard WP functionality.
Attacks targeting known vulnerabilities in that version.
It makes reconnaissance more difficult, giving time to update the WP without becoming an immediate target.
REST API exposes unauthenticated users.
WP REST API is enabled by default.
Brute-force attacks on real logins (e.g., admin).
Protects against automated credential attacks, reducing the risk of intrusion.
The endpoint xmlrpc.php allows remote calls.
Enabled by default in WordPress.
Massive brute-force and DDoS via pingback.
It closes a common gateway for amplified attacks, improving performance and security.
Accessible standard WP files, revealing version.
Not removed or blocked after installation.
It facilitates the identification of vulnerable versions.
It reduces fingerprinting on WP, making it more difficult for automatic scanners.
Traffic sent without encryption.
SSL certificate not installed or configured.
Interception of data (passwords, cookies) via MITM.
It protects data in transit, improves SEO, and prevents browser warnings.
Users can access via HTTP without redirection.
Missing rewrite rule.
Downgrade to insecure HTTP.
It guarantees encryption at all times, preventing MITM attacks on public networks.
URL parameters redirect to arbitrary external websites.
Weak validation in redirect codes.
Phishing or token theft via malicious redirects.
It prevents the site from being used as a vector for scams or credential attacks.
The server responds to the TRACE, echoing headers.
Default configuration without disabling.
Cookie leak via XST (Cross-Site Tracing).
Closes loophole for protected data theft (HttpOnly cookies).
Allows broad cross-origin access with credentials.
CORS headers are incorrectly configured.
Data theft via JavaScript from other websites.
Protects APIs and sensitive data from unauthorized reading.
No SPF or no -all (hard fail).
DNS not configured for emails.
Email spoofing (phishing emails pretending to be from your own domain).
Prevents domain abuse for spam/phishing, improving deliverability and LGPD compliance.
Without DMARC or with p=none/quarantine (does not reject).
Lack of advanced DNS configuration.
Fake emails sent pretending to be from you.
Blocks spoofing, protecting reputation and users from fraud.
No digital signature for emails.
Email provider not configured.
Emails altered in transit without detection.
It ensures the integrity of emails, reducing spam and spoofing.
Files or directories with excessive permissions (e.g., 777, 666).
Manual deployment, misconfigured shared hosting.
Allows unauthorized writing → backdoor or webshell upload.
Incorrect permissions make it easier for the code to be maliciously modified.
Publicly accessible administrative area without an additional layer.
Targeted brute force.
Even with a strong password, it reduces automated attacks.
It does not control features such as camera, microphone, or geolocation.
Abuse of modern browser APIs.
Cookies without Secure, HttpOnly and SameSite.
Session hijacking via XSS or MITM.
/wp-json/
Customized routes
Plugins exposing insecure endpoints
Exposure of sensitive data via custom endpoints.
wp-cron.php is accessible externally.
Abuse to overload the server.
The server executes .php files inside /uploads.
Remote webshell.
/backup/
/old/
/dev/
/test/
Bots search for these folders.
Subdomain pointing to a non-existent service (e.g., the former Heroku).
The striker registers the service and takes over the subdomain.
DNS servers are not protected against spoofing.
Domain hijack.
The server accepts unlimited requests.
Brute force and mild DDoS attacks.
Logged-in pages are being stored in the public cache.
Session leak.
The phpinfo.php file is accessible.
Full exposure of the server configuration.
The server accepts TLS 1.0 or 1.1.
Downgrade attacks and weak encryption.
Insecure ciphers enabled.
Decryption attacks.
Certificate with less than 15 days remaining.
The site crashed unexpectedly.
HTTPS page loading HTTP resources.
MITM via insecure assets.
The site has a user with the login name “admin”, which is the default WordPress username in older installations.
It facilitates brute force attacks and credential stuffing, since the attacker already knows half of the credentials (the login). Automated bots try thousands of combinations starting from the “admin” user.
It significantly reduces automated attacks. When login is predictable, simply cracking the password is enough. Changing the user removes a common vector exploited by mass scanners.
Users with weak passwords (e.g., 123456, admin123, name+year).
Dictionary attacks and credential stuffing can gain access quickly, especially when combined with previous data breaches.
Even with firewalls and security measures, weak passwords are the primary vector for WordPress intrusions. Most hacked sites suffer from weak credentials—not from advanced technical flaws.
Plugin installed without update for more than 2 years or removed from the official repository.
Known vulnerabilities can be exploited publicly. Automated exploits often target discontinued plugins.
Abandoned plugins do not receive security patches. Maintaining such a plugin is like leaving a permanently open door for future intrusions.
Themes installed, but not active.
Even when deactivated, files remain accessible on the server. Vulnerabilities in the theme can be exploited directly via URL.
Reduces the attack surface. If not in use, it should not remain in the production environment.
Debug mode enabled in a public environment.
Displaying error messages with:
Absolute paths
SQL Queries
Internal structure of the system
Plugin information
It facilitates reverse engineering and targeted exploitation. Insider information helps the attacker to accurately map vulnerabilities.
PHP errors reveal the full server path.
It helps in building custom payloads, exploring LFI (Local File Inclusion), and other advanced techniques.
It reduces fingerprinting and prevents attackers from obtaining internal information about the environment.
Tables use the standard prefix wp_.
It facilitates automated SQL Injection scripts that assume default table names.
It doesn’t prevent SQLi, but it makes massive automated attacks that rely on predictable structures more difficult.
Bank user with permissions such as GRANT ALL or full administrative access.
If SQL Injection is present, the attacker can:
Create new users
Clear database
Perform destructive operations
Applying the principle of least privilege limits the impact of a potential failure.
Door 3306 open for external access.
Brute force attempts directly targeting MySQL or exploiting service vulnerabilities.
The database should only accept connections locally or via a restricted IP address.
Absence of a filtering layer between the visitor and the server.
Attacks such as:
SQL Injection
XSS
Automated exploits
Mild DDoS
WAF blocks attacks before they reach WordPress, drastically reducing risk and server load.
The system accepts unlimited login attempts.
Massive brute force attack until the correct password is found.
Limiting attempts prevents automated attacks from testing thousands of combinations.
Login depends solely on the password.
If the password is leaked, access is immediate.
2FA adds an extra layer, blocking intrusions even with a compromised password.
URL parameters are displayed without sanitization.
Execution of malicious scripts in the victim’s browser, which may steal cookies or redirect to phishing sites.
Protects users against session hijacking and content manipulation.
User inputs not validated before querying the database.
Extracting or modifying data from the database.
SQL Injection is one of the most critical vulnerabilities according to OWASP, and can completely compromise a website.
The server’s real IP address is easily discovered.
Bypassing CDN firewalls and direct attacks on the server.
Hiding your IP address protects against direct attacks and DDoS attacks.
cPanel, Plesk, or a publicly accessible panel.
Administrative brute force.
The panel is a critical port — it must have a restricted IP address or mandatory 2FA.
Port 22 open without rate limit or fail2ban.
Brute force attack on SSH credentials.
Compromised SSH means complete control of the server.
No system to detect file changes.
Backdoors can remain hidden for months.
It allows for the rapid detection of intrusions.
Manual backups or no backups at all.
Ransomware or technical failure can cause total loss.
Backup is the last line of defense.
Logs not stored or analyzed.
Logs enable auditing, investigation, and compliance with the LGPD (Brazilian General Data Protection Law).
External scripts loaded without hash verification.
If the CDN is compromised, a malicious script is executed.
SRI guarantees the integrity of the uploaded resource.
Modern context isolation headers.
Possibility of advanced cross-origin attacks.
Improves insulation and safety in modern applications.
External links opened with target=”_blank” without protection.
External page may alter original tab.
Protects users against indirect phishing.
HSTS is active, but not included in the global preload list.
Initial access may occur via HTTP.
It guarantees HTTPS even before the first connection.
Headers allow public caching of sensitive content.
Private data can be stored improperly.
Prevents data leaks via proxy/cache.
AJAX or REST endpoints exposed without authentication.
Extraction of data or execution of improper actions.
Every API should require proper authentication and validation.
⚠️ The presence of one or more of these problems can put the website at risk of hacking, data leaks, loss of sales, or legal penalties. WP Auditory identifies these flaws and offers specialized remediation.