Contact
Website Security

Server vs Web Application Vulnerability Scanning

This page explains the difference between server (infrastructure) vulnerability scanning and web application vulnerability scanning, what each one can and cannot see, and how to turn a findings list into patched systems. It is written for IT managers, digital leads and agency owners who have a scan report and no clear idea what to do with it.

Two scans, two completely different answers

Ask most organisations whether their website is scanned for vulnerabilities and the answer is yes. Ask which layer is scanned and the answer usually falls apart.

A server vulnerability scan answers the question: what software is installed on this machine, and which of those packages have known CVEs? It cares about OpenSSL, the kernel, nginx, PHP, MySQL, the SSH daemon, the cron entries and the open ports. It does not know your site exists.

A web application vulnerability scan answers a different question: given this URL, what can an unauthenticated attacker make the application do? It cares about injection, broken access control, cross-site scripting, insecure cookie flags, exposed admin endpoints and vulnerable CMS components. It does not know or care what Linux distribution is underneath.

Both are necessary. Neither substitutes for the other, and a clean report from one tells you nothing about the other. A fully patched Ubuntu host can serve a Drupal site running a contributed module with a critical access bypass advisory. A hardened application with perfect headers can sit on a host with an unpatched kernel and a Redis instance bound to 0.0.0.0.

What a server vulnerability scan actually inspects

An infrastructure scan builds an inventory and compares it against a vulnerability database, usually the NVD feed plus vendor advisories. In practice it is looking at:

  • Installed package versions from the system package manager (dpkg, rpm, apk) and their matching CPE identifiers
  • Running services and listening ports, including things nobody meant to expose: memcached, Elasticsearch, database ports, old staging daemons
  • Kernel version and whether a reboot is pending after a kernel or glibc update
  • TLS configuration: protocol versions, cipher suites, certificate chain and expiry
  • SSH configuration, password authentication, permitted root login, key algorithms
  • Interpreter versions, which is where most websites fail. PHP 7.4 and 8.0 have been end of life for years and receive no security patches at all, so there is no CVE to match and no patch to apply. The finding is the version itself.
  • Firewall rules, sudoers entries, world-writable paths and file permission drift

Authenticated versus unauthenticated scanning

This is the single biggest determinant of whether a server scan is useful. An unauthenticated scan probes from outside: it port-scans, grabs banners and infers versions from response headers. An authenticated scan logs in with credentials or an installed agent and reads the actual package database.

The gap between the two is enormous. Unauthenticated scanning cannot see a vulnerable library that is installed but not reachable over the network, cannot tell you the kernel version, and cannot distinguish nginx 1.18.0 with every security backport applied from nginx 1.18.0 untouched since 2020. Banner grabbing also fails entirely when the banner has been suppressed, which hardening guides recommend, so you end up with a quiet report that means nothing.

If your current arrangement is an external scan run against a public IP, assume you are seeing a minority of what is actually there. Credentialed or agent-based scanning is the baseline for anything you intend to report on.

Why distribution backports make version numbers lie

Debian, Ubuntu and Red Hat maintain long-term support packages by backporting security fixes into the original upstream version rather than upgrading it. A Debian host might report openssl 1.1.1n-0+deb11u5. Upstream 1.1.1n has known CVEs. The deb11u5 suffix is where the fixes live.

Scanners that match on upstream version alone will flag that package as vulnerable. It is not. These findings arrive in bulk, they look urgent, and every one of them has to be checked against the distribution's security tracker before anyone can honestly say whether the box is exposed. This is the most common reason internal teams stop reading scan output: the first report contains hundreds of criticals, most of them false, and nobody has time to adjudicate them.

The inverse also happens. A package compiled from source, installed via a third-party repository or baked into a container image sits outside the distribution's patch pipeline entirely and never gets fixed, while the scanner reports it as current.

What a web application scan inspects

Application scanning splits into three techniques that are frequently confused with one another.

Dynamic scanning (DAST)

A crawler walks the site, discovers forms, parameters and endpoints, then sends malformed and malicious payloads to each one. It is looking for reflected and stored XSS, SQL injection, path traversal, open redirects, insecure direct object references, missing security headers, cookies without Secure, HttpOnly or SameSite, and exposed files such as .git/config, .env or composer.lock.

DAST sees what an attacker sees, which is its strength. Its weakness is coverage: anything behind a login, anything reachable only through a multi-step form, anything rendered client-side by a JavaScript framework and anything gated by a CAPTCHA tends to be invisible to an unauthenticated crawler. A scanner that cannot authenticate typically tests a fraction of the real attack surface.

Dependency and composition analysis (SCA)

