Penetration testing methodology: how a web application test runs, from scope to retest
How Clever Ops tests web applications and their APIs, written for the person paying for the test.
It covers how scope and authorisation are settled, what unauthenticated, authenticated and code-assisted testing each reach, how a finding is evidenced and rated, how testing behaves on a system people use, and how the retest records what your fixes changed.
In this guide
Test-coverage matrix: WSTG v4.2 and ASVS 5.0 at three depths
Fifteen rows: ten test activities and five business-logic checkpoints. Read across a row to see what each depth covers, an annotated example of the evidence it produces and an example retest entry.
How to use itHide the instructions
Use it to check a test proposal against each depth, or as a checklist when reading a report. The first column names the WSTG v4.2 tests and ASVS 5.0 requirements the row follows. A requirement number in brackets ties that cell to one requirement, and text that starts "Extra, no OWASP id" goes beyond the named tests and requirements. Retest statuses: fixed (the original reproduction fails and regression checks pass), partially fixed (some routes or part of the impact still reproduce), still reproducible (the original issue still works), and not retested (left out, or the access or build was unavailable). The application app.lab.test, its accounts and all the results shown are illustrations written for this page, not client results.
15 rows
Activity and references (WSTG v4.2 test ids, ASVS 5.0 requirements)
Unauthenticated
Map entry points and workflows (WSTG-INFO-06, WSTG-INFO-07)
- Unauthenticated
- Public pages, forms, query and body parameters, cookies set, and the redirects and errors seen in normal use, before any sign-in.
- Authenticated
- The same walk for each role, noting which requests are authenticated and which belong to a multi-step process, and mapping the principal workflows.
- Code-assisted
- Extra, no OWASP id: routes read from the routing files and API definitions, so endpoints no screen links to join the map.
- Annotated evidence example
- Map entry: POST /api/bookings/{id}/cancel, staff and customer roles, step two of a two-step flow, changes data. Annotation: the role and step columns decide which access and workflow checks the route receives later.
- Retest ledger example
- No ledger entry, because mapping produces no finding. The map is kept so the retest can show it covered the same routes on the fixed build.
Login lockout, password change and reset (WSTG-ATHN-03, WSTG-ATHN-09; ASVS v5.0.0-6.3.1, v5.0.0-6.4.3)
- Unauthenticated
- Lockout and unlock behaviour on a test account the client can afford to lock, and whether password reset resists guessing or bypass, run only on test accounts where the rules of engagement allow it.
- Authenticated
- Whether a password change asks for the current password, whether one user can change or reset another user's password, and whether reset skips multi-factor sign-in where it is on.
- Code-assisted
- The brute-force and credential-stuffing controls read in code and compared with the application's own security documentation (6.3.1).
- Annotated evidence example
- Six wrong passwords for test account cust-a1, then the right one: signed in, no lockout. Annotation: shows the threshold for one account; guessing across many accounts was not attempted.
- Retest ledger example
- Partially fixed: lockout now triggers on the web login, but the mobile API sign-in route still accepts unlimited attempts.
Session end (WSTG-SESS-06; ASVS v5.0.0-7.2.4, v5.0.0-7.4.1)
- Unauthenticated
- Limited without a session. Cookies issued before sign-in are recorded so the authenticated pass can confirm sign-in replaces them (7.2.4).
- Authenticated
- After logout or timeout, the old session cookie is replayed to see whether the server still accepts it (7.4.1).
- Code-assisted
- Extra, no OWASP id: how sessions are stored and revoked in code, including whether a role change ends existing sessions.
- Annotated evidence example
- After logout, the earlier cookie replayed on GET /api/me returned 200 with the user's profile. Annotation: the server kept the session alive, and logout cleared only the browser's copy.
- Retest ledger example
- Fixed: the replayed cookie now gets 401, and signing in again issues a new session value. Both checks were in the retest criteria.
Access between users of the same role (WSTG-ATHZ-02 horizontal tests, WSTG-ATHZ-04; ASVS v5.0.0-8.2.2)
- Unauthenticated
- Each object route requested with no session, to see whether any record comes back without signing in.
- Authenticated
- Two accounts with the same role and two live sessions. Each request naming a record is replayed with the other user's session or record id, for reads and for changes.
- Code-assisted
- Extra, no OWASP id: the query behind each route read to confirm it filters by the signed-in owner, which can reveal routes the walk-through did not reach.
- Annotated evidence example
- cust-a2's session requested GET /api/invoices/1043, owned by cust-a1, and got 200 with cust-a1's name and invoice total, redacted in the report. The owner's own request sits beside it. Annotation: the pair proves a read across accounts; writes were tested separately.
- Retest ledger example
- Still reproducible: the invoice list now filters by owner, but the single-invoice route still returns another customer's invoice.
Access between roles (WSTG-ATHZ-02 vertical tests, WSTG-ATHZ-03; ASVS v5.0.0-8.2.1, v5.0.0-8.3.1)
- Unauthenticated
- Admin routes found during mapping requested with no session.
- Authenticated
- Requests made by an administrator replayed with a lower role's session, and parameters that carry a role or group changed, to see whether a lower role reaches higher-role functions.
- Code-assisted
- Each function's role check located in server code, confirming it does not rely on browser-side code (8.3.1).
- Annotated evidence example
- A customer session sent POST /api/admin/refunds, copied from the staff map, and a refund was created against a test order. Annotation: proves a function-level gap on this route; the refund was reversed and listed for clean-up.
- Retest ledger example
- Not retested: refunds moved to a new service before the retest, outside the agreed scope, so the finding stays open and is reported as not retested.
Access between customer organisations (ASVS v5.0.0-8.4.1; WSTG v4.2 has no test specific to tenants, so the method is an extra with no WSTG id)
- Unauthenticated
- Not applicable: tenant boundaries can only be reached with accounts.
- Authenticated
- Accounts in two separate organisations. Object and list routes are replayed across the boundary, including exports, search and indirect references such as attaching a note to the other organisation's record.
- Code-assisted
- The organisation filter traced from the session to each query, including exports and background jobs that build their own queries.
- Annotated evidence example
- An Org B user's export request returned a CSV containing three Org A contacts. Annotation: a read across organisations through a route no screen uses; contact details are masked in the report.
- Retest ledger example
- Partially fixed: exports are now filtered, but search suggestions still show Org A contact names to Org B users.
Injection into queries and stored content (WSTG-INPV-05, WSTG-INPV-02; ASVS v5.0.0-1.2.4, v5.0.0-1.3.1)
- Unauthenticated
- Public inputs such as search, enquiry and sign-up fields checked for SQL injection points, and for stored input later shown to other visitors.
- Authenticated
- The same checks on inputs behind sign-in, especially rich text, comments and notes that other users or staff view later.
- Code-assisted
- Queries read for SQL built from strings instead of parameterised queries (1.2.4), and rich-text handling read for an HTML sanitiser (1.3.1).
- Annotated evidence example
- A note saved with a harmless marker element came back unencoded from GET /api/notes and rendered through a raw HTML path. Annotation: storage and the rendering path are proven; script execution is listed as unconfirmed because no browser run observed it.
- Retest ledger example
- Fixed: the marker now renders as plain text in each view named in the retest criteria.
File uploads (WSTG-BUSL-08, WSTG-BUSL-09; ASVS v5.0.0-5.2.2, v5.0.0-5.3.1)
- Unauthenticated
- Public upload points, such as a job application or quote form, tried with file types the business does not expect and with harmless files whose content does not match their extension.
- Authenticated
- Signed-in uploads such as profile images and documents, including how uploaded files are processed and whether a stored file is served back in a way that runs as code (5.3.1).
- Code-assisted
- The upload handler read for the extension and content checks 5.2.2 describes, and for where stored files land.
- Annotated evidence example
- A text file renamed invoice.pdf was accepted and later served from the public files path. Annotation: shows the extension alone is trusted; no executable content was uploaded.
- Retest ledger example
- Still reproducible: the server now checks extensions against a list, but still does not check that the content matches.
Secrets in browser code and verbose errors (WSTG-INFO-05, WSTG-ERRH-01; ASVS v5.0.0-13.3.1, v5.0.0-13.4.2, v5.0.0-16.5.1)
- Unauthenticated
- JavaScript and source maps served to visitors read for keys and credentials, and unexpected input sent to public routes to see what error output comes back.
- Authenticated
- The same review for scripts and error responses that appear only after sign-in.
- Code-assisted
- The repository and build output checked for secrets in source code or build artefacts (13.3.1), and production settings checked for debug modes (13.4.2).
- Annotated evidence example
- A dashboard bundle served after sign-in holds a key in the format a payment provider uses for secret server keys. The key was not used. Annotation: the finding rests on the key's format and where it was served, so the rating assumes the key is live until your team shows otherwise.
- Retest ledger example
- Fixed: the key is revoked and replaced, no secret key appears in the served files checked, and your developer has confirmed the revocation in writing.
Software components and versions (WSTG-INFO-08; ASVS v5.0.0-15.2.1)
- Unauthenticated
- Components fingerprinted from headers, cookies, page source, file paths and file extensions.
- Authenticated
- Extra, no OWASP id: components visible only after sign-in, such as an editor or chart library loaded in the dashboard.
- Code-assisted
- The dependency lockfile compared with the application's documented update time frames (15.2.1). Extra, no OWASP id: versions matched against vendor advisories.
- Annotated evidence example
- The lockfile pins a rich-text editor release that its vendor's advisory says was fixed in a later version. Annotation: matched to the advisory by version; exploitability in this application was not demonstrated, and the rating reflects that limit.
- Retest ledger example
- Partially fixed: the editor is updated in the customer app, but the admin bundle still loads the old version.
Business-logic checkpoint: values the server should refuse (WSTG-BUSL-01; ASVS v5.0.0-2.2.2)
- Unauthenticated
- Guest flows such as a public quote or booking form, with the browser's own checks skipped and logically invalid values sent straight to the server.
- Authenticated
- Signed-in flows with values that pass format checks but break business rules, such as a negative quantity, a booking date in the past or a discount above the allowed limit.
- Code-assisted
- Extra, no OWASP id: validation rules read in server code and compared with the rules your team describes, since an unwritten rule cannot be tested against.
- Annotated evidence example
- A cart line saved with quantity -2 lowered the order total, and checkout accepted it on test data. Annotation: the browser blocked the value and the server did not, so the finding is about the server check.
- Retest ledger example
- Fixed: the server now rejects quantities below one with a 400 response, and the browser check is unchanged.
Business-logic checkpoint: steps that can be skipped or reordered (WSTG-BUSL-06; ASVS v5.0.0-2.3.1)
- Unauthenticated
- Public multi-step flows, such as sign-up with email confirmation, tried out of order.
- Authenticated
- Paid or approval flows tried out of order: a confirmation step requested before payment or approval, and earlier steps replayed after a later one has run.
- Code-assisted
- Extra, no OWASP id: the state check behind each step read in code, to see whether a step confirms the one before it finished.
- Annotated evidence example
- POST /api/orders/{id}/confirm sent straight after the cart step marked a test order paid with no payment record. Annotation: run on staging; the order was voided and listed for clean-up.
- Retest ledger example
- Not retested: staging was unavailable during the retest, so no result is claimed for this finding.
Business-logic checkpoint: one-time actions used more than once (WSTG-BUSL-05; ASVS v5.0.0-2.3.2)
- Unauthenticated
- Public offers such as a first-order code or a free trial, tried again from the same visitor session and from a new one.
- Authenticated
- Discount codes, invites, referral credits and trial extensions applied more than once, including by going back a step and applying again.
- Code-assisted
- Extra, no OWASP id: where the usage count is stored and checked, and whether the check and the update happen together.
- Annotated evidence example
- One single-use code applied twice to a test order by returning to the cart page; the second discount was accepted. Annotation: the rule of one use per order came from the client's written description.
- Retest ledger example
- Still reproducible: the cart page now blocks a second use, but the API applies the code twice when called directly.
Business-logic checkpoint: limited resources booked twice (ASVS v5.0.0-2.3.4; WSTG v4.2 has no matching test, so the method is an extra with no WSTG id)
- Unauthenticated
- Public booking or ticketing flows, where they work without sign-in.
- Authenticated
- Two test accounts request the last slot, seat or stock item at nearly the same moment, using a handful of requests, to see whether both succeed.
- Code-assisted
- Booking code read for a lock or transaction around the availability check and the write.
- Annotated evidence example
- Two near-simultaneous bookings for the final 10 am slot on a test calendar both returned 201. Annotation: two requests only, inside the agreed rate; both test bookings were removed afterwards.
- Retest ledger example
- Fixed: the second request now receives a conflict response, checked across repeated pairs of requests on the retest build.
Business-logic checkpoint: fields the server should control (WSTG-BUSL-02, WSTG-ATHZ-03; ASVS v5.0.0-15.3.3, v5.0.0-8.2.3)
- Unauthenticated
- Public sign-up and enquiry requests sent with extra fields, such as role or account type, that the form never shows.
- Authenticated
- Profile and record updates sent directly with fields such as role, organisation id, price or status added or changed.
- Code-assisted
- The update handlers read for a list of the fields each action may change (15.3.3).
- Annotated evidence example
- PATCH /api/profile with role set to admin returned the user with the admin role, and an admin-only route then returned 200. Annotation: the role was set back after testing, and the report records that.
- Retest ledger example
- Partially fixed: profile updates now ignore role, but the team-invite route still accepts a role value from the browser.
Penetration testing methodology in five phases
A penetration testing methodology is the order the work happens in and the record each step leaves behind.
For a buyer, the record matters more than the order. It is how you check that the test covered what you paid for, that nothing happened outside the agreement, and that a fix closed the finding it was meant to close. This page sets out the method Clever Ops follows for web applications and APIs, phase by phase, in terms a buyer can check.
Published methodologies divide the work in different ways. The OWASP Web Security Testing Guide (WSTG) v4.2 lists the Penetration Testing Execution Standard among them, which describes a test as seven phases running from pre-engagement interactions to reporting. The method below keeps that opening and closing, groups the technical phases into one testing phase, separates evidence from reporting, and adds the retest that follows your fixes.
The individual checks come from WSTG v4.2, and the requirements they are measured against come from the OWASP Application Security Verification Standard (ASVS) 5.0.
- Scope and authorisation. You hold a written scope and a signed letter naming each target, the testing window and what is off limits.
- Testing. Requests are logged as they are sent, and test data is listed as it is created, which becomes the clean-up list.
- Evidence. Each finding gets redacted requests and responses, the accounts that sent them and the steps to reproduce it.
- Reporting. You receive ratings, fixes, retest criteria, negative results and a coverage statement against WSTG v4.2 and ASVS 5.0.
- Retest. Each finding ends with one status from a four-state ledger, recorded against an identified build.
Unauthenticated, authenticated and code-assisted testing
Depth is the choice that most changes what a test can prove.
Test one application at three depths and you get three different reports, because each depth reaches a different part of it. The labels black box, grey box and white box describe roughly the same progression, but they leave out the detail a buyer most needs: which accounts the tester will hold, and whether any code will be read.
Unauthenticated: what a stranger can reach
Without an account, the test covers public pages and forms, sign-up, login and password reset, public API routes, and the code your site sends to each browser. It answers one question well: what can someone do to your application before signing in?
WSTG-ATHZ-02 asks whether a resource can be reached without authenticating, so object and admin routes named in that browser code are requested with no session. Everything behind the login stays out of view.
ASVS 5.0 makes the same point about itself: even its Level 1 is not necessarily testable by an outside tester who has no documentation or code.
Authenticated: two accounts for each role
For an application with customer accounts, the rules about who may see and change what sit behind the login. WSTG-ATHZ-02 tests horizontal access with two users who hold identical privileges and two live sessions, swapping one user's session or identifiers into the other's requests, and its vertical tests do the same between roles.
WSTG-ATHZ-04 describes testing with at least two users who own different objects as the best way to find insecure direct object references. That is why the scope asks for two test accounts per role.
An application that serves several customer organisations from one database needs accounts in two of them as well. ASVS 5.0 requirement v5.0.0-8.4.1 asks for cross-tenant controls in multi-tenant applications, and only accounts on both sides of the boundary can show whether those controls hold.
Code-assisted: reading the code behind the routes
With read-only access to the repository, the test reads the code behind the riskiest routes as well as calling them. The WSTG v4.2 introduction notes that dynamic testing struggles to reach a whole code base, and that source review is particularly suited to flawed business logic, access control problems, concurrency problems and cryptographic weaknesses.
It also names the catch: the code being read may differ from the code deployed. So a weakness seen in code is confirmed against the running build where the scope allows, and a finding that rests on the code alone says so.
Code-assisted testing here is targeted at the areas the scope names, not a line-by-line review of the whole repository. ASVS 5.0 leans the same way: its assessment chapter strongly encourages documentation or source-code-led (hybrid) testing and says many ASVS requirements need it to be verified.
Choosing the depth
The depth follows what the application does and who will rely on the report.
- Unauthenticated suits a site where only your own editors sign in, or a first look before a deeper test.
- Authenticated suits any application where customers sign in, pay, upload files or see records that belong to them alone.
- Code-assisted suits an application whose riskiest logic sits in a few places your developers can point to, such as pricing, permissions or tenancy, or one where an earlier finding may have siblings elsewhere in the code.
Phase two: how testing is conducted on a system people use
A penetration test sends real requests to a real application, often one with customers on it.
These are the working rules for the testing window. They are written into the rules of engagement, and changing any of them needs your written agreement first.
- Requests go only to the targets named in the signed letter, from the source addresses it lists.
- The request rate is capped. If a firewall starts blocking, or the application keeps answering with rate-limit errors, testing on that target pauses and your contact hears about it.
- Destructive actions are off by default: no record that existed before the test is deleted, no password reset is triggered for a real person's account, and nothing is sent by email or text message to a real person. Reset, lockout and deletion checks run only on test accounts and test records, where the rules of engagement allow them.
- Where a staging copy matches production, testing starts on staging.
- Each request is logged, so a question about what was sent, and when, can be answered from the record.
- Test data is tracked as it is created, then removed or listed in the report for your team to remove.
- Denial-of-service, load and volumetric testing are not part of any engagement.
- Your technical contact can ask for testing to pause if anything looks wrong.
How evidence and your data are handled
Evidence keeps only what a finding needs. Session tokens, passwords, keys and personal details are redacted from requests, responses, URLs and screenshots, while identifiers that let your developers trace a request are kept. Evidence is stored encrypted in Australia and deleted on the schedule set in the data handling terms, and it is processed outside Australia only where your statement of work approves it.
Phase three: what counts as evidence for a finding
A finding is a claim about your application, and evidence is what lets someone else check it.
The WSTG v4.2 introduction sets a useful bar: the record of a test should let another tester reproduce the results. Each finding in this method carries the following.
- The request and the response, redacted, with the account, role and organisation that sent it.
- The build or version and the date tested, because a finding describes one build rather than the application for all time.
- A contrasting request where one helps, such as the owner reading their own record beside a second user reading the same record, so the boundary is shown rather than asserted.
- The impact that was demonstrated, kept apart from the impact that is inferred from it.
- Any verification limit, such as script execution that was not observed in a browser, and how the retest will settle it.
- Retest criteria, written when the finding is reported, so your developer knows in advance what the second look will check.
Why demonstrated and inferred impact stay apart
The lab sample report shows the difference in practice. One of its findings stored a script payload and traced it to a raw HTML rendering path, but no browser was available to watch it run, so the finding states that limit and its retest criteria ask for browser confirmation.
The sample comes from a lab application Clever Ops controls, not from a client. A finding written this way can be rated honestly now and tightened later, without anyone having to guess what was proven.
Negative results are evidence too
A check that found nothing is recorded with the request, account and build it covered. That gives the report a second use: when a customer later asks whether cross-account access was tested, you can show which routes were tried, with which accounts, on which build. A negative result speaks for what was tried, and the report keeps it to that rather than stretching it to routes or variations nobody tested.
How a finding is rated
Each rated finding carries two ratings.
The first is a CVSS v3.1 score. The FIRST specification builds CVSS from three metric groups, Base, Temporal and Environmental. The Base group describes how a weakness can be exploited and the direct consequence if it is, and the Base score runs from 0.0 to 10.0. The score is reported with its vector string, so anyone can see the inputs behind the number and challenge one.
CVSS v3.1 maps scores to a qualitative scale, and the report uses those words for technical severity:
- None:0.0.
- Low:0.1 to 3.9.
- Medium:4.0 to 6.9.
- High:7.0 to 8.9.
- Critical:9.0 to 10.0.
The business-risk rating beside the score
The second rating is for your business. FIRST notes that organisations can feed CVSS into a wider process that also weighs factors outside it, such as the number of customers on a product line or monetary losses due to a breach, and that those factors are outside the scope of CVSS.
The business-risk rating does that work for your application: it weighs the data involved, how exposed the affected feature is, the controls already in place and the cost of disruption.
In the lab sample report, a read and write across customer organisations scored 8.1, High, on CVSS and was rated Critical for the business, because it broke the boundary between customers.
Each finding is also mapped to its OWASP Top 10:2025 category, which helps when a questionnaire asks about particular types of risk. Ratings are revisited if further testing or the retest changes the facts they rest on.
Phase four: the coverage statement, and why it says tested against
The report states what was tested against WSTG v4.2 and ASVS 5.0.
It does not say your application is ASVS compliant, and it is not a certificate. ASVS 5.0 is direct about this: OWASP does not certify vendors, verifiers or software, and any assurance or certification claiming ASVS compliance is not officially endorsed by OWASP.
ASVS 5.0 also contrasts traditional penetration test reports, which list failures by exception, with what it expects of an ASVS certification report: the scope, a summary of the requirements checked, the exceptions, guidance on fixing them, and a note of requirements that do not apply. The coverage statement borrows that discipline without claiming a certification.
For each WSTG test and ASVS requirement in scope, it records the depth used, the result, and whether the item did not apply to your application. Items that were in scope but could not be tested are listed as limitations, with the reason.
In the report, identifiers carry their version, as both standards recommend, because numbers change between editions. WSTG-v42-ATHZ-04 is the WSTG v4.2 test for insecure direct object references, and v5.0.0-8.2.2 is the ASVS 5.0 requirement on data-specific access. The WSTG v4.2 reporting chapter suggests attaching a checklist of the tests conducted, and its example disclaimer calls a test a point in time assessment.
The coverage statement is that checklist with results, and the report gives the dates and build so a reader can see which point in time it describes.
Phase five: the retest and its four-state ledger
The retest checks your fixes against the criteria written into each finding.
One consolidated retest is included. You request it within the window set in your statement of work, once the fixes are deployed to an identified build of the same application. It covers the reported findings within the agreed scope; new features and unrelated changes are scoped as separate work, because they were not part of the original test.
Each finding then takes one of four statuses, defined before the retest starts:
- Fixed: the original reproduction fails and the agreed regression checks pass.
- Partially fixed: some affected routes, or part of the impact, can still be reproduced.
- Still reproducible: the original issue still works under the agreed test conditions.
- Not retested: the finding was left out of the retest, or the access or build it needs was unavailable.
Why not retested is its own status
An untested finding stays marked as not retested in the updated report, so a customer reading it is told no more than was checked. The WSTG v4.2 reporting chapter suggests the same shape for a re-test: a summary of the previous findings and the updated status of each one. Findings from another provider's report can be retested as a separate piece of work, against the evidence in their report.
What helps a retest go cleanly
Most retest friction comes from builds and accounts, not from the fixes themselves.
- Deploy all the fixes to one identified build and say which build it is.
- Keep the test accounts from the original test, so the same requests can be replayed.
- Say which findings you chose not to fix, so they are marked not retested with your reason.
- Run the regression checks from each finding's retest criteria yourself first. A fix that fails them is easier to catch before the retest than during it.
Where the method stops
A method makes a test repeatable and checkable.
It does not make a test exhaustive, and a buyer is better served by knowing where it ends.
- A test covers one build, in one window, with the accounts and roles it was given. Code released afterwards sits outside it.
- Business logic can only be tested against rules someone states. WSTG v4.2 says business logic flaws cannot be detected by a vulnerability scanner and that a third-party tester has to ask the business which operations should be allowed, so the scope asks for your key rules in writing.
- Code-assisted findings rest on the code as read, which may differ from what is deployed. The report marks which findings were confirmed on the running build.
- Services run by other businesses, your host's platform, office networks, staff devices and denial-of-service testing are outside the method. Internal network, Active Directory and red team work goes to a specialist in that field.
- Where a tender, panel or contract requires a CREST-accredited provider, the work goes elsewhere. Clever Ops is not CREST accredited, so we refer that work to a provider that is.
- A report is evidence for a decision someone else makes, such as a customer or an auditor. It is not a certificate for the application.
Frequently asked questions
The OWASP Web Security Testing Guide (WSTG) v4.2 describes how to test: each test has an id, objectives and steps, such as WSTG-ATHZ-04 for insecure direct object references. ASVS 5.0 describes what to verify: around 350 requirements in 17 chapters, assigned to three levels, L1 to L3. A test plan uses WSTG for the procedure and ASVS for the requirement each result is measured against, which is how the coverage matrix on this page is laid out.
No. The report records which ASVS 5.0 requirements were tested, at which depth and with what result. OWASP does not certify vendors, verifiers or software, and ASVS 5.0 advises caution about third-party claims of ASVS certification. If a customer asks about ASVS, give them the coverage statement and let them weigh it against their own requirement.
Roughly, unauthenticated testing is black box, authenticated testing with test accounts is grey box, and code-assisted testing moves towards white box. Providers use the labels loosely, so ask what each depth includes: which accounts, which roles, and whether any code or documentation will be read. Those answers decide what the report can prove.
Yes, when the authorisation letter names production and records which risks you accept. A staging copy that matches production is preferred, because test data and odd edge cases then stay away from customers. On production the non-destructive defaults, the capped request rate and the pause conditions all apply, and any test data left behind is listed for removal.
Because a business-logic flaw is only a flaw against a rule. A discount that applies twice, an order confirmed without payment or a quantity below one is a defect only if your business says it should not happen. A short written list of the rules that protect money, stock and customer data lets the checkpoints in the matrix test what your application is meant to allow, rather than what a tester guesses it should allow.
They keep their status in the updated report, as partially fixed, still reproducible or not retested, each with the reason. Further fix work and any additional retest are agreed separately. The original evidence stays with each finding, so a later retest can replay the same requests on the next build.
Scope the right test for your application
Tell us what you have built, who uses it and when it needs to launch. You will get a plain-English recommendation: a website audit, a web application test or a referral to a specialist.