Skip to content

Methodology reference

How we test, track by track.

The scope, checks, safety constraints and references behind every ProteQon service, from web and APIs to OT networks, published so you know what a test covers before it starts.

34
test areas
202
tool references
9
service tracks

This is a reference for authorized testing only. Every technique here is used strictly within a written scope and rules of engagement agreed with the system owner.

00 · Engagement lifecycle

From authorization to retest

  1. 01

    Scope and authorize

    Targets, accounts, testing windows and rules of engagement are agreed in writing before any traffic is sent.

  2. 02

    Map the surface

    Reconnaissance builds an inventory of hosts, endpoints, parameters and technologies inside the agreed scope.

  3. 03

    Test and exploit

    Each class of weakness below is tested manually, with tools used to extend coverage rather than replace judgement.

  4. 04

    Verify impact

    Findings are reproduced and rated by priority so that what reaches the report is real and explainable.

  5. 05

    Report

    Evidence, impact and remediation for every finding, in a format engineering and audit can both use.

  6. 06

    Retest

    Fixes are verified and the report is updated with the result.

Priority model

How findings are ranked

P1
Critical
Remote code execution, authentication bypass, data breach at scale
P2
High
Significant data exposure, privilege escalation, stored XSS on sensitive pages
P3
Medium
Limited data exposure, reflected XSS, CSRF on sensitive functions
P4
Low
Information disclosure, minor misconfigurations, self-XSS
P5
Informational
Best-practice recommendations, minimal/no security impact

Service tracks

Pick the surface you need tested

  1. 01Web applicationsOWASP Web Security Testing Guide (WSTG)
  2. 02APIs (REST, GraphQL, SOAP)OWASP API Security Top 10 (2023)
  3. 03Mobile applicationsOWASP MASVS
  4. 04Thick clientsOWASP Desktop App Security Top 10
  5. 05Network and Active DirectoryNIST SP 800-115, Technical Guide to Information Security Testing
  6. 06Cloud (AWS, Azure, GCP)AWS penetration testing policy
  7. 07IoT and embedded devicesOWASP IoT Security Testing Guide (official source)
  8. 08OT and industrial control systemsNIST SP 800-82 Rev. 3, Guide to OT Security
  9. 09PTaaS (continuous testing)NIST SP 800-218, Secure Software Development Framework

Track 01

Web applications

Authenticated, role-aware testing of browser-facing applications. The detailed check list, tools and priority model follow in the phases below.

We agree before testing

  • Hostnames, environments and excluded paths
  • Test accounts for every role and at least two tenants
  • Third-party components we may and may not touch

Safety constraints

  • No denial-of-service or load testing unless agreed in writing
  • Destructive actions only against data we created
  • Critical findings reported immediately, not held for the report

Web phase 01

Reconnaissance

Passive and active information gathering before any exploitation attempt. Goal: map the full attack surface of the target.

Identify all subdomains of the target to expand the attack surface. Combine passive (cert transparency, threat intel) with active (bruteforce) methods.

  • Sublist3r

    Fast subdomains enumeration for penetration testers

  • Amass

    In-depth Attack Surface Mapping and Asset Discovery

  • massdns

    High-performance DNS stub resolver for bulk lookups

  • Findomain

    Fastest cross-platform subdomain enumerator

  • subfinder

    Subdomain discovery tool — valid subdomains for websites

  • shuffleDNS

    Enumerate valid subdomains via active bruteforce + wildcard handling

  • dnsx

    Fast multi-purpose DNS toolkit

  • assetfinder

    Find domains and subdomains related to a given domain

  • censys-subdomain-finder

    Subdomain enumeration via certificate transparency logs (Censys)

  • altdns

    Generates permutations and mutations of subdomains then resolves them

  • VHostScan

    Virtual host scanner that performs reverse lookups

  • hakrevdns

    Small, fast tool for reverse DNS lookups en masse

  • Sudomy

    Subdomain enumeration + automated reconnaissance for bug hunting

  • dnscan

    Python wordlist-based DNS subdomain scanner

  • knockpy

    Enumerate subdomains on a target domain through a wordlist

  • scilla

    DNS / Subdomains / Ports / Directories enumeration

  • sub3suite

    Research-grade suite for subdomain enumeration and attack surface mapping

  • crtndstry

    Certificate-based subdomain finder

Identify open ports and services running on discovered hosts.

  • masscan

    TCP port scanner — SYN packets asynchronously at massive speed

  • RustScan

    The Modern Port Scanner — fast with nmap integration

  • naabu

    Fast port scanner in Go — reliability and simplicity

  • nmap

    The Network Mapper — industry standard port/service scanner

  • sandmap

    Nmap on steroids — 31 modules with 459 scan profiles

  • ScanCannon

    Combines masscan speed with nmap detailed enumeration

