A code scanner says where a flaw could be. Testing the running app proves it.

Vybscan now tests your running app as well as reading its code. Here is why we built it, how it works and what it found.

Vybscan engineering Nov 19, 2026 6 min read
โ† Back to Blog

A code scanner reads your source and points at lines that look dangerous. A query built from user input. A file path taken from a request. A URL the server fetches on the user's behalf. That is useful, and it is also a guess. Whether the flaw is real depends on things the code doesn't show, such as the framework's defaults, a proxy in front of the app, or a check in a library three calls away.

Dynamic testing, or DAST, answers the question from the other side. It sends requests to the running app and watches what comes back. If a quote in a search box breaks the database query, that is no longer a guess.

We have added it to Vybscan. You point it at your staging app, and it tests that app with the same kinds of attack a penetration tester would try first.

Why most DAST tools disappoint

DAST has been around for twenty years, and teams that have tried it tend to have the same three complaints.

  • A classic scanner crawls links and forms. A modern single-page app has few of either. Its API routes live in JavaScript bundles and server code, so the crawler sees a login page and a handful of links, and tests those.
  • A slow response or an error page gets reported as a vulnerability. After a few of those, people stop reading the report.
  • A scanner that submits every form it finds will delete records, send emails and reset passwords. Nobody wants that on a shared staging server.

We built Vybscan's tests around those three.

We use the code to find the app

Vybscan has already read your repository. It knows the routes your server defines and the query and body fields each handler reads. So the test starts with a map of the app, and then adds what a crawler finds and any OpenAPI or Swagger file you give it.

The difference is large. On OWASP Juice Shop, a single-page app, crawling alone found 11 endpoints and 1 vulnerability. With the routes from the code, the same test found 67 endpoints and 4 vulnerabilities.

Crawling alone
11 endpoints
1 vulnerability found
Crawling plus the code's routes
67 endpoints
4 vulnerabilities found

The code helps once more at the end. Each finding links to the route in your repository that served it, so the developer who fixes it starts at the right line.

Every finding needs proof

We only report what the app itself demonstrates. Each test carries a value whose effect can't happen by accident, and the finding stands only if the response shows that effect.

  • For SQL injection, a quote must break the query while a balanced value does not, or a true and a false condition must return different pages.
  • For template injection, the page must show the product of two numbers we chose, one of them random.
  • For command injection, the page must show the output of a command we asked it to run.
  • For path traversal, the page must show the contents of a known system file.
  • For reflected cross-site scripting, our tag must come back unescaped.
  • For server-side request forgery, our own server must receive the request your server made.
  • For open redirects, the app must send the browser to a reserved test domain.

We don't run timing tests, where a slow response is read as a sign of injection. They are slow, and on a busy staging server they guess wrong. A test that can't show its proof reports nothing.

Built to be safe to run

These are real attacks, so the limits are strict and they are not optional.

  • It runs only against an app you have proved you control, through a file on the site or a DNS record. The proof is checked again before every run.
  • It stays on that one host. Every request and every redirect is checked, and private and cloud metadata addresses are refused.
  • It never follows sign-out, delete, cancel or payment links. It never submits a form that resets, deletes, sends or pays, or one that changes a password or carries card details.
  • It submits forms only if you allow it. Otherwise it reads pages and sends test values in links and API queries.
  • You set the pace, from 1 to 10 requests a second. Each run has a request cap and a time limit, and you can stop it at any time.

We ask you to confirm that the target is not production. A staging app with test data is the right place for this.

What it found

We ran it against two apps that are insecure on purpose and checked every finding by hand.

AppFoundNot found
DVWA 7 findings: SQL injection on three pages, including a blind one, command injection, path traversal and reflected cross-site scripting on two pages. Stored cross-site scripting (its form also clears the guestbook, so we never submit it), DOM-based cross-site scripting, CSRF, file upload and weak session IDs.
OWASP Juice Shop 4 findings: SQL injection in search and in login, server-side request forgery through the profile image URL, and error details sent to the browser. DOM-based cross-site scripting, and access-control and business-logic flaws.

Neither app produced a false finding. Both were run locally in their default setup.

We ran it on our own website too. It reported no successful attack, and it listed security headers we had not set. We added them the same day.

How it fits with the rest of Vybscan

Vybscan reads your dependencies and your code on every pull request. These tests add the running app. Results are shown on the repository page next to the code findings, and as a report you can print and share. You can run a test whenever you want, or schedule one every week.

App testing is in early access. To try it on your staging app, contact us at contact@dheemai.com.

See what Vybscan finds on your repos

Dependencies, secrets and code on every pull request, and now your running app.

Try Vybscan โ†’
โ† Back to Blog