Fissuredocumentation v5.3.1
On this page

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 login object on /api/scans (or start_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:

  1. 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.
  2. 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:Signature is 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=value in the field (for example role=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.

  1. Open two accounts in separate browser containers and tag each with a PwnFox color; confirm the Ident column.
  2. Capture a request that returns user-specific data as the owner.
  3. Set a Low-priv identity in Settings and run Check access control on that request; read the popup verdict and the finding.
  4. 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.
  5. Snapshot the admin role's site map, rescan as the user, and Compare roles.
  6. Decode a session JWT in the Tokens workshop, try role=admin and alg:none in a lab, and confirm the server rejects, ignores, or accepts each.
  7. Capture one OAuth login end to end in the Proxy and replay the callback with a changed state parameter.
  8. 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 a verify marker and a reauth_on_contains marker and watch it re-authenticate.
  9. If your lab exposes a SAML SSO login, open the SAML workshop, Decode the captured SAMLResponse, Inspect it, Set NameID (or role=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.
  10. Write one authorization finding with owner, attacker, and unauthenticated evidence and a business-impact statement.