Capture screenshots of web interfaces across all discovered hosts for rapid visual triage.

  • EyeWitness

    Screenshots of websites + server header info + default credentials

  • aquatone

    Visual inspection of websites across large amounts of hosts

  • gowitness

    Go-based web screenshot utility using Chrome Headless

  • WitnessMe

    Web inventory + screenshots using Pyppeteer (headless Chromium)

  • eyeballer

    CNN for analyzing pentest screenshots — automatic triage

  • httpscreenshot

    Screenshots and HTML capture for large numbers of websites

Fingerprint technologies, frameworks, and libraries in use. Enables targeted vulnerability research.

  • Wappalyzer

    Identify technology on websites — browser extension + CLI

  • webanalyze

    Port of Wappalyzer for automated mass scanning

  • whatweb

    Next generation web scanner — 1800+ plugins

  • retire.js

    Detect JavaScript libraries with known vulnerabilities

  • httpx

    Fast multi-purpose HTTP toolkit — probers with retryablehttp

  • fingerprintx

    Service discovery on open ports — works with common bug bounty tools

Discover hidden files, directories, and endpoints not linked from the application surface.

  • gobuster

    Directory/File, DNS and VHost busting tool in Go

  • feroxbuster

    Fast, simple, recursive content discovery written in Rust

  • dirsearch

    Web path scanner — comprehensive and widely used

  • recursebuster

    Rapid content discovery tool for recursively querying webservers

  • gospider

    Fast web spider written in Go

  • hakrawler

    Simple, fast web crawler for quick endpoint discovery

  • crawley

    Fast, feature-rich unix-way web scraper/crawler

  • filebuster

    Extremely fast and flexible web fuzzer

Uncover hidden GET/POST parameters — critical for finding injection points and cache poisoning.

  • Arjun

    HTTP parameter discovery suite — most reliable

  • param-miner

    Burp extension — identifies hidden, unlinked parameters (cache poisoning)

  • ParamSpider

    Mining parameters from dark corners of Web Archives

  • parameth

    Brute-force discover GET and POST parameters

  • x8

    Hidden parameters discovery suite written in Rust

  • ParamPamPam

    Brute-discover GET and POST parameters

Send malformed/unexpected inputs to discover unexpected behaviours and vulnerabilities.

  • ffuf

    Fast web fuzzer written in Go — industry favourite

  • wfuzz

    Web application fuzzer — highly configurable

  • fuzzdb

    Dictionary of attack patterns for black-box fault injection

  • IntruderPayloads

    Collection of Burp Intruder payloads and fuzz lists

  • fuzzapi

    REST API pentesting tool using API_Fuzzer

  • qsfuzz

    Query String Fuzz — build rules to fuzz query strings

  • fuzzilli

    JavaScript Engine Fuzzer by Google Project Zero

  • vaf

    Very advanced web fuzzer written in Nim

Web phase 02

Exploitation

Active testing and exploitation of discovered attack vectors. Always within authorized scope.

Manual payloads: ; id, | id, && id, $(id), ` id`, \n id, %0aid — test all injection contexts including headers, form fields, filenames, and JSON values.

VRT Severity: Critical (P1) when RCE is achievable. High (P2) for blind/limited command injection. Enables full server compromise.

  • commix

    Automated All-in-One OS command injection and exploitation tool

VRT Severity: High (P2) when sensitive data is accessible to arbitrary origins. Medium (P3) if limited impact. Check for wildcard + credentialed requests.

  • Corsy

    CORS Misconfiguration Scanner

  • CORStest

    Simple CORS misconfiguration scanner

  • cors-scanner

    Multi-threaded scanner for CORS flaws/misconfigurations

  • CorsMe

    Cross Origin Resource Sharing MisConfiguration Scanner

VRT Severity: Medium (P3) typically. Can escalate to P2 if HTTP response splitting enables session fixation or phishing.

Test checklist: Missing/predictable CSRF token · SameSite cookie attribute absent · Referer-based bypass · JSON CSRF · Flash-based CSRF

VRT Severity: High (P2) on state-changing sensitive actions (password change, fund transfer). Medium (P3) on lower-impact actions. Requires authenticated session.

  • XSRFProbe

    The Prime CSRF Audit and Exploitation Toolkit

VRT Severity: High (P2) when arbitrary file read is possible (e.g., /etc/passwd, source code, secrets). Critical (P1) if write access or RCE achievable.

  • dotdotpwn

    The Directory Traversal Fuzzer

  • FDsploit

    File Inclusion & Directory Traversal fuzzing and exploitation

  • off-by-slash

    Burp extension — detect alias traversal via NGINX misconfiguration

VRT Severity: Critical (P1) for RFI (Remote File Inclusion → RCE). High (P2) for LFI with sensitive file read. Medium (P3) for limited LFI.

  • liffy

    Local file inclusion exploitation tool

  • LFISuite

    Totally Automatic LFI Exploiter + Reverse Shell + Scanner

  • Burp-LFI-tests

    Fuzzing for LFI using Burpsuite

  • LFI-Enum

    Scripts to execute enumeration via LFI

  • LFI-files

    Wordlist to bruteforce for LFI

