AI search engine and MCP server for bots and agents. One Rust binary indexes code, docs, logs, JSONL/CSV and PDFs for BM25 full-text, vector and hybrid search, code search without grep, agent memory and RAG. Elasticsearch-compatible API; Corpus Hub serves hundreds of reference memory corpora.
The WordPress authentication & authorization story (all entry surfaces)
WordPress accreted four request-entry surfaces over 20 years, and an auth audit
has to cover all of them — a check that's correct for AJAX means nothing if the
same operation is reachable unguarded over REST or XML-RPC. This is the
consolidated story: the model, every surface, the specific failure classes
(missing / insufficient / broken-== / race), and the honest verdict — with the
XERJ-vs-plain-tooling cost measured.
The model (three independent things)
Every state change needs all three; conflating them is the #1 WP auth bug:
- Authentication — who (auth cookie /
wp_authenticate). - Authorization — allowed? — a capability bound to the object:
current_user_can('edit_post', $post->ID), not a genericcurrent_user_can('edit_posts'). - Intent — did they mean it? — a nonce / CSRF token.
check_ajax_refererverifies intent, NOT authorization — a Subscriber holds valid nonces.
The four surfaces, audited (from XERJ facts)
| surface | entry points | auth posture | verdict |
|---|---|---|---|
AJAX (wp_ajax_*) |
97 | object-scoped cap + nonce; a few self-scoped (prefs) need no cap | 0 IDOR |
REST (register_rest_route → *_permissions_check) |
107 checks | object-scoped meta-cap one hop into check_*_permission($obj); create_* uses generic caps correctly (no object yet) |
0 IDOR |
admin-post / direct wp-admin |
41 file-scope handlers | object-scoped cap + check_admin_referer, guards in shared preamble/fall-through |
object-scoped |
XML-RPC (class-wp-xmlrpc-server) |
106 methods | 66 call login(), 68 cap-check |
see below |
XML-RPC specifics (the oldest, riskiest surface)
- Unauthenticated methods are the known set and intentional:
pingback.*(→ SSRF/DoS, and it hits Finding 1's169.254gap viawp_safe_remote_request),demo.sayHello/addTwoNumbers(harmless),mt.supportedMethods/supportedTextFilters(public info).blogger.getTemplate/setTemplateare disabled (IXR_Error 403). - The structural weakness — brute-force amplification: every authenticated
method calls
$this->login($user,$pass)(username/password, no per-call rate limit or nonce), andsystem.multicallbatches many calls into one HTTP request → hundreds of credential guesses per request. This is by-design and the reason hardened sites disable XML-RPC. Not a code bug — an architectural exposure.
The specific failure classes (what we looked for)
| class | method | result in core |
|---|---|---|
| Missing permission check | every state-changing entry point, all surfaces | none — all gated |
| Insufficient (generic cap on a specific object → IDOR) | has_obj_cap vs has_generic_cap, interprocedural + check-vs-use |
none — object-scoped meta-caps; the one risky shape (revisions) has an explicit parent_id_mismatch guard |
Broken == (loose compare / magic-hash in auth) |
wppatterns loose-eq/timing-compare ∩ auth files |
none — the loose-== hits in auth files are Akismet status-string compares ('spam' == $status), benign; core secrets use wp_check_password / hash_equals |
| Race / TOCTOU in auth | check-then-use in privileged paths | none found in core; note: WP nonces are reusable within their 12–24h window (documented property, not a race), and object-scoped current_user_can is synchronous |
map_meta_cap fail-open |
the authz engine | fails closed (do_not_allow on missing object/arg) |
Honest verdict
Across all four surfaces, WordPress core's authorization is consistently
object-scoped and fail-closed; no missing, insufficient, broken-==, or race
auth flaw was found. The real exposures are architectural, not code bugs:
XML-RPC brute-force amplification and pingback SSRF (both mitigated by disabling
XML-RPC), and the SSRF range gap (Finding 1). The lesson the census makes provable:
the same operation must be checked identically on every surface — that's what
plugins get wrong, and what this multi-surface sweep is built to catch.
XERJ vs plain tooling (measured, this audit)
| approach | tokens | quality |
|---|---|---|
| grep + read the 50 handler files (AJAX + REST + XML-RPC + admin) | ~335,500 | must hand-trace each cap check across files; exceeds a context window |
XERJ — auth-posture facts for all 310 entry points (has_obj_cap/has_nonce/caps) |
~6,600 | structured posture per entry point, one query per surface, reusable |
~51× fewer tokens, and it answers the cross-surface question directly ("which
entry points change state with only a generic cap?") — which grep can't express.
The full authz reasoning behind each verdict is in
wordpress-authz-agentic-audit.md.