WordPress security audit
A defensive checklist-driven review for WP plugin and theme PHP. Goal:
catch the boring, repeatable mistakes that ship to production because no
one ran through the basics. This is not a substitute for a real
security review of cryptography, business logic, or third-party deps.
When to use this skill
Trigger this skill when ANY of the following is true:
- The user asks for a security review, audit, or "is this safe".
- The diff or file under discussion contains:
$_GET, $_POST,
$_REQUEST, $_COOKIE, $_FILES, $_SERVER, wp_unslash,
wp_verify_nonce, check_admin_referer, current_user_can,
add_action( 'wp_ajax, add_action( 'admin_post,
register_rest_route, $wpdb->, update_option, update_user_meta,
wp_redirect, wp_safe_redirect, file_get_contents, move_uploaded_file.
- The user is preparing a plugin for release or wp.org submission.
- The user is reviewing a contributor's PR.
How to run the audit
Work through the Critical checks below in order. For each finding:
- State the file and line.
- Name the issue using its conventional WP terminology
(e.g. "missing nonce", "unescaped output", "broken access control").
- Show the offending code (1–3 lines).
- Show the fix.
- Mark severity: HIGH (exploitable now), MEDIUM (exploitable under
conditions), LOW (hardening / best practice).
Do NOT silently rewrite the file. Produce a report first; only edit if the
user asks you to apply fixes.
Critical checks
1. Nonce verification on state-changing requests
Any handler that writes (saves option, updates meta, deletes a post,
sends an email, mutates anything) must verify a nonce.
- Forms:
wp_nonce_field( 'action_name', '_wpnonce' ) →
check_admin_referer( 'action_name' ) in handler.
- AJAX:
wp_create_nonce( 'action_name' ) → check_ajax_referer( 'action_name', 'nonce' ).
- REST: rely on cookie auth + the built-in
_wpnonce (wp-api nonce) for
logged-in routes; for permission_callback use a real capability check.
Common mistake: verifying the nonce inside an if whose else branch
still does the write. The nonce check must short-circuit.
2. Capability checks (authorization)
Authentication ≠ authorization. A logged-in subscriber is still a user.
- Admin actions:
current_user_can( 'manage_options' ) or a more
specific capability (edit_posts, edit_post with object ID,
manage_woocommerce etc.).
- Object-level actions MUST pass the object ID:
current_user_can( 'edit_post', $post_id ) — the ID-less form is wrong.
- REST
permission_callback must NEVER be __return_true for
state-changing routes. Returning true unconditionally is the #1 plugin
vulnerability pattern on wp.org.
3. Input: unslash → sanitize → validate
WordPress magically slashes superglobals. The pipeline is fixed:
$raw = isset( $_POST['email'] ) ? wp_unslash( $_POST['email'] ) : '';
$email = sanitize_email( $raw );
if ( ! is_email( $email ) ) { /* reject */ }
- Missing
wp_unslash before sanitization → escaped quotes leak through.
- Wrong sanitizer for the data type. Map by intent:
- text field:
sanitize_text_field
- textarea:
sanitize_textarea_field
- email:
sanitize_email
- URL:
esc_url_raw (storage) / esc_url (output)
- key/slug:
sanitize_key, sanitize_title
- integer:
absint or (int) with range check
- HTML allowed:
wp_kses_post or wp_kses with explicit allowlist
- file path:
sanitize_file_name + realpath containment check
- Never trust
$_SERVER['HTTP_*'] headers without sanitizing; they're
attacker-controlled.
4. Output escaping (XSS)
Escape at the point of output, in the right context:
- HTML body:
esc_html( $x )
- HTML attribute:
esc_attr( $x )
- URL in
href/src: esc_url( $x )
- Inside
<script> JSON: wp_json_encode( $x ), never raw concatenation
- Translated strings with placeholders: escape the template AND
the substituted value separately.
esc_html__() only escapes
the static template; printf( esc_html__( '%s', 'td' ), $name ) is
XSS if $name contains markup. Correct form:
printf( esc_html__( 'Hello, %s', 'td' ), esc_html( $name ) ).
- Already-HTML content (post content):
wp_kses_post( $x )
echo $foo; where $foo came from input or DB without escaping → XSS.
This is the most common finding in plugin audits.
5. SQL: always prepare
// WRONG
$wpdb->get_results( "SELECT * FROM x WHERE id = $id" );
// RIGHT
$wpdb->get_results( $wpdb->prepare( "SELECT * FROM x WHERE id = %d", $id ) );
%d integers, %f floats, %s strings. Table/column names CANNOT be
parameterized — validate against an allowlist before interpolating.
LIKE needs $wpdb->esc_like() BEFORE prepare():
$like = '%' . $wpdb->esc_like( $term ) . '%';
- Prefer WP_Query / get_posts / get_users over raw SQL where possible.
6. AJAX endpoints
Two hooks, two meanings — confuse them and you ship a vulnerability:
wp_ajax_{action} — fires only for logged-in users.
wp_ajax_nopriv_{action} — fires for logged-out users.
Rules:
- Register
nopriv ONLY if the feature is genuinely meant for guests
(e.g. public search, login form). Never copy-paste both registrations
"to be safe".
- Both handlers still need
check_ajax_referer().
- The
nopriv handler must NOT perform actions that only logged-in users
should do (saving prefs, accessing other users' data, etc.).
- End with
wp_send_json_success / wp_send_json_error, not echo + die.
7. admin-post and form handlers
admin_post_{action} and admin_post_nopriv_{action} follow the same
rules as AJAX. Plus: redirect with wp_safe_redirect() + exit;. Never
redirect with wp_redirect( $_GET['redirect_to'] ) without validating
against an allowlist — that's an open-redirect.
8. REST API routes
register_rest_route( 'myplugin/v1', '/save', [
'methods' => 'POST',
'callback' => 'myplugin_save',
'permission_callback' => function () {
return current_user_can( 'manage_options' );
},
'args' => [
'id' => [
'required' => true,
'validate_callback' => 'is_numeric',
'sanitize_callback' => 'absint',
],
],
] );
Findings to flag:
permission_callback missing, or __return_true on a non-public route.
- No
args schema — input is unsanitized.
- Returning raw DB rows including sensitive columns (
user_pass,
user_activation_key, private meta).
9. File operations
- Uploads: validate MIME via
wp_check_filetype_and_ext(), store via
wp_handle_upload(), never trust the client-provided extension or MIME.
- Path joins with user input: after building,
realpath() and check the
result starts with the intended base dir. Otherwise: path traversal.
- Never
include / require a path containing user input.
10. Secrets and information disclosure
- No API keys or DB credentials in the plugin source. Use options or
constants in
wp-config.php.
WP_DEBUG_DISPLAY should be off in prod; flag any var_dump,
print_r, error_log( $sensitive ) left in handlers.
- Don't leak stack traces, full SQL, or user enumeration via error
messages ("user not found" vs "wrong password" — pick one).
11. Redirects
- Use
wp_safe_redirect() for any URL that may be influenced by input.
- Always
exit; after a redirect — execution continues otherwise.
12. Cron and background jobs
wp_schedule_event callbacks run with no current user. If the job
performs privileged work, do not trust any "stored intent" without
re-validating; treat persisted user input as untrusted.
What this skill does NOT cover
- Cryptographic correctness (key derivation, signing schemes).
- Business-logic flaws (race conditions, IDOR beyond capability checks).
- Third-party library CVEs — run
composer audit separately.
- Frontend JS XSS — different skill.
- Server / hosting hardening (file perms, disable_functions, etc.).
- Object injection, SSRF, CSRF on GET, mass assignment, file include,
mail/zip injection, timing comparison, TOCTOU races — these are
covered by
wp-security-deep. Run it after this one.
- Hardcoded credentials, weak randomness for tokens, password
storage, cookie flags, secrets in logs — covered by
wp-security-secrets. Run it whenever auth or third-party
integrations are in scope.
State this scope explicitly in the report. If the reviewed code
clearly falls into one of the deeper categories above, recommend the
appropriate skill in the report's footer.
Report format
# Security audit: <plugin name>
Scope: <files reviewed>
Date: <YYYY-MM-DD>
## HIGH
1. <file>:<line> — <issue>
<code>
Fix: <code>
## MEDIUM
...
## LOW / Hardening
...
## Out of scope
- <thing not checked>
References
1---2name: wp-security-audit3description: Audits WordPress plugin or theme PHP code for the most common4 security mistakes — missing nonce checks, capability checks, input5 sanitization, output escaping, unslashing, SQL preparation, AJAX nopriv6 exposure, file/path traversal, and unsafe redirects. Use when reviewing7 pull requests, before releasing a plugin, when the user asks "is this8 secure", or when handling code that touches $_GET / $_POST / $_REQUEST /9 $_COOKIE / $_FILES / $_SERVER, admin-ajax / admin-post, REST endpoints,10 options, user meta, custom DB queries, or file uploads.11author: Soczó Kristóf12contact: mailto:lonsdale201@hotmail.com13plugin: wordpress14plugin-version-tested: "6.0 - 6.9"15php-min: "7.4"16last-updated: "2026-04-28"17docs:18 - https://developer.wordpress.org/apis/security/19 - https://developer.wordpress.org/plugins/security/20 - https://developer.wordpress.org/reference/functions/wp_verify_nonce/21 - https://developer.wordpress.org/reference/functions/current_user_can/22metadata:23 source: https://skillmd.com/skills/vikingokft/wp-security-audit24---2526# WordPress security audit2728A defensive checklist-driven review for WP plugin and theme PHP. Goal:29catch the boring, repeatable mistakes that ship to production because no30one ran through the basics. This is **not** a substitute for a real31security review of cryptography, business logic, or third-party deps.3233## When to use this skill3435Trigger this skill when ANY of the following is true:3637- The user asks for a security review, audit, or "is this safe".38- The diff or file under discussion contains: `$_GET`, `$_POST`,39 `$_REQUEST`, `$_COOKIE`, `$_FILES`, `$_SERVER`, `wp_unslash`,40 `wp_verify_nonce`, `check_admin_referer`, `current_user_can`,41 `add_action( 'wp_ajax`, `add_action( 'admin_post`,42 `register_rest_route`, `$wpdb->`, `update_option`, `update_user_meta`,43 `wp_redirect`, `wp_safe_redirect`, `file_get_contents`, `move_uploaded_file`.44- The user is preparing a plugin for release or wp.org submission.45- The user is reviewing a contributor's PR.4647## How to run the audit4849Work through the **Critical checks** below in order. For each finding:50511. State the file and line.522. Name the issue using its conventional WP terminology53 (e.g. "missing nonce", "unescaped output", "broken access control").543. Show the offending code (1–3 lines).554. Show the fix.565. Mark severity: **HIGH** (exploitable now), **MEDIUM** (exploitable under57 conditions), **LOW** (hardening / best practice).5859Do NOT silently rewrite the file. Produce a report first; only edit if the60user asks you to apply fixes.6162## Critical checks6364### 1. Nonce verification on state-changing requests6566Any handler that *writes* (saves option, updates meta, deletes a post,67sends an email, mutates anything) must verify a nonce.6869- Forms: `wp_nonce_field( 'action_name', '_wpnonce' )` →70 `check_admin_referer( 'action_name' )` in handler.71- AJAX: `wp_create_nonce( 'action_name' )` → `check_ajax_referer( 'action_name', 'nonce' )`.72- REST: rely on cookie auth + the built-in `_wpnonce` (`wp-api` nonce) for73 logged-in routes; for `permission_callback` use a real capability check.7475**Common mistake:** verifying the nonce inside an `if` whose `else` branch76still does the write. The nonce check must short-circuit.7778### 2. Capability checks (authorization)7980Authentication ≠ authorization. A logged-in subscriber is still a user.8182- Admin actions: `current_user_can( 'manage_options' )` or a more83 specific capability (`edit_posts`, `edit_post` with object ID,84 `manage_woocommerce` etc.).85- Object-level actions MUST pass the object ID:86 `current_user_can( 'edit_post', $post_id )` — the ID-less form is wrong.87- REST `permission_callback` must NEVER be `__return_true` for88 state-changing routes. Returning `true` unconditionally is the #1 plugin89 vulnerability pattern on wp.org.9091### 3. Input: unslash → sanitize → validate9293WordPress magically slashes superglobals. The pipeline is fixed:9495```php96$raw = isset( $_POST['email'] ) ? wp_unslash( $_POST['email'] ) : '';97$email = sanitize_email( $raw );98if ( ! is_email( $email ) ) { /* reject */ }99```100101- Missing `wp_unslash` before sanitization → escaped quotes leak through.102- Wrong sanitizer for the data type. Map by intent:103 - text field: `sanitize_text_field`104 - textarea: `sanitize_textarea_field`105 - email: `sanitize_email`106 - URL: `esc_url_raw` (storage) / `esc_url` (output)107 - key/slug: `sanitize_key`, `sanitize_title`108 - integer: `absint` or `(int)` with range check109 - HTML allowed: `wp_kses_post` or `wp_kses` with explicit allowlist110 - file path: `sanitize_file_name` + `realpath` containment check111- Never trust `$_SERVER['HTTP_*']` headers without sanitizing; they're112 attacker-controlled.113114### 4. Output escaping (XSS)115116Escape **at the point of output**, in the right context:117118- HTML body: `esc_html( $x )`119- HTML attribute: `esc_attr( $x )`120- URL in `href`/`src`: `esc_url( $x )`121- Inside `<script>` JSON: `wp_json_encode( $x )`, never raw concatenation122- Translated strings with placeholders: escape the **template** AND123 the **substituted value** separately. `esc_html__()` only escapes124 the static template; `printf( esc_html__( '%s', 'td' ), $name )` is125 XSS if `$name` contains markup. Correct form:126 `printf( esc_html__( 'Hello, %s', 'td' ), esc_html( $name ) )`.127- Already-HTML content (post content): `wp_kses_post( $x )`128129`echo $foo;` where `$foo` came from input or DB without escaping → XSS.130This is the most common finding in plugin audits.131132### 5. SQL: always prepare133134```php135// WRONG136$wpdb->get_results( "SELECT * FROM x WHERE id = $id" );137138// RIGHT139$wpdb->get_results( $wpdb->prepare( "SELECT * FROM x WHERE id = %d", $id ) );140```141142- `%d` integers, `%f` floats, `%s` strings. Table/column names CANNOT be143 parameterized — validate against an allowlist before interpolating.144- `LIKE` needs `$wpdb->esc_like()` BEFORE `prepare()`:145 `$like = '%' . $wpdb->esc_like( $term ) . '%';`146- Prefer WP_Query / get_posts / get_users over raw SQL where possible.147148### 6. AJAX endpoints149150Two hooks, two meanings — confuse them and you ship a vulnerability:151152- `wp_ajax_{action}` — fires only for **logged-in** users.153- `wp_ajax_nopriv_{action}` — fires for **logged-out** users.154155Rules:156- Register `nopriv` ONLY if the feature is genuinely meant for guests157 (e.g. public search, login form). Never copy-paste both registrations158 "to be safe".159- Both handlers still need `check_ajax_referer()`.160- The `nopriv` handler must NOT perform actions that only logged-in users161 should do (saving prefs, accessing other users' data, etc.).162- End with `wp_send_json_success` / `wp_send_json_error`, not `echo` + `die`.163164### 7. admin-post and form handlers165166`admin_post_{action}` and `admin_post_nopriv_{action}` follow the same167rules as AJAX. Plus: redirect with `wp_safe_redirect()` + `exit;`. Never168redirect with `wp_redirect( $_GET['redirect_to'] )` without validating169against an allowlist — that's an open-redirect.170171### 8. REST API routes172173```php174register_rest_route( 'myplugin/v1', '/save', [175 'methods' => 'POST',176 'callback' => 'myplugin_save',177 'permission_callback' => function () {178 return current_user_can( 'manage_options' );179 },180 'args' => [181 'id' => [182 'required' => true,183 'validate_callback' => 'is_numeric',184 'sanitize_callback' => 'absint',185 ],186 ],187] );188```189190Findings to flag:191- `permission_callback` missing, or `__return_true` on a non-public route.192- No `args` schema — input is unsanitized.193- Returning raw DB rows including sensitive columns (`user_pass`,194 `user_activation_key`, private meta).195196### 9. File operations197198- Uploads: validate MIME via `wp_check_filetype_and_ext()`, store via199 `wp_handle_upload()`, never trust the client-provided extension or MIME.200- Path joins with user input: after building, `realpath()` and check the201 result starts with the intended base dir. Otherwise: path traversal.202- Never `include` / `require` a path containing user input.203204### 10. Secrets and information disclosure205206- No API keys or DB credentials in the plugin source. Use options or207 constants in `wp-config.php`.208- `WP_DEBUG_DISPLAY` should be off in prod; flag any `var_dump`,209 `print_r`, `error_log( $sensitive )` left in handlers.210- Don't leak stack traces, full SQL, or user enumeration via error211 messages ("user not found" vs "wrong password" — pick one).212213### 11. Redirects214215- Use `wp_safe_redirect()` for any URL that may be influenced by input.216- Always `exit;` after a redirect — execution continues otherwise.217218### 12. Cron and background jobs219220- `wp_schedule_event` callbacks run with no current user. If the job221 performs privileged work, do not trust any "stored intent" without222 re-validating; treat persisted user input as untrusted.223224## What this skill does NOT cover225226- Cryptographic correctness (key derivation, signing schemes).227- Business-logic flaws (race conditions, IDOR beyond capability checks).228- Third-party library CVEs — run `composer audit` separately.229- Frontend JS XSS — different skill.230- Server / hosting hardening (file perms, disable_functions, etc.).231- Object injection, SSRF, CSRF on GET, mass assignment, file include,232 mail/zip injection, timing comparison, TOCTOU races — these are233 covered by **`wp-security-deep`**. Run it after this one.234- Hardcoded credentials, weak randomness for tokens, password235 storage, cookie flags, secrets in logs — covered by236 **`wp-security-secrets`**. Run it whenever auth or third-party237 integrations are in scope.238239State this scope explicitly in the report. If the reviewed code240clearly falls into one of the deeper categories above, recommend the241appropriate skill in the report's footer.242243## Report format244245```246# Security audit: <plugin name>247Scope: <files reviewed>248Date: <YYYY-MM-DD>249250## HIGH2511. <file>:<line> — <issue>252 <code>253 Fix: <code>254255## MEDIUM256...257258## LOW / Hardening259...260261## Out of scope262- <thing not checked>263```264265## References266267- Detailed examples of each finding type, before/after: `reference.md`268- Real-world snippets with the fix applied: `examples/`269- WordPress core: [Plugin Security Handbook](https://developer.wordpress.org/plugins/security/)270- Capability map: [Roles and Capabilities](https://wordpress.org/documentation/article/roles-and-capabilities/)