VRT Severity: Varies P1–P4 depending on impact. Introspection enabled = P4. Batch query abuse/DoS = P3. Data exfiltration = P2. Injection to RCE = P1.

  • InQL

    Burp Extension for GraphQL Security Testing

  • GraphQLmap

    Scripting engine to interact with a GraphQL endpoint for pentesting

  • clairvoyance

    Obtain GraphQL API schema despite disabled introspection

  • shapeshifter

    GraphQL security testing tool

  • graphql_beautifier

    Burp extension to make GraphQL requests readable

VRT Severity: Critical (P1) — almost always leads to Remote Code Execution. Java, PHP, Python, .NET all have known gadget chains.

  • ysoserial

    Generate payloads for unsafe Java object deserialization

  • GadgetProbe

    Probe Java endpoints to identify deserialization classes and libraries

  • ysoserial.net

    Deserialization payload generator for .NET formatters

  • phpggc

    Library of PHP unserialize() payloads + generator tool

Test checklist: Numeric ID → enumerate adjacent IDs · UUID → try GUID of other accounts · Horizontal + vertical privilege escalation · Mass assignment · API parameter tampering

VRT Severity: High (P2) when accessing other users' private data. Critical (P1) for mass data exfiltration. Low (P4) for publicly available data only.

  • Autorize

    Automatic authorization enforcement detection extension for Burp Suite

VRT Severity: Medium (P3) standalone. High (P2) when chained with OAuth token theft or used in phishing at scale. Low (P4) if requires user interaction with no escalation path.

  • Oralyzer

    Open Redirection Analyzer

  • Injectus

    CRLF and open redirect fuzzer

  • OpenRedireX

    Fuzzer for OpenRedirect issues

  • dom-red

    Check a list of domains against open redirect vulnerability

VRT Severity: High (P2) for financial/resource-impacting races (double-spend, free credits). Medium (P3) for minor logic bypasses.

  • turbo-intruder

    Burp Suite extension for sending large numbers of HTTP requests simultaneously

  • requests-racer

    Python library to exploit race conditions in web apps with Requests

  • race-the-web

    Tests for race conditions — includes RESTful API for CI pipelines

  • racepwn

    Race Condition framework

VRT Severity: Critical (P1) — can bypass front-end security controls, poison cache, hijack requests of other users, or achieve RCE in some configurations.

  • smuggler

    HTTP Request Smuggling / Desync testing tool written in Python 3

  • http-request-smuggling

    HTTP Request Smuggling Detection Tool

  • h2csmuggler

    HTTP Request Smuggling over HTTP/2 Cleartext (h2c)

  • tiscripts

    Create Request Smuggling Desync payloads for CLTE and TECL attacks

VRT Severity: Critical (P1) for internal network access, metadata service access, or pivoting to RCE. High (P2) for blind SSRF with limited impact. Medium (P3) for SSRF to non-sensitive internal endpoints.

  • SSRFmap

    Automatic SSRF fuzzer and exploitation tool

  • Gopherus

    Generate gopher links for SSRF exploitation and RCE

  • SSRFire

    Automated SSRF finder — domain + callback server

  • singularity

    DNS rebinding attack framework

  • ssrf-sheriff

    Simple SSRF-testing sheriff written in Go

  • B-XSSRF

    Detect and track Blind XSS, XXE & SSRF

  • httprebind

    Automatic tool for DNS rebinding-based SSRF attacks

  • lorsrf

    Bruteforce hidden parameters to find SSRF via GET and POST

VRT Severity: Critical (P1) for authentication bypass, data exfiltration, or OS command execution via SQL. High (P2) for read-only SQLi with limited data. Medium (P3) for blind/time-based with restricted access.

  • sqlmap

    Automatic SQL injection and database takeover tool — gold standard

  • NoSQLMap

    Automated NoSQL database enumeration and web application exploitation

  • SleuthQL

    Burp History parsing to discover potential SQL injection points

  • Blinder

    Python library to automate time-based blind SQL injection

  • andor

    Blind SQL Injection Tool with Golang

  • nosqli

    NoSql Injection CLI tool for MongoDB-backed websites

  • SQLiScanner

    Automatic SQL injection with Charles and sqlmap API

  • sqliv

    Massive SQL injection vulnerability scanner

VRT Severity: Stored XSS on sensitive pages = P1/P2. Reflected XSS requiring interaction = P3. DOM-based = P3. Self-XSS = P4/P5. Context matters: admin panel XSS ≠ low-traffic comment section XSS.

  • XSStrike

    Most advanced XSS scanner — context-aware

  • dalfox

    DalFox — Parameter Analysis and XSS Scanning tool (Go)

  • ezXSS

    Easy way to test Blind Cross-Site Scripting

  • xsshunter

    The XSS Hunter service — track blind XSS callbacks

  • tracy

    Find all sinks and sources of a web application

  • domdig

    DOM XSS scanner for Single Page Applications

  • xsser

    Automatic framework to detect, exploit and report XSS vulnerabilities

  • weaponised-XSS-payloads

    XSS payloads designed to turn alert(1) into P1

  • bXSS

    Identify Blind Cross-Site Scripting for bug hunters and organizations

  • XSpear

    Powerful XSS Scanning and Parameter analysis tool

  • findom-xss

    Fast DOM-based XSS vulnerability scanner

  • femida

    Automated blind-XSS search for Burp Suite

