Check that each user can do only what they should
One forgotten access rule can let a basic user open an admin screen or see another customer's records. Your build stays green, because the tests sign in as one user who can do everything.
AccessGuard reads the access rules in your code, runs the same journey as each of your test logins, and shows where the running application allowed or refused something the code says it should not.
Why access mistakes reach production
Code review sees the rules and tests see the behaviour, but nothing compares the two.
The code says one thing
A controller is marked for administrators only. A code review checks that the marking is there, but nobody checks that the running application actually refuses everyone else.
Tests run as one user
Most end-to-end tests sign in with a single account, usually one that can do everything. A screen that is wrongly open to a basic user passes every one of them.
Nobody knows what was checked
When an auditor asks which roles were tested against which features, the answer is usually a spreadsheet someone filled in by hand months ago.
How it works
FlowGuard already scans your code and runs your journeys. AccessGuard adds the logins and the comparison.
Read the rules in your code
During the codebase scan, AccessGuard lists every permission your back end declares: the roles and policies on each ASP.NET Core endpoint, plus your own permission attributes once you tell it how they are written.
Each permission is linked to the endpoints it protects.
Run the journey as each login
For each environment you add the logins to test with: a username, a password kept in FlowGuard's secret store, and the role that login has. A suite then runs one journey as each login side by side, and you mark whether each should get through or be refused.
The same journey, the same steps, different users.
Compare what happened
Every run already records the requests the browser sent and what the server answered. AccessGuard matches those requests to the endpoints from step 1 and compares, for each login, what it reached with what it should have reached.
Every finding names the endpoints behind it.
What it finds
Each finding is judged on the whole run, with the endpoints listed as evidence, so a shared call like the sign-in page does not raise a finding on its own.
Let in when it should not be
- A login that should be refused completed the whole journey
- An endpoint that requires one role answered successfully to a run signed in with a different role
Refused when it should not be
- A login that should get through was refused by the server (HTTP 403)
- The server refused a request on an endpoint where the code declares no access rule, so the rule lives somewhere the team may not know about
Never tested
- A permission your code declares that no journey has ever exercised
- How many of your application's permissions any journey has reached, so coverage is a counted number
An Access page for each application
When an auditor asks which roles were tested against which features, this page is the answer, built from real runs.
Permissions by login
For each test login and environment: which permissions its journeys reached, which were refused, and which it never touched.
Permissions by module
The same evidence grouped by the parts of your application, so each team can see its own area.
Findings on the run
Each suite run shows its logins as columns, with the endpoints each one reached and any finding marked on the row.
What was read
Every answer says which sources it used: the code, the runs, or both. If no journey has run yet, the page says nothing has been checked rather than showing a clean result.
What it does not claim
These are the limits of what AccessGuard checks today.
- It reads access rules from ASP.NET Core (.NET) back ends today. Other frameworks need their own reader, which we add per customer.
- It only knows what your journeys touch. A permission no journey reaches is reported as untested, never as safe.
- A 401 (not signed in) is not counted as an access refusal. Only a 403 (signed in, not allowed) is.
- It never tries to break in, and it never changes your users, roles or permissions. It signs in with the logins you give it and records what happens.
- It needs a codebase scan of the application before it can link requests to permissions.
Where it runs
AccessGuard is part of FlowGuard, so it runs wherever your FlowGuard journeys run.
Part of FlowGuard
AccessGuard uses FlowGuard's codebase scan, journeys and runs. There is nothing extra to install, and its pages sit next to your flows.
Passwords stay in the vault
Test logins point at secrets in FlowGuard's secret store. Flows never contain the password itself.
Runs where FlowGuard runs
Journeys run on our cloud runners or on the agent inside your own network, so applications that are not on the internet can be checked too.
Try it on your own application
If you'd like to try it, create a free workspace, scan your code and add two test logins with different roles. If you would rather see it on a call first, book a demo.