This reads the manifests rather than the running site: composer.lock, package-lock.json, yarn.lock, Gemfile.lock, requirements.txt. Every pinned version is compared against advisory databases. This is how you discover that a transitive dependency six levels deep in a build toolchain has a prototype pollution advisory, which no DAST crawler will ever surface.

Composition analysis only works if it runs against the code that is actually deployed. Scanning a repository that has drifted from production tells you about a site that does not exist.

CMS and component scanning

WordPress, Drupal, Silverstripe, Magento and Craft each have their own plugin, module and extension ecosystems with their own advisory feeds. The majority of real-world CMS compromises come from a third-party component, not the core, and often from a component that was deactivated but left installed, which keeps its PHP files reachable. Component scanning enumerates installed extensions and their versions, checks them against the relevant advisory source, and flags anything abandoned by its maintainer.

Coverage comparison across scan types

Scan type Inspects Typically finds Cannot see Sensible cadence
Unauthenticated network scan Open ports, banners, TLS Exposed services, expired or weak certificates, legacy TLS Package versions, kernel, anything not listening publicly Weekly
Authenticated server scan Package database, kernel, config files, users Unpatched OS packages, end-of-life interpreters, config drift Application logic, CMS extensions, custom code Daily or continuous
Dynamic application scan (DAST) Live HTTP responses to crafted input XSS, injection, headers, cookie flags, exposed files Authenticated areas, business logic, server packages Weekly, plus every release
Dependency / composition analysis Lock files and manifests Vulnerable direct and transitive libraries, abandoned packages Runtime exploitability, server layer, configuration Every build, plus daily advisory re-check
CMS component scan Installed plugins, modules, themes Known-vulnerable extensions, abandoned components Custom modules, server layer, logic flaws Daily

The gaps neither layer covers

Running all five scan types still leaves meaningful risk unmeasured. Automated tools do not find business logic flaws: a checkout that accepts a negative quantity, a quote form that lets you enumerate other people's reference numbers, a password reset that does not invalidate the token. They do not assess whether an administrator who left the organisation still has an active account, whether multi-factor authentication is enforced on the CMS, or whether your backups restore.

Scanners also stop at your boundary. Third-party scripts loaded into your pages, tag manager containers, chat widgets and analytics libraries execute with full access to your DOM and are not covered by a scan of your own code. That is a Content Security Policy problem, not a scanning problem.

This is also why automated scanning is not a substitute for manual testing. The two are complementary, and a clean scan history is the cheapest way to make a penetration test productive, because the testers spend their time on logic rather than on findings you could have fixed yourself. If a test is on your roadmap, the preparation matters more than the test itself.

Scan frequency, noise and the false positive tax

Scanning quarterly is close to pointless for a public website. A critical CVE in a widely deployed PHP framework is exploited at scale within days of disclosure, sometimes within hours of a proof of concept appearing. The useful cadence is continuous advisory monitoring against a known inventory, with scheduled full scans layered on top.

The real constraint is not frequency, it is noise. A first full scan of a mature environment routinely produces hundreds of findings. Somewhere between a third and most of them will be backport artefacts, informational findings, or genuine issues that are not reachable in your configuration. If every one of those lands on an internal team with no process for adjudicating them, the report gets filed and nothing changes. The organisation now has documented knowledge of vulnerabilities it has not remediated, which is a worse legal and insurance position than not having scanned at all.

Triage is the work. For each finding, someone has to establish whether the vulnerable code path is reachable, whether a compensating control such as a WAF rule or network restriction already mitigates it, what the patch is, and what the patch will break.

Turning a findings list into a remediation plan

A scan report is an input. A remediation plan has four things a report does not: an owner, a severity that accounts for your context, a deadline, and a verification step.

  1. Normalise and deduplicate. The same underlying library flagged by three tools is one finding, not three.
  2. Re-score against exploitability in your environment. CVSS base score is a starting point. A critical in a module you do not have enabled ranks below a medium in your login flow. Check whether the CVE appears in the CISA Known Exploited Vulnerabilities catalogue, because that changes the clock.
  3. Assign a remediation class. Patch now, patch in the next scheduled window, mitigate with a control and patch at the next major upgrade, or formally accept with a review date.
  4. Patch in a staging environment that matches production. Minor version bumps break things. A PHP point release can break a legacy extension; a CMS security release can change a template API.
  5. Regression test, deploy, rescan. The finding is not closed until a subsequent scan confirms it. This is the step most arrangements omit.

The reason this breaks down in practice is organisational, not technical. The hosting provider runs the scan and will patch the operating system, but will not touch the application. The development agency can patch the application, but does not see the scan, has no staging environment on that infrastructure, and bills by the hour for work nobody has approved. The finding sits in the gap between them for months. Closing that gap means scanning, triage, patching and regression testing sitting with one team that has both server access and the ability to change code.