VRT Severity: Critical (P1) for SSRF or file read via XXE. High (P2) for blind/OOB XXE with confirmed data exfil. Medium (P3) for XXE without confirmed impact.

  • dtd-finder

    List DTDs and generate XXE payloads using local DTDs

  • XXEinjector

    Automatic XXE exploitation using direct and out-of-band methods

  • xxexploiter

    Tool to help exploit XXE vulnerabilities

  • xxeserv

    Mini webserver with FTP support for XXE payloads

  • docem

    Embed XXE and XSS payloads in docx, odt, pptx, etc.

  • ground-control

    Scripts for debugging SSRF, blind XSS, and XXE vulnerabilities

  • oxml_xxe

    Embed XXE/XML exploits into different filetypes

Web phase 03

Miscellaneous

Additional attack vectors not covered by the primary exploitation phase.

  • gitleaks

    Scan git repos for secrets using regex and entropy

  • truffleHog

    Search git repos for high entropy strings and secrets in commit history

  • gitrob

    Reconnaissance tool for GitHub organizations

  • git-secrets

    Prevent committing secrets and credentials into git repositories

  • GitGot

    Semi-automated search through public GitHub data for sensitive secrets

  • shhgit

    Find GitHub secrets in real time

  • detect-secrets

    Enterprise-friendly detecting and preventing secrets in code

  • whispers

    Identify hardcoded secrets and dangerous behaviours

  • rusty-hog

    Suite of secret scanners built in Rust — based on TruffleHog

  • earlybird

    Sensitive data detection — passwords, PII, outdated crypto, key files

  • WPScan

    Black box WordPress security scanner

  • WPSpider

    Dashboard for running and scheduling WordPress scans

  • CMSmap

    Python CMS scanner — WordPress, Joomla, Drupal

  • joomscan

    OWASP Joomla Vulnerability Scanner

  • wprecon

    WordPress Recon tool

  • pyfiscan

    Free web-application vulnerability and version scanner

VRT Severity: Critical (P1) for algorithm confusion (RS256→HS256) leading to admin auth bypass. High (P2) for weak secret bruteforce. Medium (P3) for sensitive data in payload.

  • jwt_tool

    Toolkit for testing, tweaking and cracking JSON Web Tokens

  • c-jwt-cracker

    JWT brute force cracker written in C

  • jwt-heartbreaker

    Check JWT for keys from known public sources

  • jwtear

    Modular CLI tool to parse, create and manipulate JWT tokens

  • jwt-hack

    Tool for JWT hacking and security testing

  • jwt-cracker

    Simple HS256 JWT token brute force cracker

VRT Severity: High (P2) when postMessage leads to XSS or sensitive data extraction. Medium (P3) for misconfigured message handlers without proper origin validation.

VRT Severity: High (P2) for confirmed takeover of an active subdomain. Medium (P3) for a dangling CNAME pointing to unclaimed service.

  • subjack

    Subdomain Takeover tool written in Go

  • SubOver

    Powerful Subdomain Takeover Tool

  • tko-subs

    Detect and takeover subdomains with dead DNS records

  • can-i-take-over-xyz

    "Can I take over XYZ?" — list of services with dangling DNS vulnerability

  • dnsReaper

    Sub-domain takeover tool — accuracy, speed, and large signature arsenal

  • takeover

    Testing subdomain takeover possibilities at mass scale

  • second-order

    Second-order subdomain takeover scanner

  • autoSubTakeover

    Check if a CNAME resolves outside scope for subdomain takeover

  • nuclei

    Fast configurable targeted scanning based on templates — massive extensibility

  • OWASP ZAP

    World's most popular free web security tool

  • nikto

    Web server scanner — 6700+ potentially dangerous files/programs

  • Sn1per

    Automated pentest framework for offensive security experts

  • Metasploit

    The world's most used penetration testing framework

  • arachni

    Web Application Security Scanner Framework

  • Osmedeus

    Fully automated offensive security framework for recon + vuln scanning

  • flan

    Cloudflare's pretty sweet vulnerability scanner

  • jaeles

    The Swiss Army knife for automated Web Application Testing

  • cariddi

    Crawl URLs and scan for endpoints, secrets, API keys, file extensions, tokens

Evidence you receive

Replayable request and response pairs, affected roles, impact, and code-level remediation for each finding.

Track 02

APIs (REST, GraphQL, SOAP)

APIs are tested as a system of objects, functions and identities, not as a list of URLs. We build an authorization matrix before testing it.

