Web application API Mobile app Network and infrastructure Cloud Source code Thick client
Web application · 9 checks
Tick what you can already prove with a test, a setting or a ticket. The rest is your shortlist for Web Application VAPT .
Sessions expire and logout revokes the token Cookies are Secure, HttpOnly and SameSite. Logging out invalidates the session on the server, not only in the browser. Every request is authorised on the server Hiding a button is not access control. Admin and tenant-scoped routes refuse the call even if the UI never shows it. Object IDs do not grant access Changing an invoice, file or user id in the URL returns a record only if that user is allowed to see it. Input is validated and output is encoded Queries are parameterised and user content is encoded for the context it lands in, which closes SQL injection and XSS. Uploads cannot become code Type, size and storage location are enforced, and files are never executed from the upload path. State-changing requests resist CSRF Anti-forgery tokens or strict SameSite cookies protect every action that changes data. Login and reset flows resist abuse Rate limiting, lockout or step-up checks, and reset tokens that expire and work once. Security headers and TLS are set HTTPS everywhere with HSTS, plus a Content-Security-Policy and clickjacking protection. Errors and logs say less to strangers Customers see a short message. Stack traces, queries and library versions stay in your logs.
API · 9 checks
Tick what you can already prove with a test, a setting or a ticket. The rest is your shortlist for API Security Testing .
Object-level authorisation on every endpoint Each call checks that the caller owns the object it references (BOLA / IDOR), not just that the caller is logged in. Function-level authorisation is enforced Admin and internal functions refuse ordinary tokens, whatever HTTP method or path is used. Tokens are short-lived and scoped JWT or OAuth tokens carry only the scopes needed, expire quickly and are validated for signature, issuer and audience. Responses return only what is needed No full database objects. Sensitive fields are filtered on the server to stop excessive data exposure. Mass assignment is blocked Clients cannot set fields such as role, price or owner by adding them to a request body. Rate limits and quotas exist Per-user and per-key limits protect login, search, export and any costly endpoint from abuse and scraping. Schemas are validated Requests are checked against a schema for type, length and format, and unexpected fields are rejected. The API inventory is known Old versions, shadow endpoints and test routes are listed, owned and retired, so nothing runs unmonitored. Third-party API calls are treated as untrusted Data from partners is validated, and server-side fetches cannot be pointed at internal addresses (SSRF).
Mobile app · 9 checks
Tick what you can already prove with a test, a setting or a ticket. The rest is your shortlist for Mobile App VAPT .
No secrets are shipped in the app API keys, tokens and private URLs are not in the binary, resources or config files anyone can unpack. Data at rest is protected Sensitive data uses the iOS Keychain or Android Keystore, and is not left in plain files, logs or backups. Traffic uses TLS with certificate pinning All calls use HTTPS, and critical apps pin certificates so a rogue proxy cannot read the traffic. The backend does not trust the app Authorisation and business rules live on the server, so a modified client gains nothing. Biometric and local auth are done right Local unlock is tied to a server check or a keystore-bound key, not a simple on-device flag. Deep links and intents are validated Custom URL schemes, exported components and WebViews cannot be abused by another app or a crafted link. Root, jailbreak and tamper checks fit the risk Detection and obfuscation are in place where the app handles money or health data, and are not the only defence. Clipboard, screenshots and caches are controlled Sensitive screens are hidden in app switchers, and tokens and personal data do not linger in caches. Third-party SDKs are reviewed Each SDK is needed, up to date and limited to the data and permissions it must have.
Network and infrastructure · 9 checks
Tick what you can already prove with a test, a setting or a ticket. The rest is your shortlist for Network VAPT .
Only needed ports and services are exposed An external scan shows the services you expect and nothing else, such as forgotten databases or admin panels. Default and shared credentials are gone Devices, appliances and services no longer use factory passwords, and admin interfaces are not public. Systems are patched on a schedule Internet-facing hosts get critical fixes quickly, with a record of what is exposed and what is outdated. Remote access uses MFA VPN, RDP and SSH are protected by multi-factor authentication and are not open to the whole internet. The network is segmented Servers, user devices, guests and management interfaces sit in separate zones, so one foothold does not reach everything. Active Directory is hardened Privileged accounts are few, service accounts have strong secrets, and legacy protocols such as NTLM and SMBv1 are off. Encryption protects data in transit Modern TLS and SSH settings are used, and weak ciphers and expired certificates are removed. Logging and alerting reach a person Firewall, VPN and authentication logs are kept and reviewed, and someone is told when they look wrong. Wi-Fi and guest access are separated Corporate wireless uses strong authentication and guest networks cannot reach internal systems.
Cloud · 9 checks
Tick what you can already prove with a test, a setting or a ticket. The rest is your shortlist for Cloud Security Assessment .
The root account is locked down Root or global-admin use is rare, protected by MFA and monitored, with no access keys attached. IAM follows least privilege Roles and policies grant only what each person and service needs, with no wildcard permissions left over. Storage is private by default Buckets and blobs block public access unless a reviewed exception exists, and are encrypted at rest. Secrets live in a vault Keys, tokens and passwords sit in a secrets manager, rotate regularly and are not in code, images or environment dumps. Network exposure is minimal Security groups and firewall rules avoid 0.0.0.0/0 on management and database ports, and workloads sit in private subnets. Audit logging is on and kept CloudTrail, Activity Log or Cloud Audit Logs record admin activity in every account and region, in a place attackers cannot edit. Configuration is checked continuously Misconfigurations are caught by policy-as-code or posture tools before and after deployment. Containers and Kubernetes are hardened Images are scanned and minimal, pods do not run as root, and the cluster API and dashboard are not public. Backups work and are separated Backups are tested for restore, stored in a separate account or region, and protected from deletion.
Source code · 9 checks
Tick what you can already prove with a test, a setting or a ticket. The rest is your shortlist for Source Code Review .
Secrets are not in the repository or its history Scanning runs on every commit, and any key that was ever committed has been rotated. Dependencies are tracked and patched A software bill of materials or dependency scan flags known-vulnerable libraries, with an owner for each fix. Authentication code is reviewed Password storage, session handling, token validation and reset flows use vetted libraries and no home-made crypto. Authorisation checks are central Access rules are enforced in one consistent layer rather than copied by hand into each route. Injection sinks are safe Database, OS command, template and deserialisation calls use parameterised or allow-listed inputs. Sensitive data is handled deliberately Personal and payment data is minimised, encrypted and kept out of logs, URLs and error messages. Static analysis runs in CI SAST and secret scanning run on pull requests, and high-severity results block a merge. The build pipeline is protected CI/CD secrets are scoped, third-party actions are pinned, and only reviewed code can reach production. Security-relevant changes get a second reviewer Changes to auth, crypto, payments and permissions need a named reviewer who understands the risk.
Thick client · 9 checks
Tick what you can already prove with a test, a setting or a ticket. The rest is your shortlist for Thick Client VAPT .
No credentials or keys are hard-coded Binaries, config files and the registry hold no embedded passwords, connection strings or API keys. The server enforces every rule The desktop client is treated as untrusted, so changing it or its memory does not bypass business logic. Local storage is protected Cached data, databases and temp files are encrypted or access-controlled and cleaned up after use. Network traffic is encrypted and verified The client uses TLS with certificate validation, and does not send sensitive data over plain protocols. Direct database access is avoided The app talks to an API with its own authorisation, not straight to a database with shared credentials. Updates are signed and verified The installer and updater check a signature before running code, and do not fetch from unprotected locations. DLL and library loading is safe The application loads libraries from trusted paths only, which prevents search-order hijacking. Installed files have correct permissions Services, folders and scheduled tasks cannot be modified by ordinary users to gain higher privileges. Logs and crash dumps hide sensitive data Diagnostic output omits credentials, tokens and personal information.