How Ryft tests your APIs

Injects shell metacharacter payloads and confirms execution via a command-output oracle (id/passwd/win.ini) or a time-based delay.

Injects SQLi and XSS payloads into parameters and detects SQL error signatures and unencoded reflection.

Injects LDAP filter metacharacters into parameters/body fields and detects LDAP library/filter errors indicating injection.

Injects NoSQL query operators ($ne/$gt/$regex) into parameters and body fields and detects driver errors or auth-bypass behaviour.

Injects ../ traversal sequences into parameters/body fields and confirms file disclosure via a file-content marker oracle.

Injects template expressions into parameters/body fields and confirms server-side evaluation with an arithmetic oracle, then fingerprints the engine and escalates to code execution.

Submits an XML document declaring an external entity and detects file disclosure (file:///etc/passwd or win.ini) in the response.

Runs an explicit {anon, low-priv, primary} role matrix and proves a monotonicity violation (a lower identity reaching an admin function) with a rejected bogus-token control — never 'anon got 200'. Verb/method-override tampering is aggressive-gated.

Proves cross-identity object access with real harvested ids and the similarity oracle (same-object vs authz-error vs not-found vs different-object) against owner, error-template, decoy and anon controls — across path/query/body/header/cookie carriers.

Learns the object shape, injects privileged / readOnly / sensitive properties, and proves each with an ECHO-DIFF read-back persistence oracle plus a canary negative control. Writes are aggressive-gated and snapshot-then-restored.

Flattens JSON responses to key-paths and flags sensitive-name, third-party and spec-undeclared properties, confirmed with list-vs-detail and anon-vs-owner differentials; empty/null/masked values and the caller's own ids are subtracted.

Tries a tiny curated default-credential set against identified login endpoints; a known-bad control is sent first and a hit must differ toward a concrete auth artifact. Gated behind config.aggressive.

For asymmetric tokens, resolves the server's public key and re-signs with HS256 using each public-key byte representation as the HMAC secret, confirming acceptance against a rejecting control.

Forges unsigned (alg:none) and signature-stripped JWTs and tampers the payload under the original signature, confirming acceptance against a rejecting random-signature control.

Compares an authenticated baseline against no-credential, bogus-bearer, empty-bearer and garbage-cookie identities using the similarity oracle to prove an endpoint serves protected content without valid authentication.

Flags credentials, tokens, API keys or JWTs carried in the URL query string or userinfo, and (aggressive) confirms a header credential is still accepted as a query parameter.

Scans client JavaScript (captured, plus configured bundles in active mode) for hardcoded provider secrets, keys, tokens and private keys, gated by known formats and entropy.

Offline-cracks the HMAC signing secret against a large bundled wordlist (zero network, cannot false-positive); with aggressive mode, mints a token with the cracked secret and confirms the server honors it.

Exploits the 'kid' key-id as a path-traversal/SQLi sink to coerce a known signing key, and points 'jku'/'x5u' at an OAST host to detect SSRF to an attacker-controlled JWKS (confirmed by correlated callout).

Once a signature weakness is confirmed (cracked HMAC secret or alg:none), mints single-claim deltas (expired exp, future nbf/iat, attacker aud/iss, sub/role tamper) to isolate which claim checks the server skips.

On a login endpoint identified from spec/flow/designation only, tests for missing rate-limiting / lockout / CAPTCHA / MFA and username enumeration using a bounded synthetic-credential burst.

Measures session-identifier entropy offline and, with a login flow in aggressive mode, verifies sessions are invalidated on logout / refresh via the rate-limited flow runner.

Points URL-like query params, nested body fields and URL-ish headers at loopback (with filter-bypass encodings), cloud metadata (detect-only), file/gopher/dict schemes and a blind OAST host; confirms via a dead-host control differential and OAST token correlation.

Amplifies a GraphQL endpoint with alias-duplication (<=50) and deep nesting (<=10) versus a __typename baseline; FIRM only when the server processes it without errors AND latency amplifies. Reuses introspection only as a corroborating signal.

Looks for any request-rate control (RateLimit-*/Retry-After/429/503/509). Observational by default; under --aggressive a bounded clean 2xx burst corroborates the absence, with CDN cache-replay downgrade and latency-degradation as a secondary signal.

Wraps a single request into K bounded copies (array / JSON-RPC / GraphQL batch) with per-element canaries and proves the server PROCESSED K units of work. Aggressive-only; 413/400/422 suppress; irreversible money/order/transfer endpoints are deferred (API6).

Builds a median+MAD latency baseline, then injects heavy filter/search/expand/range values and flags only on a robust +absolute+relative threshold with a mandatory repeat-confirm. Fast 400/422 errors and cached responses are discounted.

Proves a page-size knob is uncapped: an absurd limit (100000) both moves the returned element count versus limit=1 AND is honoured with a 2xx, corroborated by body-size scaling. Suppressed on 400/422/413.

Detects reflected / null / wildcard-with-credentials CORS and trust-boundary bypasses (prefix/suffix/subdomain/scheme-downgrade) plus pre-flight method/header widening; credentialed reflection is HIGH/CRITICAL.

Probes a curated set of debug/config/metrics endpoints, each with a content signature, gated by the per-origin not-found baseline to beat SPA catch-all 200s; CRITICAL when secrets leak.

Enumerates advertised methods via OPTIONS and confirms TRACE via an echoed marker (XST). Reports configuration only; authorization impact is left to the BFLA check.

Flags SQL errors, stack traces, framework banners, filesystem paths and internal IPs leaked in responses; actively (non-destructively) provokes errors and only reports signatures absent from a clean baseline.

Grades security headers per response (HSTS max-age, nosniff, CSP, frame/referrer), content-type aware so JSON APIs are not asked for render-only headers; error responses are graded too.

Passively parses Server / X-Powered-By / X-AspNet-Version / X-Runtime headers for a concrete product+version to seed version-specific CVE lookups downstream.

Discovers sibling API versions (/v1,/v2,/internal,/beta,/legacy) and proves the value-add weakness differential — an old version accepting anonymous access where the current one requires auth — de-duping identical-backend aliases by body hash.

Probes Swagger/OpenAPI/GraphQL documentation paths and confirms the body actually parses as a spec (importers.detect; GraphQL __schema) before reporting — a published dev portal is downgraded to INFO.

Synthesizes sibling env hostnames (dev./staging./qa./uat.), requires them to resolve and serve an API-shaped body (not a parked page), and reports the weakness differential vs prod — suppressing same-body CDN aliases and honouring explicit scope denials.

Classifies sensitive state-changing flows (signup/login/reset/coupon/invite/add-to-cart/checkout/transfer) and detects the ABSENCE of anti-automation (CAPTCHA / step-up / 429 / rising friction). Observational (TENTATIVE) by default; under --aggressive a bounded distinct-input replay proves it FIRM. The irreversible money/order/transfer COMMIT is never driven, even aggressively.

Finds consumed-URL params (webhook/callback/discovery/import/avatar fetchers) and points one at the operator's own OAST host with a unique nonce. Proves the server blindly consumes the upstream via an OAST interaction correlated to that nonce, reflection of the nonce in the server's own response (upstream-data trust), or a plaintext callback where TLS was offered (no pinning). OAST-correlated only — the whole check INFO-skips when no OAST host is configured.

Passively scans response bodies for PII and secrets (SSNs, cards, keys, tokens, password fields).

Coaxes the model to emit active markup and flags when the API reflects LLM output unsanitized into an HTML/JS sink (XSS/SSRF).

Sends guardrail-bypass templates (DAN / developer-mode / persona-split) and flags responses that emit bypass-confirmation signals.

Detects LLM-backed endpoints (text/prompt field or chat body) and injects a unique canary token with an instruction to echo it; a reflected canary proves the injected instruction ran.

Coaxes the model to reveal secrets/PII from its context and flags responses that contain credential or PII patterns not present in the probe.

Stores indirect-injection markers in user-supplied text an LLM likely reprocesses; flags when the marker is persisted/reflected, creating a second-order injection sink.

Sends extraction probes that ask the model to reveal its system/developer prompt and flags responses that contain system-prompt-like leak markers.