We agree before testing

  • OpenAPI / GraphQL schema or a Postman collection where available
  • Tokens for each role, tenant and machine client
  • Rate limits and quotas that must be respected

Safety constraints

  • Rate-limit and resource-consumption tests run at agreed volumes only
  • Write operations confined to test tenants

Authorization

  • Object-level authorization (BOLA) on every identifier
  • Function-level authorization on admin and internal operations
  • Property-level exposure and mass assignment
  • Tenant isolation for list, search and export endpoints

Identity and tokens

  • JWT signature, algorithm and claim validation
  • OAuth 2.0 / OIDC flows: redirect URIs, state, PKCE, scopes
  • API key scoping, rotation and leakage

Protocol specifics

  • GraphQL introspection, batching, aliasing and depth abuse
  • SOAP / XML parsers: XXE and signature wrapping
  • Versioned and undocumented endpoints (inventory drift)
  • Resource consumption and sensitive business flows

Evidence you receive

An authorization matrix showing which role reached which object, with replayable calls for every break.

Track 03

Mobile applications

iOS and Android clients are analysed statically and dynamically, and the API behind them is tested from the point of view of the client.

We agree before testing

  • Release and debug builds (IPA / APK / AAB)
  • Test accounts and any feature flags to enable
  • Whether certificate pinning and anti-tamper controls are in scope to bypass

Safety constraints

  • Testing on our own devices and emulators, never on end-user devices
  • No submission of modified builds to public app stores

Static analysis

  • Decompilation and secret discovery in the bundle
  • Manifest / Info.plist: exported components, URL schemes, ATS
  • Third-party SDKs and their permissions

Dynamic analysis

  • Local storage: Keychain, Keystore, SQLite, shared preferences, logs
  • Deep links and intents leading to account takeover
  • WebView configuration and JavaScript bridges
  • Runtime instrumentation, pinning, root / jailbreak and anti-hooking resilience

Backend from the client

  • API authorization using tokens taken from the app
  • Client-side trust: prices, roles or limits enforced only in the app

Evidence you receive

Platform-specific findings mapped to MASVS controls, with reproduction steps on a named OS version.

Track 04

Thick clients

Desktop applications are tested on the host they run on and on the wire they talk over, because both are attacker-controlled.

We agree before testing

  • Installer and supported OS versions
  • Standard-user and administrator test accounts
  • Back-end services and protocols in scope

Safety constraints

  • Testing in a dedicated virtual machine supplied or approved by you
  • Exploit attempts against native code limited to the test host

Host

  • Installation paths, permissions and service configuration
  • DLL / dylib search-order hijacking
  • Secrets and licences stored in files, registry or memory
  • Local privilege escalation through the application

Traffic

  • Interception of HTTP and proprietary protocols
  • Direct database or SMB connections from the client
  • Client-side authorization that the server does not repeat

Binary

  • Decompilation of .NET, Java and Electron code
  • Unsafe deserialization and update mechanisms
  • Memory-safety issues in native components

Evidence you receive

Host and protocol findings with the exact build, OS and privileges used.

Track 05

Network and Active Directory

External perimeter and internal network testing that follows realistic attack paths from an initial foothold to business impact.

We agree before testing

  • External IP ranges and domains you own or are authorised to test
  • Internal starting point: VPN account, jump host or on-site device
  • Systems excluded for stability or contractual reasons

Safety constraints

  • Password spraying stays below your lockout threshold
  • No exploits with known stability risk against production without approval
  • Credentials obtained are handled as evidence and never reused outside scope

Perimeter

  • Service discovery and version fingerprinting
  • Exposed management interfaces and default credentials
  • VPN, mail and remote-access hardening

Internal

  • Name-resolution poisoning and relay attacks (LLMNR, NBT-NS, NTLM)
  • Segmentation between user, server and management networks
  • Credential exposure in shares, scripts and configuration

Active Directory

  • Kerberoasting and AS-REP roasting
  • ACL and delegation abuse paths to privileged groups
  • AD CS certificate template misconfiguration
  • Tiering and privileged-account hygiene

Evidence you receive

An attack-path narrative from entry point to impact, mapped to ATT&CK techniques, with the control that would have broken each step.

Track 06

Cloud (AWS, Azure, GCP)

Configuration review and assumed-breach testing of the cloud control plane, where a single IAM mistake can outweigh every network control.

We agree before testing

  • Accounts, subscriptions or projects in scope
  • Read-only audit role plus a low-privilege starting identity
  • Provider testing policies acknowledged before work starts

Safety constraints

  • Testing follows each provider policy; prohibited activities are excluded
  • No changes to production resources without explicit approval

Identity

  • IAM privilege-escalation paths and role chaining
  • Cross-account trust and federated identity
  • Long-lived keys, unused privileges and service-account sprawl

Data and workloads

  • Public or cross-tenant storage exposure
  • Metadata service access from workloads (SSRF to credentials)
  • Serverless functions, container registries and Kubernetes RBAC

