● Talk to a security engineer: +92 323 8295031info@protonyte.com  ·  PCSF batch enrolling now

Web application penetration testing that finds the logic a scanner cannot read

Protonyte tests web applications and customer portals by hand for companies in the United States, the UK, Canada and the Gulf. We work through the OWASP Web Security Testing Guide, then go past it into your own business rules - the checkout that can be re-ordered, the invoice that belongs to another tenant, the admin page one request away. Every finding comes with the request that proves it, and one free retest once you have fixed it.

input → interpreter

ENGAGEMENT SCOPEtypical 1 - 2 week test

Authentication and session handlingIN SCOPE
Access control and multi-tenancyIN SCOPE
Injection, XSS and template abuseIN SCOPE
Business-logic and workflow abuseIN SCOPE
File upload, SSRF and deserialisationIN SCOPE
Source-code reviewOPTIONAL
// the basics

What a web application test actually covers

A web application penetration test is a controlled attack on your own site, run by a person rather than a product. We are given a set of accounts, or none at all, and we try to reach data and actions that those accounts should never have.

Automated scanning is part of it, but only the first hour. A scanner can tell you a field reflects input. It cannot tell you that order number 10043 belongs to another company, that a coupon can be applied twice if the second request arrives first, or that the password-reset token never expires. Those are the findings that end up in the summary your board reads.

  • 01Tested by handA certified tester drives the application the way a determined user would, with tooling in support rather than in charge.
  • 02Every role, not just oneWe test as an anonymous visitor, a normal user and an administrator, and across tenants where the product is shared.
  • 03Proof, not suspicionEach finding carries the exact request and response, so your developers can reproduce it in minutes.
  • 04Retested freeWhen your fixes are in, we test them again and write down whether the risk is actually closed.
// coverage

What we go after

The structure follows the OWASP Web Security Testing Guide, so nothing is skipped. The depth comes from what your application does for a living.

// who you are

Authentication and sessions

Everything between the login form and the signed-in page.

  • Password, OTP and social login flows
  • Password reset and account recovery
  • Session fixation, timeout and logout
  • Multi-factor bypass paths
// what you may touch

Access control

The single most common serious finding we report.

  • Insecure direct object references (IDOR)
  • Horizontal and vertical privilege escalation
  • Cross-tenant data access
  • Hidden and forced-browsing endpoints
// what you send

Injection and input handling

Where untrusted text reaches an interpreter.

  • SQL, NoSQL and command injection
  • Stored, reflected and DOM-based XSS
  • Server-side template injection
  • XML external entities and XPath
// what you allow

Business-logic abuse

The part no scanner has any idea about.

  • Price, quantity and discount tampering
  • Workflow steps taken out of order
  • Race conditions on money and stock
  • Abuse of limits, quotas and free tiers
// what you accept

Files, SSRF and deserialisation

Where your server fetches or opens something on a visitor’s say-so.

  • Upload filtering and content-type trust
  • Server-side request forgery into internal hosts
  • Unsafe deserialisation
  • Archive and path traversal
// how it is set up

Configuration and client side

The details that turn a small bug into a big one.

  • Security headers and cookie flags
  • CORS and postMessage origins
  • Verbose errors and debug endpoints
  • Known-vulnerable components
// methodology

How the work runs

  1. 1

    Scope and rules

    We agree the application, the accounts, the test window and what is off limits, in writing, before anything is touched.

    • Target list and environments
    • Test accounts per role
    • Out-of-scope actions
    • A named contact on both sides
  2. 2

    Map the application

    Every page, parameter, role and request is walked and recorded, so the test covers the application rather than its home page.

    • Authenticated crawl per role
    • API and AJAX endpoints
    • Technology and version fingerprinting
    • Entry points ranked by risk
  3. 3

    Test and exploit

    The long part. Manual testing against the map, then careful exploitation to establish what the issue is actually worth.

    • OWASP WSTG coverage
    • Chaining small issues into real ones
    • Impact confirmed on test data only
    • Daily contact, and a call at once if it is critical
  4. 4

    Report

    Written for two readers: the person who signs and the person who fixes. Each finding carries evidence and a fix.

    • Executive summary in plain language
    • CVSS score and business impact
    • Request and response for each finding
    • Remediation written for your stack
  5. 5

    Retest

    Included. We attack the fixes the same way and say plainly whether the risk is closed.

    • Every finding re-attempted
    • Closure summary you can hand to a client
    • Regressions reported if a fix broke something else
// the deliverable

What you are left holding

Two documents and a conversation. Written so the person who signs the invoice and the person who writes the fix can both use them.

  • Executive summary in plain language, with the business risk first
  • Technical findings with the evidence that proves each one
  • CVSS score and a risk rating that reflects your business, not a template
  • Remediation written for the stack you actually run
  • A free retest, and a closure summary you can hand to a customer
  • A debrief call with the tester who did the work, not an account manager
Ask for a sample report
// the standards

Measured against something

The work follows OWASP Web Security Testing Guide, OWASP Top 10, OWASP ASVS, PTES and NIST SP 800-115, so the coverage can be checked rather than taken on trust, and the report maps to what your auditor or your enterprise customer already recognises.

This page is one part of our penetration testing service. Where a finding needs a different kind of engagement to answer properly, we say so in the report rather than selling you the test we happen to be running.

// faq

Common questions

How long does a web application penetration test take?

A single application with two or three user roles is usually one to two weeks of testing, plus a few days for the report. Size, the number of roles and how much of the functionality is behind a paywall are what move that number. You get the exact timeline during scoping, before anything is agreed.

Do you test in production or in staging?

Either, and we will tell you which we would prefer for your case. Staging is safer and is usually right when the application handles live money or patient data; production is more honest, because staging is rarely configured the same way. If we test production we avoid destructive techniques and agree a window.

What do you need from us to start?

The address of the application, one working account for each role, and a signed authorisation to test. If the application is behind a WAF or an IP allow list we will ask to be let through, because testing the WAF is a different exercise from testing the application.

Is this the same as a vulnerability scan?

No. A scan lists what a tool recognises. A penetration test has a person try to use those weaknesses, chain them together and reach something that matters. The findings that cost companies money - access control and business logic - are almost never found by a scanner.

Will you give us something we can show a customer or an auditor?

Yes. After the retest we issue a closure summary stating what was tested, when, and that the findings were fixed. That is the document enterprise buyers and ISO 27001 or PCI DSS auditors normally ask for.

// start here

Let's protect your business together.

Tell us what you need tested. Our team will reply with a clear scope and quote.

By submitting, you agree to our Terms of Use and Privacy Statement.