Evidence that satisfies auditors, insurers and security questionnaires

Increasingly the scan is not for you. It is for a procurement team, a cyber insurer, an ISO 27001 auditor or a government client running a supplier assessment. What they want is rarely the raw report.

They want to see a documented patching cadence and the actual dates it was followed, a record of each critical finding with the date identified and the date remediated, evidence of who approved each risk acceptance and when it will be reviewed, and a change log showing patches did not go out unreviewed. External rating platforms add another dimension, scoring your public surface on headers, TLS, DNS records and exposed services, and a poor UpGuard or equivalent rating can stall a deal regardless of how well your internal patching is running.

A dated, chronological record of every finding, fix and decision is worth more in an audit than any single scan output, because it demonstrates a process rather than a snapshot. Treating that record as a deliverable, not a by-product, is the difference between answering a security questionnaire in an afternoon and answering it over three weeks.

Frequently Asked Questions

What is the difference between server vulnerability scanning and web application vulnerability scanning?

Server vulnerability scanning inspects the operating system and installed software, comparing package versions, kernel, services and TLS configuration against CVE databases. Web application vulnerability scanning tests the running site over HTTP for issues such as injection, cross-site scripting, broken access control and vulnerable CMS components. They examine different layers and a clean result from one says nothing about the other, so a complete programme runs both.

Do I need an authenticated scan, or is an external scan enough?

An external unauthenticated scan only sees what is exposed on the network and infers software versions from banners, which are often suppressed or misleading. An authenticated scan reads the actual package database and configuration files, which is the only reliable way to know your real patch level. External scanning is useful for confirming your public attack surface, but it should not be your only source of truth.

Why does my scanner report vulnerabilities that my hosting provider says are already patched?

Debian, Ubuntu and Red Hat backport security fixes into the original upstream version number rather than upgrading the package, so the version string still matches a known CVE even though the fix is applied. Scanners that match on upstream version alone generate large numbers of these false positives. Each one needs checking against the distribution's security tracker before it can be dismissed, which is why unfiltered scan reports are so often ignored.

How often should a website be scanned for vulnerabilities?

Quarterly scanning is too slow for a public-facing site, because widely deployed CVEs are exploited at scale within days of disclosure. The practical approach is continuous advisory monitoring against a maintained inventory of your packages, dependencies and CMS extensions, with full authenticated and dynamic scans on a weekly or per-release schedule. Frequency only helps if someone triages and acts on the output.

Does vulnerability scanning replace a penetration test?

No. Scanning finds known vulnerabilities with published identifiers, while a penetration test finds logic flaws, chained exploits and access control failures that no automated tool detects. Running a disciplined scanning programme beforehand makes a penetration test considerably more valuable, because the testers spend their time on findings you could not have discovered yourself rather than on unpatched packages.

Who should be responsible for patching the findings?

Whoever can change both the server and the application code, because findings fall on both sides and a split arrangement leaves them unowned. If your hosting provider patches the operating system and your development agency maintains the site, agree in writing which party handles CMS core, extensions, application dependencies and configuration findings. Without that, critical findings sit between the two vendors indefinitely.

Where UnDigital fits

UnDigital runs both layers as one service. Authenticated server scanning and continuous CVE monitoring across the infrastructure sit alongside dependency analysis, CMS component checks and dynamic scanning of the live site, with triage done by engineers who know the application, not by a dashboard. Backport false positives are adjudicated before they reach you. Real findings come with a severity scored against your environment, a remediation class and a date.

Because the same team holds server access and development capability, patching does not stop at the boundary between infrastructure and code. A vulnerable Composer package, an end-of-life PHP version and an abandoned WordPress plugin are all handled in staging, regression tested and deployed under change control, then verified by a rescan. Every finding, decision and fix is recorded with a date, which is what you hand to an auditor, an insurer or a client security questionnaire. The same discipline underpins broader security posture work and makes penetration test preparation straightforward rather than frantic.

If your current arrangement produces scan reports that nobody closes, or you are unsure which layer is being scanned at all, start with an audit of what is actually running and what is actually being checked.

Find out what your scans are missing

Reviews from our client partners.

"Thanks so much for your comprehensive strategy and execution of our digital ecosystem.

I can finally sleep at night knowing that everything is under control, secure and scalable.

Thank you!!!".

Corporate Marketing Manager, Sekisui House

"Thanks for all your help. This project was in such good hands from the beginning. We really appreciate all your hard work and expertise!!"

Retail Marketing Manager, West Village

Get vulnerability findings triaged

@undigital