Detection

  • Logging coverage: CloudTrail, Activity Log, Cloud Audit Logs
  • Whether our actions were detected and by what

Evidence you receive

IAM paths shown as a chain of permissions, with the exact policy statement to change.

Track 07

IoT and embedded devices

The device, its firmware, its radio and its cloud are one product, so they are tested as one.

We agree before testing

  • At least two units, ideally one we may open or damage
  • Firmware images and update channel details where available
  • Companion app and cloud APIs in scope

Safety constraints

  • Destructive hardware work only on units designated for it
  • Radio testing in a controlled environment, within local regulations

Hardware

  • Board identification and debug interfaces (UART, JTAG, SWD)
  • Flash extraction and boot-chain integrity
  • Physical tamper resistance

Firmware

  • Hardcoded credentials, keys and certificates
  • Outdated components and known vulnerabilities
  • Update signing and rollback protection

Radio and cloud

  • BLE pairing, Zigbee and Wi-Fi provisioning
  • Device identity and authentication to the cloud
  • Companion app trust in device-supplied data

Evidence you receive

Findings tied to hardware revision and firmware version, with the extraction steps that make them reproducible.

Track 08

OT and industrial control systems

In operational technology, availability and safety come first. Testing is planned with your engineers and favours passive and offline techniques.

We agree before testing

  • Purdue-level map of zones, conduits and remote access
  • Test bench or spare equipment for active testing
  • Plant contacts, change windows and stop conditions

Safety constraints

  • No active scanning or writes against live controllers without written approval from operations
  • Active techniques run on a bench or during an agreed maintenance window
  • Defined stop conditions and a plant contact on call throughout

Passive and architecture

  • Asset and protocol inventory from captured traffic
  • IT/OT segmentation and remote-access paths
  • Engineering workstation and historian exposure

Protocols

  • Modbus, DNP3, S7, EtherNet/IP and OPC UA authentication and integrity
  • Unauthenticated write or program-download capability

Controls

  • Alignment with IEC 62443 security levels
  • Backup, recovery and monitoring capability

Evidence you receive

Zone-and-conduit findings with the operational consequence described in process terms, not only IT terms.

Track 09

PTaaS (continuous testing)

The same methods as the tracks above, run continuously against what changes, so new features are tested close to their release.

We agree before testing

  • Asset inventory and which tracks apply to each asset
  • Release cadence and how new features are announced to us
  • Channel for findings: ticketing, chat or both

Safety constraints

  • Same rules of engagement as a point-in-time test, reviewed whenever scope changes
  • Testing windows agreed per asset

Cadence

  • Continuous reconnaissance for new hosts, endpoints and exposures
  • On-demand testing of new releases and high-risk changes
  • Periodic deep-dive against one area per cycle

Validation

  • Every finding reproduced by an engineer before it is raised
  • Fix verification inside the subscription
  • Scanner output triaged, never forwarded raw

Evidence you receive

Findings delivered as they are confirmed, plus periodic summaries suitable for auditors.

Reference

Vulnerability rating taxonomy

Note: Severity ratings are defaults. Actual priority depends on application context, data sensitivity, exploitability, and business impact. ProteQon engineers should always justify ratings with evidence. Source: Bugcrowd VRT.

Server Security MisconfigurationP2
VulnerabilityPriorityDescription

Misconfigured DNS

P3Misconfigured DNS records enabling zone transfer, cache poisoning, or subdomain hijacking

Directory Listing Enabled

P4Web server exposes directory contents without authorization

Exposed Admin Panels

P2Admin interface accessible without authentication or with weak credentials

Lack of Password Confirmation

P4Sensitive actions (email/password change) performed without re-authentication

Missing HTTPS / SSL Stripping

P3Sensitive data transmitted over unencrypted HTTP

Security Headers Missing

CSP · HSTS · X-Frame-Options · X-Content-Type-Options

P5Absence of security headers that reduce attack surface

Verbose Error Messages

P4Stack traces, internal paths, or debug information exposed to users

Path Disclosure

P5Internal filesystem path disclosed in response

Server Version Disclosure

P5Software version information in HTTP headers or error pages

Mail Server Misconfiguration

P3Open relay, SPF/DKIM/DMARC missing, email spoofing possible

Insecure File Upload

P1Unrestricted file upload allowing web shell upload and RCE

Misconfigured Cloud Storage

P2Publicly accessible S3/Azure/GCS buckets containing sensitive data

Default Credentials in Use

P2Admin/default credentials unchanged on public-facing services

HTTP Methods Enabled

PUT · DELETE · TRACE · OPTIONS

P3Dangerous HTTP methods enabled on production server

Sensitive Data in Cache

P3Sensitive pages cached by browser or proxy without proper headers

Backup Files Exposed

P2.bak, .old, .swp, .sql backup files accessible on the web

Debug Mode Enabled in Production

P2Django DEBUG=True, Laravel debug mode — exposes env vars and config
Broken Authentication & Session ManagementP1
VulnerabilityPriorityDescription

