Volume IV - Authentication and Access Control
Most serious web vulnerabilities are not caused by malformed syntax. They happen because the application answers the wrong access-control question. This volume is about comparison testing: the same action, a different identity, and an expected policy. If the action succeeds for an identity the policy should deny, you have a candidate authorization flaw.
Chapter 1 - The Access-Control Model
1.1 Authentication versus authorization
| Concept | Question | Example failure |
|---|---|---|
| Authentication | Who are you? | Login accepts weak or forged creds. |
| Session management | How is identity remembered? | Token is predictable or not revoked. |
| Authorization | What may this identity do? | A user reads another user's order. |
1.2 The boundaries
- Object boundary: can user A access user B's objects?
- Function boundary: can a low-privilege user call an admin function?
- Data boundary: does a response leak fields that should be hidden?
- Workflow boundary: can a user skip approval, payment, or verification?
Common failure patterns are IDOR (an object ID is changed and
ownership is not checked), vertical and horizontal privilege escalation,
mass assignment (submitting role=admin or
owner_id), method confusion (GET denied but PUT allowed),
and state confusion (an action works out of order). Always know the
identity, object, action, and expected policy before calling something
vulnerable. Do not confuse a hidden UI button with server-side
authorization: if the endpoint accepts the low-privilege request, the
check is broken.
Chapter 2 - Multi-Identity Testing
Authorization testing requires at least two identities: an owner, a peer, an admin, and often an anonymous session. Fissure keeps them separated and labeled so their traffic stays comparable.
2.1 PwnFox-style tagging
When a browser stamps each request with an identity header (the
de-facto X-PwnFox-Color, or the
X-Fissure-Identity alias), Fissure reads it, strips it
before forwarding to the target, and tags the captured flow with that
identity in the Proxy grid's Ident column. Use a Firefox multi-account
or container extension (or any header-setting extension) to color
requests per identity. Fissure ships no browser code; the browser side
is documented. Each color's credential can then become an identity in
the Auth matrix.
2.2 A session inventory
| Session | Purpose | Evidence note |
|---|---|---|
| Anonymous | Unauthenticated baseline. | What does the public see? |
| User A | Object owner. | Own records and normal actions. |
| User B | Peer account. | Should not see user A's records. |
| Admin/manager | Privileged baseline. | Functions normal users cannot reach. |
| Expired/stale | Session-handling edge case. | How does the app fail? |
The comparison workflow: browse a feature as the owner, then as a peer; send both requests to the Repeater; swap only the identity material first, then the object identifier; and compare status, length, JSON keys, and business impact in the Comparer.
2.3 Keeping a long scan authenticated (mid-scan re-authentication)
A long authenticated scan is worthless if the session dies half-way
through and every later request silently drops to unauthenticated,
hiding the findings behind the login. Fissure re-establishes the session
in flight. Give the scan a login config (--login on the
CLI, the login object over the control API / MCP, or the
Settings login config) and add a reauth_on_contains field:
a substring that appears only on the logged-out or login page (for DVWA,
Login :: Damn Vulnerable; for a plain form,
name="password"). When a scanned response contains that
marker, the engine replays the login into the same jar and retries the
request once. This matters because the common logout is a redirect to
the login page (a 200 login form), which a plain "re-auth on 401" rule
would miss. Fissure also ships a "Re-auth on 401" session rule for the
case where an endpoint answers 401 once the session lapses, but it is
off by default, so enable it when you want a bare 401 to trigger re-auth
as well. The same mechanism is what the "Expired/stale" session row
above is really testing: how the app fails, and whether your tooling
notices.
2.4 Recording a login instead of writing one (the macro recorder)
Section 2.3 assumes you already have a login config to hand the scan. Writing one by hand is fiddly: you transcribe every step's method, URL, headers, and body, and worst of all you find each anti-CSRF token, work out where the server issued it, and write a regex that re-derives a fresh one on every replay. Get the token handling wrong and the login silently fails, dropping the whole authenticated scan back to anonymous. The login/macro recorder builds that config for you from traffic you have already captured, so it is the easier alternative to hand-writing the login config.
How it works. Log in once through the proxy so the exchange sits in
the Proxy grid: the login page GET (whose response carries the hidden
CSRF token) and the credential POST that submits the username, password,
and that token. Multi-select those flows in the Proxy grid (Ctrl-click
or Shift-click) and press Record login. Fissure turns each selected flow
into a step, in chronological order, and auto-detects the dynamic
tokens: any request value long enough to be a token that also appears in
an earlier response is rewritten into a {{name}}
placeholder, and a context-anchored regex extract is added to that
earlier step so replay pulls a fresh value. Credentials stay literal,
because a password never appears in a prior response, so it is not
mistaken for a token (the recorder substitutes the whole
name=value, so password=password rewrites the
value, not the field name). You are prompted for a name, and the config
is saved to <config>/logins/<name>.json in the
same schema the CLI, the scan routes, and the session rules already
consume.
Using it. Feed the saved config to an authenticated run:
- CLI:
fissure scan <target> --login <config>/logins/<name>.json. - Control API / MCP: the
loginobject on/api/scans(orstart_scan). - Session rules: reference it so the engine re-runs it on session expiry (2.3).
Headless, the same thing is one call:
record_login(name, exchanges, verify="Logout") over the MCP
bridge (or POST /api/macro/record), where
exchanges is the ordered list of
{method, url, content_type?, req_body?, resp_body?} you
gathered (typically a send_request GET of the login page,
keeping its response body, then the credential POST). It returns the
ready config and a login object you feed
straight into a scan.
The login-replay verify anchor. A login that "ran" is not the same as
a login that worked. Give the recorder a marker that appears only on a
logged-in page and it adds a verify block (a
url plus a contains string) to the config; on
replay the engine fetches that URL and confirms the marker is present
before trusting the session. The headless recorder takes it directly
(verify="Welcome, alice"); the Proxy button records without
one, so add a verify anchor by editing the saved JSON's
verify block or by recording headless with
verify=. The same marker idea drives mid-scan
re-authentication through reauth_on_contains (2.3): the
verify anchor proves the login worked once, and the re-auth marker
re-runs it whenever the session later drops.
Worked example (DVWA). Browse the DVWA login through the proxy: GET
/login.php (its response contains the hidden
user_token field) then POST /login.php with
username=admin, password=password,
user_token=<hex>, and Login=Login. In
the Proxy grid, multi-select the GET and the POST, then press Record
login. The recorder emits two steps: step 1 GET /login.php
gains a regex extract that captures user_token from the
response, and step 2 POST /login.php has its body rewritten
to user_token={{user_token}} while
username=admin and password=password stay
literal. Name it dvwa-admin; it is saved to
<config>/logins/dvwa-admin.json. Run
fissure scan http://localhost:8080 --login <config>/logins/dvwa-admin.json:
the scan logs in first, re-derives a fresh token on every attempt, and
stays authenticated. Add verify with
contains: "Logout" so the engine confirms the session
before scanning, and set
reauth_on_contains: "Login :: Damn Vulnerable" (2.3) so it
re-logs in if DVWA drops the session mid-scan.
Chapter 3 - Autorize-Style IDOR: Check Access Control
The Check-access-control action replays a captured authenticated request under a second identity and with credentials removed, then compares the responses. It is Fissure's fast IDOR and missing-authorization triage.
3.1 Running it
Set a Low-priv identity in Settings (for example another user's Cookie). Then right-click a captured authenticated request in the Proxy or Findings grid and choose Check access control. Fissure replays it under the second identity and with no credentials, and compares each replay to the authenticated response:
- If a replay gets the same content, access control is missing, and a Broken Access Control / IDOR (or missing-auth) finding is raised.
- If it differs (401, 403, a redirect, or different content), access control is holding.
The verdict shows as a popup, and the finding lands in the Findings view.
3.2 Avoiding false positives
Authorization replay flags behavior that is not always vulnerable: public resources, cached responses, empty shells, same-length error messages, and tenant-independent objects. Before believing a hit, confirm the modified response includes the protected object, that it contains fields belonging to another user, that the action can be performed and not just loaded, and that the result reproduces manually. Proof comes from manual reproduction and impact, not from the triage verdict.
Chapter 4 - The Authorization Matrix (Auth Analyzer)
For role-heavy applications, the Auth matrix replays one request under N named identities at once and grades each, surfacing horizontal and vertical privilege escalation in one pass.
4.1 Configuration
Open the Auth-matrix popup. Each identity is a credential
header/cookie block. An optional extraction rule (a variable name, a
source, and a pattern) pulls a CSRF token or nonce from the baseline
response (a regex capture, a response header, or a JSON key) and
substitutes {{name}} into each replay, so guarded flows
stay valid. This matters because a replay that fails only on a stale
token tells you nothing about authorization; extract the dynamic value
first.
4.2 Running and reading
Right-click a request and choose Auth matrix. Fissure baselines it,
extracts the dynamic values, replays it under each identity, and shows a
per-identity bypassed / enforced verdict grid (a 2xx with near-identical
content is a bypass). It is scope-gated, and identities persist to
authmatrix.json.
Interpret with care: a user performing an admin action is vertical escalation; a user performing a peer's action is horizontal escalation; a user who can load a page but whose action fails is client-side exposure without server-side impact. Change one variable at a time (identity, object, method, or origin), never all at once.
4.3 Cross-role site-map diff
A broader technique compares whole reachable maps. In the Target view, scan as a higher-privilege identity and click Snapshot role; then switch to a lower-privilege login (or clear it), rescan the same target, and click Compare roles. Resources both roles reached raise a tentative Broken Access Control finding; those the second role was denied show access control holding. Public pages appear as shared, so confirm each. The Findings button next to Compare roles switches to the Findings view, where the comparison's findings sit alongside what the crawl and scan raised for that target.
Chapter 5 - JWTs, Session Tokens, and Signed Cookies
A token is not secure because it looks cryptic; it is secure only if the server verifies it correctly and enforces authorization after verification. The Tokens workshop lets you decode, edit, sign, verify, and forge tokens as a local transform, with no network calls.
5.1 The JWT workshop
Open the Tokens popup from the toolbar, or right-click a request carrying a JWT and choose Signed tokens to open it pre-loaded. Paste a token and press Decode to see the header and payload as editable JSON. Edit the claims, choose Sign as HS256, HS384, HS512, or none, enter the secret, and press Sign to forge. Verify checks the signature against the secret, alg:none strips it to an unsigned token, and Crack HS tries a wordlist to recover an HMAC secret offline. For HS/RS algorithm confusion, paste the RSA public key as the secret and sign as HS. Copy puts the result on the clipboard; To Repeater swaps the token into the active Repeater request.
5.2 What to inspect
Inspect the algorithm header (alg, typ, kid), the claims (sub,
user_id, role, scope, tenant, exp, aud, iss), and where the token lives
(cookie, Authorization header, body). Then observe how the server
behaves when the token is missing, expired, altered, or replayed. Safe
experiments: change role=user to role=admin
(expect a signature failure or an ignored claim), remove the token
(expect 401), change alg to none (expect rejection), use a token from
another tenant (expect denial). The finding is not "the token decoded";
it is "the server accepted a forged or modified token across a security
boundary".
5.3 Framework signed cookies (SignSaboteur-style)
Signed cookies in common frameworks are not JWTs but still have
structure, claims, and a signature. Press Mode in the Tokens workshop to
switch to framework cookies: Flask and itsdangerous, Django, Rails
signed, Express cookie-session, Rails encrypted (AES-256-GCM), or a
generic HMAC signed string. Decode the payload, then Sign, Verify, or
Crack the secret, entering the app secret (or the Rails
secret_key_base) and, for Django, the signing salt. A
cracked secret is only the beginning: prove that a modified cookie is
accepted and changes security-relevant behavior.
Chapter 6 - OAuth, OpenID Connect, and SSO
OAuth and OIDC introduce multiple actors (browser, client, identity
provider, resource server). Fissure ships a passive OAuth check
(resources/checks/oauth-flow.js) that recognizes an
authorization request in the traffic and flags common flow-integrity
gaps automatically; you still drive the flow-level testing manually,
using the Proxy to see the whole redirect and token story as one
sequence.
6.0 The passive OAuth check
As you browse an OAuth or OIDC login through the proxy, the shipped
oauth-flow.js check parses each authorization request out
of the URL and raises a finding for a missing state (CSRF /
login CSRF), a missing OIDC nonce (ID-token replay), the
implicit flow (response_type=token, a token in the URL), an
authorization-code flow with no code_challenge (missing
PKCE for public clients), and a cleartext http://
redirect_uri. These are leads: confirm the client type and
the server-side enforcement before reporting, using the manual checks
below.
6.1 What to capture
Clear the Proxy history to reduce noise, then record the login from
the first click. Capture the initial authorization request and its
parameters (redirect_uri, client_id,
response_type, scope, state,
nonce, code_challenge), the callback carrying
the authorization code, the token exchange when it is visible, the
application session created after SSO, and the API requests that follow.
Use HaE rules to highlight the redirect and callback requests so they
are easy to find in the grid.
6.2 High-value checks
Send the callback and the token-bearing API requests to the Repeater and replay them, changing one parameter at a time in a lab-safe way:
| Check | Question |
|---|---|
| State validation | Can the callback complete with a missing or swapped state? |
| Nonce validation | Can an ID token be replayed or substituted? |
| Redirect URI | Can an attacker control where the code is sent? |
| PKCE | Is the code verifier required for public clients? |
| Scope enforcement | Does the API enforce the granted scopes? |
| Logout | Are the IdP and application sessions both invalidated? |
Never attack a real identity provider or a third-party account; keep SSO tests inside authorized programs or private labs. Report the full redirect chain, the changed parameter and expected policy, the final identity observed, and the impact (login CSRF, account takeover, token leak, or scope bypass).
Chapter 7 - The SAML Workshop: Signed SSO Assertions
SAML is the other single sign-on protocol. Where Chapter 6 covered OAuth and OIDC, SAML works differently: an identity provider (IdP) authenticates the user and posts a digitally signed XML assertion to the service provider (SP), and the SP trusts whatever identity and attributes that assertion carries because it is signed by the IdP. The security of the whole scheme rests on the SP verifying that XML digital signature correctly and binding it to the exact assertion it then trusts. The SAML workshop is Fissure's SAML-Raider-style toolkit for testing exactly that: decode the assertion, edit the identity it claims, and run the three classic signature attacks. Every operation is a local transform; the workshop sends nothing, so nothing here touches a target until you deliberately replay an edited message.
7.1 When to reach for it
Reach for the SAML workshop whenever a login flows through a SAML
IdP. You will see a form POST carrying a base64
SAMLResponse field (the HTTP-POST binding), or a redirect
with a SAMLRequest / SAMLResponse query
parameter (the HTTP-Redirect binding, which DEFLATE-compresses before
base64). The questions it answers: does the SP accept an assertion with
the signature removed; does it validate one signature but read a
different, forged assertion; and does it accept a signature from any key
rather than only the IdP's pinned certificate. These are
authentication-bypass and privilege-escalation bugs of the highest
severity: a successful edit logs you in as any user, often as an
administrator.
7.2 Opening the workshop and decoding a message
Open it from the toolbar's Auth & session dropdown (the SAML
button, next to Tokens), from the command palette ("Open SAML workshop",
or Ctrl+K), or drive it headless over POST /api/saml and
the MCP saml tool. It is a standalone workshop, not tied to
a selected request, so capture the SSO login in the Proxy, copy the
SAMLResponse value, and:
- Paste the transport value into the input area and press Decode. The binding is auto-detected: a base64 that decodes straight to XML is the HTTP-POST binding; a base64 that decodes to a DEFLATE stream is the HTTP-Redirect binding (URL-decode a Redirect-binding value before pasting). The decoded XML lands in the editable work area and the status line names the binding it found.
- Press Inspect to summarize the assertion as JSON: the Issuer, the
NameID (the identity the SP trusts), the Destination, the attribute
name/value pairs, whether a
ds:Signatureis present, and, when it is, whether that signature currently verifies against its own embedded certificate.
7.3 Editing the identity
The assertion is now editable text in the work area. Two helpers rewrite the identity cleanly:
- Set NameID: type the new identity in the field and press Set NameID to replace the NameID element's text (spoof another user).
- Set attr: type
name=valuein the field (for examplerole=admin) and press Set attr to set or add a SAML attribute.
Editing alone is not an attack: a correctly configured SP rejects the modified assertion because the signature no longer matches. The three attacks below are the ways that check can fail.
7.4 Attack 1: signature exclusion (Strip signature)
Some SPs verify a signature when one is present but do not require
one; strip it and they trust the assertion outright. Press Strip
signature to remove every ds:Signature element, then Encode
the message back to a transport blob and replay it into the SP callback.
If the SP still logs you in, it fails to enforce signing: edit the
NameID or a role attribute first and you have a full authentication
bypass. This is the SAML analogue of JWT alg:none from
Chapter 5.
7.5 Attack 2: XML signature wrapping (Apply XSW)
A stronger SP does verify the signature, but signature verification
and assertion consumption can look at different parts of the document.
XML signature wrapping (XSW) keeps the original, validly signed
assertion in the message, so its signature still verifies, while
smuggling in a forged assertion positioned so a vulnerable SP validates
the original but reads the forged one. Choose a variant in the dropdown
and press Apply XSW; the forged NameID comes from the field (default
attacker@evil.example). The forged assertion is a copy of
the signed one with its own signature removed, a new ID, and your forged
NameID, so the original signature stays cryptographically valid. The
three variants cover the common processing orders:
- XSW 1 (forged before): the forged assertion is inserted as a sibling immediately before the original.
- XSW 2 (original nested): the original signed assertion is nested inside the forged one, which takes the original's place.
- XSW 3 (original in Extensions): the original is moved into an Extensions wrapper (so its signature still resolves by ID) and the forged assertion takes its slot.
Try each variant against the SP; which one, if any, succeeds depends entirely on how that SP walks the XML.
7.6 Attack 3: self-signed re-signing (Generate key, Sign)
If the SP verifies the signature but does not pin the IdP's certificate (it trusts whatever certificate the message embeds), you can simply re-sign a tampered assertion with your own key. Press Generate key to mint a throwaway self-signed RSA key and certificate into the Key and Cert PEM fields, edit the assertion (NameID, attributes) however you like, then press Sign to apply an enveloped RSA-SHA256 signature with your key and embed your certificate in the message. Any existing signature on the target is removed first, so this both signs a stripped message and re-signs a tampered one. Sign targets the Assertion element when present, otherwise the whole Response. If the SP accepts it, it is trusting the signature without checking whose key it is.
7.7 Verify, and encoding back
Verify runs a pure cryptographic check: it takes the public key from the message's embedded certificate (or the Cert field when the message carries none) and reports VALID, INVALID, or NO SIGNATURE. It deliberately does not check the certificate chain or the validity window, so it answers only whether this signature and digest match this key. Use it to confirm your own re-sign succeeded (VALID), and to confirm that a mere edit without re-signing breaks the original signature (INVALID), which is exactly why the strip, wrap, and re-sign attacks exist. When the edited message is ready, press Encode POST or Encode Redirect to turn the working XML back into a transport blob for the matching binding, then paste it into the SP request in the Repeater and replay.
7.8 A worked example
Capture the SP callback that carries the SAMLResponse.
Decode it and Inspect: say it reports Issuer
https://idp.corp.example, NameID
alice@corp.example, attribute role=user,
signed true, signature valid. Set NameID to
admin@corp.example (or Set attr role=admin),
then work the attacks in order of SP strength. First press Strip
signature, Encode POST, and replay: if you are now admin, the SP does
not require a signature. If it rejects the unsigned message, undo, and
Apply XSW variant 1 (then 2, then 3), replaying each: a successful
variant means the SP validates the original signature but consumes your
forged assertion. If wrapping fails too, press Generate key, re-apply
your edit, press Sign, Encode POST, and replay: success means the SP
does not pin the IdP certificate. Whichever path works, confirm the
granted identity on a post-login page before reporting.
7.9 Authorized use
Every button in the workshop is an offline transform; the workshop itself sends no request. Forging a SAML assertion and sending it to a service provider is an explicit, separate action that goes through the scope allowlist and the authorization banner, and it is only ever for an SSO deployment you are authorized to test. Never point these attacks at a real identity provider or a third party's SP. Report the captured original assertion, the exact edit and which attack carried it (exclusion, a wrapping variant, or a re-sign), the identity the SP granted, and the impact (authentication bypass, privilege escalation, or full account takeover).
Chapter 8 - Reporting Authorization Findings
Authorization findings are often high impact but easy to overstate. Strong reporting requires a clear policy, a reproducible bypass, and an impact statement tied to real data or actions.
8.1 The triage matrix
| Impact | Example | Direction |
|---|---|---|
| Read own data only | No boundary crossed. | Informational |
| Read another user's low-risk | Profile name, public metadata. | Low to medium |
| Read private PII or financial | Email, address, invoices. | High |
| Modify another user's object | Change order, address, settings. | High |
| Admin action as a user | Disable account, approve a payment. | High to critical |
| Tenant escape | Access another organization. | High to critical |
8.2 Reproduction
Capture the owner request and response, the attacker replay, and the unauthenticated replay where relevant; state the object ownership and the expected policy; and describe the impact in business terms. Use "the server permits" rather than "the UI allows" unless the issue is truly client-side. Recommend server-side enforcement (ownership or tenant checks for every object, allowlists for writable fields, authorization middleware on all methods), not UI hiding. Fissure carries the exchange with each finding, so Send to Repeater reproduces the exact request, and the report redacts secrets by default.
Chapter 9 - Auth Lab
Use a legal training application with at least two accounts.
- Open two accounts in separate browser containers and tag each with a PwnFox color; confirm the Ident column.
- Capture a request that returns user-specific data as the owner.
- Set a Low-priv identity in Settings and run Check access control on that request; read the popup verdict and the finding.
- Add both accounts as identities in the Auth matrix, add an extraction rule for any CSRF token, and run it; read the bypassed/enforced grid.
- Snapshot the admin role's site map, rescan as the user, and Compare roles.
- Decode a session JWT in the Tokens workshop, try
role=adminand alg:none in a lab, and confirm the server rejects, ignores, or accepts each. - Capture one OAuth login end to end in the Proxy and replay the callback with a changed state parameter.
- Record a login from the proxy: browse the login page and submit
credentials, multi-select the login-page GET and the credential POST in
the Proxy grid, press Record login, name it, then run an authenticated
scan with the saved config
(
fissure scan <target> --login <config>/logins/<name>.json) and confirm the scan stays logged in; add averifymarker and areauth_on_containsmarker and watch it re-authenticate. - If your lab exposes a SAML SSO login, open the SAML workshop, Decode
the captured
SAMLResponse, Inspect it, Set NameID (orrole=admin), then work the attacks in turn: Strip signature, each XSW variant, and Generate key then Sign; Encode each result and replay it into the SP callback to see which the SP accepts. - Write one authorization finding with owner, attacker, and unauthenticated evidence and a business-impact statement.