Authentication Bypass

P1Bypass authentication entirely without valid credentials

Weak Password Policy

P4No minimum password length, complexity, or history enforcement

No Account Lockout

P3No rate limiting or lockout on login — brute force possible

Insecure "Remember Me" Token

P3Persistent login token is predictable or not properly invalidated

Session Fixation

P2Session ID not regenerated after authentication

Insecure Session Expiration

P4Sessions never expire or persist too long after logout

Session Token in URL

P3Session identifiers transmitted in URL — logged by servers/proxies

Predictable Token / Session ID

P2Sequentially generated or low-entropy session tokens

Password Reset Flaws

Weak tokens · No expiry · Host header injection

P2Password reset tokens are predictable, reusable, or leak via Host header

Missing Multi-Factor Authentication

P4No MFA available for high-value accounts (admin, financial)

OAuth Misconfiguration

open redirect · state missing · token leakage

P2OAuth flow allows token interception or authorization code theft

Concurrent Session Allowed

P4No restriction on simultaneous sessions from different locations

Credential Stuffing Possible

P3No CAPTCHA or rate limiting prevents automated credential testing

Token Not Invalidated on Logout

P3JWT or session token remains valid after logout
Broken Access ControlP1
VulnerabilityPriorityDescription

Horizontal Privilege Escalation

IDOR

P2Access/modify another user's data at the same privilege level

Vertical Privilege Escalation

P1Regular user can access admin or higher-privileged functionality

Function-Level Access Control

P2Direct URL access to restricted functions (admin endpoints, reports)

Mass Assignment

P2Binding user-supplied data to model attributes including privileged fields

Exposed Internal API

P2Internal/admin API endpoints accessible without authentication

Metadata Manipulation

P3Manipulate access tokens, cookies, or form fields to gain unauthorized access

Missing Authorization on API

P2API endpoints lack proper authorization checks

Server-Side Request Forgery

P1Force server to make requests to internal/external resources
Injection FlawsP1
VulnerabilityPriorityDescription

SQL Injection

P1Inject SQL commands into database queries — auth bypass, data dump, OS command

Blind SQL Injection

P2SQLi without direct output — inferred via boolean/time delays

NoSQL Injection

P2Inject operators in MongoDB/CouchDB queries

OS Command Injection

P1Execute arbitrary OS commands on the server

LDAP Injection

P2Manipulate LDAP queries to bypass authentication or exfiltrate data

XPath Injection

P2Inject XPath expressions to manipulate XML data retrieval

Server-Side Template Injection (SSTI)

P1Inject template syntax to achieve RCE (Jinja2, Twig, Freemarker, etc.)

CSV Injection / Formula Injection

P3Inject formulas in exported CSV files to execute on victim's spreadsheet

HTTP Header Injection

P3Inject arbitrary headers via CRLF sequences

XML Injection

P2Inject malicious XML data — leading to XXE or data manipulation

Code Injection

P1Inject and execute application-language code (eval(), exec(), etc.)

GraphQL Injection

P2Manipulate GraphQL queries to bypass authorization or leak data
Cross-Site Scripting (XSS)P2
VulnerabilityPriorityDescription

Stored XSS

High-impact page (admin, profile, global)

P1Persistent XSS affecting large user populations or admin interfaces

Stored XSS

Low-traffic or limited-scope page

P2Persistent XSS with limited reach or requiring specific conditions

Reflected XSS

Requiring user interaction

P3Non-persistent XSS triggered by crafted URL requiring victim to click

DOM-Based XSS

P3XSS via client-side DOM manipulation without server reflection

Blind XSS

P2XSS payload stored and executed in admin/internal panels not directly visible

Self-XSS

P5XSS only exploitable by the victim themselves — no meaningful impact

XSS via File Upload

P2Malicious SVG, HTML, or other file executing JavaScript when viewed

XSS via postMessage

P2Injecting JavaScript via misconfigured postMessage handler

Content Security Policy Bypass

P3Bypassing CSP to execute JavaScript despite protection headers
Cryptographic FailuresP2
VulnerabilityPriorityDescription

Weak Cryptographic Algorithm

MD5 · SHA1 · DES · RC4

P3Use of deprecated algorithms for sensitive data or authentication

Hardcoded Cryptographic Key

P2Encryption keys embedded in source code or configuration files

Cleartext Transmission of Credentials

P2Passwords or tokens sent over unencrypted HTTP connections

Weak SSL/TLS Configuration

SSLv2 · SSLv3 · TLS 1.0 · Weak ciphers

P3Deprecated TLS versions or weak cipher suites accepted by server

Insufficient Key Length

P3RSA keys below 2048-bit or ECC curves below 256-bit

Padding Oracle

P2Exploitable padding oracle in CBC-mode decryption — auth bypass/data exposure

Mixed Content

P4HTTPS page loading resources over HTTP

JWT Algorithm Confusion

RS256 → HS256 / none algorithm

P1Sign JWT with public key as HMAC secret or use "none" algorithm to bypass auth

Sensitive Data Stored Unencrypted

P2Passwords, PII, or financial data stored in plaintext in database
Sensitive Data ExposureP2
VulnerabilityPriorityDescription

PII Exposure

Names · Emails · Phone · Address

P2Personally identifiable information exposed without authorization

Financial Data Exposure

Card numbers · Bank accounts

P1Payment card data or financial information accessible to unauthorized parties

API Keys / Credentials in Source

P2API keys, AWS credentials, or tokens exposed in JS files or HTML source

Internal Path Disclosure

P5Internal server paths exposed in error messages

Private Key Exposure

P1SSL/TLS private keys or SSH private keys publicly accessible

User Enumeration

P4Login/registration responses reveal whether a username/email exists

Token Exposure in Logs

P3Access tokens or passwords recorded in server logs

Health/Medical Data Exposure

P1Protected health information (PHI) accessible without authorization

GitHub/Repository Secret Leak

P2Credentials or secrets committed to public/private repositories

EXIF Data / Metadata Exposure

P5Document or image metadata revealing internal information (GPS, usernames, paths)
Business Logic ErrorsP2
VulnerabilityPriorityDescription

Price Manipulation

P2Modify product price or discount in client-side request to buy items for free/low price

Race Condition — Double Spend

P2Use same coupon/resource multiple times via parallel requests

Workflow Bypass

P2Skip required steps in multi-step processes (checkout, verification)

Coupon / Voucher Abuse

P3Reuse single-use coupons, stack unlimited discounts, or bypass coupon validation

Account Takeover via Logic Flaw

P1Password reset or account linking logic allows taking over other accounts

Negative Value Manipulation

P2Input negative quantity or amount to receive credit or reverse a payment

Insecure Rate Limiting

P3No rate limiting on OTP verification, API, or actions — brute force possible

Email Verification Bypass

P3Verify email without access to the email account

2FA Bypass

P2Bypass two-factor authentication via response manipulation or OTP reuse
Mobile Application VulnerabilitiesP2
VulnerabilityPriorityDescription

Insecure Data Storage

Cleartext credentials in SQLite · SharedPreferences · plist

P2Sensitive data stored unencrypted on device storage

Hardcoded Credentials in APK/IPA

P2API keys or credentials embedded in compiled application binary

Insecure Communication

P2App sends data over HTTP or accepts invalid TLS certificates

Insufficient Transport Layer Security

SSL pinning bypass

P3SSL/TLS not pinned — MITM possible without specific bypass techniques

Exported Activities / Intents

P2Android activity or content provider exported without proper permissions

Clipboard Data Leakage

P4Sensitive data (passwords) accessible via device clipboard

WebView Vulnerabilities

JavaScript bridge · file:// access

P2WebView allows JavaScript execution, file protocol access, or addJavascriptInterface abuse

Improper Session Handling

P3Session not invalidated on logout or after app backgrounding

Reverse Engineering / Obfuscation Missing

P5App binary lacks obfuscation — internal logic easily reverse-engineered
Unclassified / Other Notable VulnerabilitiesP3
VulnerabilityPriorityDescription

Clickjacking

P4UI redressing via iframe to trick users into unintended clicks

DNS Rebinding

P2Exploit DNS TTL to bypass SOP and access internal services from external origin

Insecure Deserialization

P1Deserializing untrusted data leading to RCE or privilege escalation

Using Components with Known Vulns

P3Outdated libraries with known CVEs — severity depends on actual exploitability

Server-Side Template Injection

P1Template engine processes user input enabling code execution

Prototype Pollution

P2Pollute JavaScript object prototype to change behavior, sometimes leading to RCE

HTTP Request Smuggling

P1Desync front-end/back-end HTTP parsing to bypass security controls or poison cache

Cache Poisoning

P2Poison web cache to serve malicious content to other users

Web Cache Deception

P2Trick cache into storing authenticated response accessible by attacker

Denial of Service (DoS)

P3Application-layer DoS via ReDoS, resource exhaustion, or algorithmic complexity

Subdomain Takeover

P2Claim dangling CNAME pointing to unclaimed external service

OAuth Token Theft via Open Redirect

P2Redirect OAuth callback to attacker-controlled domain to steal authorization code

Parameter Pollution (HPP)

P3Supply multiple values for same parameter to bypass filters or cause unexpected behavior

Dependency Confusion

P2Publish malicious package with same name as internal package to public registries

SMTP Header Injection

P3Inject SMTP headers via user-controllable input in email functionality

Insecure Direct Object Reference (IDOR)

P2Directly reference objects (IDs, filenames) accessible without authorization

CORS — Arbitrary Origin Trusted

P2API trusts arbitrary Origin headers — allows cross-origin data theft

Exposed .env / Config Files

P2.env, config.php, database.yml, or similar files accessible publicly

Broken Link Hijacking

P3Register expired domains or claim unclaimed usernames referenced in app

See how this turns into a report.