应用漏洞利用路径证据审计
沿攻击者输入到危险操作的完整路径核验应用漏洞,输出区分已证实风险与加固项的报告。
完整提示词
I want you to perform a maximally deep, systematic, evidence-first, and production-oriented analysis of the application focused on classic web/application vulnerability classes, with a special focus on real attack paths, exploitable input-to-sink flows, and the distinction between a confirmed vulnerability and a mere hardening deficiency.
Main goal:
> Find concrete OWASP-like vulnerabilities that can actually be exploited through the application, including injection, XSS, SSRF, CSRF, unsafe deserialization, path traversal, file-related issues, open redirect, security misconfiguration, dangerous parser behavior, and other input-driven vulnerabilities, without generic enumeration of best practices.
This is not:
- reciting the OWASP Top 10 list
- automatically declaring every raw query a SQL injection
- automatically declaring every `innerHTML` usage XSS
- automatically declaring every URL fetch SSRF
- automatically declaring the absence of CSP/HSTS a critical vulnerability
- automatically labeling all dependency CVEs as exploitable
- merely a static grep audit
- merely a penetration test checklist
The focus is on the model:
```text
attacker-controlled input
↓
transformations / validation
↓
trust boundary
↓
dangerous sink
↓
security-relevant behavior
↓
impact
```
Priority:
**remote code execution > injection with data/control impact > SSRF to privileged targets > stored/reflected XSS > CSRF on sensitive actions > path/file access > unsafe deserialization > open redirect/security misconfiguration > hardening**
It is better to identify 5 real exploit chains than to write 100 generic OWASP recommendations.
---
# 1. ESTABLISH STACK AND ATTACK SURFACE
Before documenting findings, establish:
- backend language
- framework
- frontend framework
- templating system
- ORM/query builder
- HTTP client
- XML/YAML parsers
- file processing libraries
- archive handling
- template engines
- headless browser
- PDF generator
- command execution utilities
- object storage
- deployment/proxy
---
# 2. INPUT INVENTORY
Inventory all attacker-controlled input sources:
```text
path params
query params
headers
cookies
JSON body
multipart
file content
file names
WebSocket messages
GraphQL args
webhook payloads
queue payloads
database content originally supplied by users
third-party data
```
---
# 3. SECOND-ORDER INPUT
Do not focus solely on the currently arriving request.
Stored attacker data can reach a sink later.
Example:
```text
user saves payload
↓
admin opens record later
↓
payload reaches HTML sink
```
Stored XSS.
---
# 4. SINK INVENTORY
Search the repository for potentially dangerous sinks:
- raw SQL
- shell/command execution
- template evaluation
- HTML insertion
- server-side HTTP fetch
- filesystem access
- archive extraction
- XML parsing
- YAML/native deserialization
- dynamic code execution
- redirects
- response headers
- object merge
---
# 5. SOURCE-TO-SINK TRACE
Every finding must trace the complete path:
```text
SOURCE
↓
VALIDATION
↓
TRANSFORMATION
↓
SINK
↓
IMPACT
```
If the path is not provable:
do not label as a confirmed vulnerability.
---
# 6. SQL INJECTION
Find:
- raw query strings
- dynamic SQL
- string concatenation
- interpolation
- raw filters
- dynamic `ORDER BY`
- dynamic table/column names
---
# 7. PARAMETERIZED SQL
If values pass through parameter binding:
do not report SQLi merely because the query is raw.
---
# 8. STRING CONCATENATION
High-signal:
```text
"SELECT * FROM users WHERE id = " + userInput
```
---
# 9. TEMPLATE LITERAL SQL
Example:
```text
`SELECT * FROM users WHERE email = '${email}'`
```
if `email` is not safely parameterized.
---
# 10. DYNAMIC `ORDER BY`
Many drivers do not parameterize identifiers.
If the user selects sort column/order:
use a whitelist.
---
# 11. TABLE NAME INJECTION
Dynamic tenant table/schema names are particularly risky if derived from requests.
---
# 12. ORM ESCAPE
Verify framework semantics.
Do not assume an ORM is automatically safe if it uses:
```text
raw()
literal()
whereRaw()
executeRaw()
```
---
# 13. N+1 IS NOT SQLI
Do not confuse performance findings with injection findings.
---
# 14. NOSQL INJECTION
If the stack uses NoSQL:
verify whether an attacker can inject query operators.
---
# 15. OBJECT BODY DIRECTLY IN QUERY
High-signal:
```text
collection.find(req.body)
```
if arbitrary operators pass through.
---
# 16. MONGO-LIKE OPERATORS
Test relevant operators:
```text
$ne
$gt
$regex
$where
```
only if the driver/model permits.
---
# 17. LDAP INJECTION
Only if the application constructs LDAP filters.
If not:
**NOT APPLICABLE**
---
# 18. COMMAND INJECTION
Search for:
```text
exec
system
shell
spawn with shell
popen
ProcessBuilder string
Runtime.exec
```
according to the language.
---
# 19. ARGUMENT ARRAY
APIs that pass command + arguments without a shell are generally safer.
Still verify tool semantics.
---
# 20. `shell=true`
High-signal when user input enters the command.
---
# 21. COMMAND CONCATENATION
Example:
```text
exec("convert " + filename)
```
---
# 22. SHELL METACHARACTERS
Test only in a safe test environment.
---
# 23. FILENAME AS COMMAND ARGUMENT
Even without a shell, some CLI tools treat arguments starting with `-` as options.
Consider option injection where relevant.
---
# 24. OPTION TERMINATOR
`--` can be relevant for certain CLI tools.
Do not recommend generically if the tool lacks that semantics.
---
# 25. CODE INJECTION
Search for:
```text
eval
Function()
exec(dynamic code)
dynamic language runtime
```
---
# 26. `eval` IS NOT AUTOMATICALLY EXPLOITABLE
Attacker control over evaluated content must exist.
---
# 27. TEMPLATE INJECTION
If user content becomes template source:
check for SSTI.
---
# 28. TEMPLATE DATA VS TEMPLATE SOURCE
This is a critical distinction.
Safe:
```text
render("template", { name: userInput })
```
Potentially dangerous:
```text
renderString(userInput)
```
depending on the engine.
---
# 29. SSTI
Search for the ability to execute expressions.
---
# 30. TEMPLATE SANDBOX
If the engine includes a sandbox:
verify actual configuration/version.
---
# 31. XSS INVENTORY
Classify:
```text
STORED
REFLECTED
DOM
MUTATION
MARKDOWN/RICH TEXT
```
---
# 32. FRAMEWORK ESCAPING
React/Vue/Svelte/templating systems often escape text interpolation.
Do not report XSS if the framework already treats input as text.
---
# 33. UNSAFE HTML SINK
Search for:
```text
innerHTML
dangerouslySetInnerHTML
v-html
{@html}
HTML.Raw
safe filter
```
---
# 34. SANITIZATION
If an unsafe HTML sink exists:
inspect the sanitizer.
---
# 35. SANITIZER BEFORE AND AFTER
If a sanitized string subsequently undergoes a transformation that reintroduces markup:
check for mutation issues.
---
# 36. STORED XSS
Specifically check:
- profiles
- comments
- support tickets
- admin dashboards
- product names
- user-generated HTML
---
# 37. ADMIN XSS
Stored XSS affecting administrators can be far more severe than simple self-XSS.
---
# 38. SELF-XSS
Do not report as a serious vulnerability if the attacker must manually force themselves to execute their own payload without a realistic social/privilege path.
---
# 39. ATTRIBUTE CONTEXT
Escaping for HTML text is not necessarily sufficient for:
- attributes
- JS strings
- URLs
- CSS
---
# 40. URL SCHEME
Attacker-controlled links:
```text
javascript:
data:
```
can be problematic if the application permits clickable unsafe URLs.
---
# 41. MARKDOWN
Inspect:
- raw HTML
- link schemes
- embedded media
- sanitizer
---
# 42. SVG
User-supplied SVG can contain active content in specific contexts.
---
# 43. FILE-SERVED XSS
Uploaded HTML/SVG served inline from the application origin can become stored XSS.
---
# 44. DOM XSS SOURCE
Search for:
- location.search
- location.hash
- postMessage
- localStorage
- server data
flowing into unsafe DOM sinks.
---
# 45. `postMessage`
If cross-origin messages influence DOM/actions:
verify `origin`.
---
# 46. DOMPURIFY / SANITIZER CONFIG
Verify actual options, hooks, and allowed URI schemes.
---
# 47. CSP
CSP can mitigate XSS impact.
However, absence of CSP is not equivalent to XSS.
---
# 48. TRUSTED TYPES
Hardening for specific frontends.
P4 unless current architecture specifically mandates it.
---
# 49. CSRF
Apply only when browsers automatically attach credentials:
- cookies
- client certificates
- ambient auth
---
# 50. BEARER HEADER
If an SPA manually attaches a bearer token from JS:
the classic CSRF model differs.
---
# 51. STATE-CHANGING REQUESTS
Inventory:
- POST
- PUT
- PATCH
- DELETE
- state-mutating GET
---
# 52. GET MUTATION
A GET request causing side effects elevates CSRF/preload/crawler risk.
---
# 53. CSRF TOKEN
If present:
verify:
- generation
- validation
- session binding
---
# 54. SAME-SITE COOKIE
Evaluate:
- `Strict`
- `Lax`
- `None`
against cross-site requirements.
---
# 55. `SameSite=None`
Must be paired with Secure in modern browsers.
---
# 56. ORIGIN CHECK
Can provide strong secondary defense for state-changing requests.
---
# 57. REFERER
Fallback, but privacy/proxy settings can affect availability.
---
# 58. FORM POST
`application/x-www-form-urlencoded` and `multipart/form-data` can be submitted cross-site from HTML forms.
---
# 59. JSON-ONLY API
Can complicate certain CSRF paths due to preflight/content-type semantics, but do not rely on it as sole defense without understanding CORS/browser behavior.
---
# 60. LOGIN CSRF
A distinct vulnerability class.
---
# 61. ACCOUNT LINK CSRF
High-risk.
---
# 62. CSRF IMPACT
Severity mirrors the action:
- logout
- profile update
- password/email change
- payout
- API key creation
---
# 63. CORS
Audit as a browser cross-origin policy, not as backend authorization.
---
# 64. ORIGIN REFLECTION
Pattern:
```text
Access-Control-Allow-Origin: <request Origin>
Access-Control-Allow-Credentials: true
```
without an allowlist is high-signal.
---
# 65. CORS `*`
With credentials is not a valid standard combination for browser credentialed requests, but verify config/library behavior.
---
# 66. CORS PUBLIC API
Wildcards can be entirely legitimate for public APIs.
---
# 67. NULL ORIGIN
If an allowlist permits `null`, verify whether a real exploit path exists.
---
# 68. SUBDOMAIN REGEX
Patterns like:
```text
/example\.com/
```
can accept:
```text
evil-example.com
```
---
# 69. SSRF
Inventory every server-side URL fetch.
Examples:
- webhook tests
- image import
- URL preview
- PDF from URL
- crawlers
- callbacks
- remote file import
---
# 70. SSRF SOURCE
Who can control:
- full URL
- host
- path
- redirect
- DNS
---
# 71. SSRF SCHEMES
Verify supported schemes:
```text
http
https
file
ftp
gopher
```
according to library capabilities.
---
# 72. ALLOW `HTTP/HTTPS` ONLY
Can reduce attack surface, but is insufficient defense against internal HTTP targets.
---
# 73. LOCALHOST
Block by design:
- `127.0.0.1`
- `::1`
- localhost names
if external-only fetching is intended.
---
# 74. PRIVATE NETWORK
Relevant ranges:
- RFC1918
- link-local
- internal DNS
---
# 75. CLOUD METADATA
Evaluate specific cloud/platform environments.
---
# 76. REDIRECT SSRF
Initial URL can be public, followed by a redirect to an internal IP.
---
# 77. DNS REBIND / RE-RESOLUTION
If custom defense validates DNS before connecting:
verify actual HTTP library resolution behavior.
---
# 78. PROXY
Outbound proxies can alter the SSRF threat model.
---
# 79. CREDENTIALS ON SERVER FETCH
HTTP client may automatically attach:
- proxy credentials
- cloud identity
- internal cookies
Inspect carefully.
---
# 80. RESPONSE EXFILTRATION
SSRF impact is greater if the attacker receives the response body.
---
# 81. BLIND SSRF
Even without a response body, it can:
- trigger internal actions
- scan ports
- reach metadata services
---
# 82. SSRF TIMING
Do not assert internal port scanning based solely on theoretical timing without reproducible evidence.
---
# 83. PATH TRAVERSAL
Inventory user-controlled filesystem paths.
---
# 84. FILENAME
Test:
```text
../
..encoded variants
absolute paths
```
according to OS/framework.
---
# 85. NORMALIZATION
Decode and normalization ordering is critical.
---
# 86. PREFIX CHECK
Naive checks like:
```text
resolvedPath.startsWith(basePath)
```
can be flawed without proper path separator/canonical semantics.
---
# 87. WINDOWS
If the app runs on Windows:
consider:
- drive letters
- UNC paths
- alternative separators
---
# 88. NULL BYTE
Relevance depends on runtime/library version.
Do not assume universal modern exploitability.
---
# 89. SYMLINK
Filesystem containment can fail via symlinks.
---
# 90. TOCTOU
Validating path followed by attacker swapping a symlink before use.
Relevant only if attacker controls the filesystem race surface.
---
# 91. ZIP SLIP
Archive entries containing:
```text
../../file
```
---
# 92. ARCHIVE ABSOLUTE PATH
Including absolute path entries.
---
# 93. ZIP BOMB
Small compressed size expanding to massive uncompressed volume.
---
# 94. NESTED ARCHIVE
Recursive extraction can amplify resource consumption.
---
# 95. FILE UPLOAD
Audit:
- filename
- extension
- MIME
- content
- size
- storage
- serving
- processing
---
# 96. MIME SPOOFING
Client-supplied MIME types provide zero trust.
---
# 97. EXTENSION SPOOFING
Same applies to extensions.
---
# 98. POLYGLOT FILES
Magic bytes do not offer complete protection when format/context supports active content.
---
# 99. SERVER EXECUTION
Worst-case scenario:
uploaded file lands in a web-executable directory.
---
# 100. STATIC SERVING
User files must not become server-side templates or scripts merely due to file extension.
---
# 101. USER-CONTROLLED FILENAME
Do not permit overwriting critical server files.
---
# 102. OBJECT STORAGE KEY
Path traversal semantics may differ in object storage, but key authorization and prefixes must be audited.
---
# 103. DOWNLOAD PATH
User-controlled local filenames can enable arbitrary file reads.
---
# 104. CONTENT-DISPOSITION
Inline serving increases active content risks.
---
# 105. FILE PARSER
Uploads may be forwarded to:
- ImageMagick
- FFmpeg
- PDF parser
- office parser
- antivirus
Dependency-specific exploits belong in a supply-chain audit, but note the attack surface.
---
# 106. XML / XXE
Only if an XML parser is present.
---
# 107. DTD
Verify external entity behavior.
---
# 108. FILE URI ENTITY
Potential local file reading.
---
# 109. HTTP ENTITY
Potential SSRF.
---
# 110. BILLION LAUGHS
Entity expansion DoS, depending on parser configuration.
---
# 111. SVG XML
SVG processing can implicitly introduce an XML parser attack surface.
---
# 112. YAML
Search for:
- `load`
- `unsafe_load`
- tags/object constructors
according to library.
---
# 113. YAML DESERIALIZATION
User-controlled YAML paired with an unsafe object loader can lead to RCE in specific runtimes.
---
# 114. PYTHON PICKLE
Untrusted pickle deserialization equals high-risk code execution.
---
# 115. JAVA NATIVE SERIALIZATION
Untrusted object streams can form gadget attack surfaces.
---
# 116. PHP UNSERIALIZE
Same risk applies.
---
# 117. .NET DESERIALIZATION
Legacy unsafe serializers where present.
---
# 118. JSON
Standard JSON parsing is not equivalent to unsafe object deserialization.
---
# 119. DESERIALIZATION TRUST
Key question:
> Can the attacker control serialized bytes or the object graph?
---
# 120. PROTOTYPE POLLUTION
For JS/Node frontend/backend:
search for unsafe recursive merge or path setters.
---
# 121. `__proto__`
Test only where the library/version is not already patched.
---
# 122. CONSTRUCTOR PROTOTYPE
And other paths according to actual merge library semantics.
---
# 123. POLLUTION IMPACT
Prototype pollution in isolation can be low/medium.
Search for gadgets:
- auth bypass
- RCE
- config manipulation
- XSS
---
# 124. HEADER INJECTION
User-controlled values reflected into response headers.
---
# 125. CRLF
Modern frameworks commonly reject CR/LF characters.
Verify actual runtime behavior.
---
# 126. EMAIL HEADER INJECTION
If the application constructs raw email headers from user input.
---
# 127. LOG INJECTION
Newlines/control characters in logs can hinder auditing.
Typically P3/P4 unless parser/SIEM workflows yield concrete security impact.
---
# 128. OPEN REDIRECT
Search for:
```text
next
redirect
returnUrl
callback
continue
```
---
# 129. ABSOLUTE URL
Attacker-controlled domains.
---
# 130. PROTOCOL-RELATIVE
```text
//evil.example
```
---
# 131. BACKSLASH PARSING
Browser and framework differences can impact parsing.
Test actual redirect implementation.
---
# 132. PREFIX ALLOWLIST
Naive validation like:
```text
url.startsWith("https://example.com")
```
can accept:
```text
https://example.com.evil.test
```
---
# 133. OPEN REDIRECT SEVERITY
Usually not P1 in isolation.
Impact escalates if chained with:
- OAuth flows
- password resets
- trusted-link phishing
- token leakage
---
# 134. HOST HEADER INJECTION
If the backend relies on `Host` headers for security-sensitive URL generation.
---
# 135. RESET LINK
Especially critical.
---
# 136. ABSOLUTE URL GENERATION
Use trusted configured base URLs where required.
---
# 137. CACHE POISONING
If reverse proxies/CDNs exist:
check user-controlled headers/queries that affect responses but are absent from cache keys.
---
# 138. CACHE DECEPTION
Sensitive personalized responses cached as public resources.
---
# 139. AUTHORIZED RESPONSE SHARED CACHE
P1 if one user receives another user's data.
---
# 140. `Vary`
Verify relevant caching headers.
---
# 141. WEB CACHE KEY
Do not assert theoretical cache attacks without evidence that a caching layer actually exists.
---
# 142. HTTP REQUEST SMUGGLING
Only if custom reverse proxy chains and parser mismatches present a realistic exploit surface.
Do not report generically.
---
# 143. FRONTEND REQUEST SMUGGLING
Irrelevant in most application-level repo audits without infrastructure evidence.
---
# 144. SECURITY MISCONFIGURATION
Search for concrete misconfigurations with real attack impact.
---
# 145. DEBUG MODE
Production debug toolbars, stack traces, or admin consoles.
---
# 146. DEFAULT CREDENTIALS
Critical.
---
# 147. DIRECTORY LISTING
Severity scaled to exposed data.
---
# 148. PUBLIC BUCKET
When private files become publicly accessible.
---
# 149. DATABASE PORT PUBLIC
If infrastructure config demonstrates public internet exposure.
---
# 150. ADMIN CONSOLE PUBLIC
High-risk.
---
# 151. TEST ENDPOINT
Endpoints capable of:
- dumping databases
- creating users
- issuing tokens
- resetting system state
---
# 152. SAMPLE DATA ENDPOINT
Do not assume sample endpoints are harmless.
---
# 153. ENV EXPOSURE
Routes or static configurations returning `.env`, configs, or source files.
---
# 154. SOURCE MAP
Can assist attackers, but P3/P4 unless exposing secrets or source-dependent exploit chains.
---
# 155. ERROR STACK
Internal paths, library versions, and info disclosures.
---
# 156. SERVER VERSION
Banner disclosure is low priority without an actionable exploit.
---
# 157. BACKUP FILES
Search for:
```text
.env.bak
config.old
database.sql
.zip
.tar
```
if deployment or static configurations could expose them.
---
# 158. `.git`
Public `.git` directories exposing source code or secrets.
---
# 159. CREDENTIALS IN STATIC FILE
High severity if actual secrets are present.
---
# 160. DEFAULT CORS
Do not equate broad CORS with server-side data exposure in the absence of credentials/auth contexts.
---
# 161. SECURITY HEADERS
Review:
- CSP
- frame-ancestors
- X-Content-Type-Options
- Referrer-Policy
Rank as hardening unless tied to a concrete exploit chain.
---
# 162. HSTS
Hardening/transport security according to deployment architecture.
---
# 163. CLICKJACKING
If sensitive actions can be framed:
verify `frame-ancestors` or equivalents.
---
# 164. CLICKJACKING IMPACT
Do not elevate severity without a sensitive clickable action.
---
# 165. MIME SNIFFING
Relevant specifically for user-uploaded files.
---
# 166. SENSITIVE DATA IN URL
Query strings can be recorded in:
- logs
- browser history
- analytics
- referrer headers
---
# 167. GET PASSWORD/SECRET
High-signal.
---
# 168. PII IN PATH
Can be a privacy or logging issue, not necessarily a security vulnerability.
---
# 169. RESPONSE SPLITTING
Modern frameworks typically validate headers.
Verify actual behavior.
---
# 170. EMAIL TEMPLATE HTML
User data in HTML emails may require escaping, but email client XSS models differ.
Do not transfer browser XSS assumptions automatically.
---
# 171. PDF/HTML GENERATION
If the server generates PDFs from attacker-controlled HTML:
analyze:
- local files
- SSRF
- scripts
- internal network resources
---
# 172. HEADLESS BROWSER
Can possess broader internal network access than standard user browsers.
---
# 173. PLAYWRIGHT/PUPPETEER
Attacker-controlled URLs or HTML represent high-value review surfaces.
---
# 174. BROWSER SANDBOX FLAGS
`--no-sandbox` represents significant defense reduction for untrusted rendering workloads.
However, it does not independently equate to RCE.
---
# 175. SCREENSHOT SERVICE
SSRF plus browser attack surface.
---
# 176. URL PREVIEW
SSRF, XSS in extracted metadata, and parser vulnerabilities.
---
# 177. OG METADATA
Remote attacker-controlled HTML parsed server-side.
---
# 178. VALIDATION ORDER
Input validated prior to decoding can yield dangerous characters after subsequent decoding.
---
# 179. DOUBLE ENCODING
Relevant for:
- traversal
- XSS
- redirects
if multiple decoding layers exist.
---
# 180. CANONICALIZATION
Security decisions must be performed on the identical canonical representation consumed by the sink.
---
# 181. UNICODE NORMALIZATION
Can be relevant for path and identifier allowlists.
Do not report without concrete mismatch semantics.
---
# 182. REGEX VALIDATION
Naive regex allowlists can be bypassed due to missing start/end anchors.
---
# 183. REGEX DOS
Attacker-controlled input paired with catastrophic backtracking regexes.
---
# 184. RE-DOS
Check:
- nested quantifiers
- ambiguous alternatives
- unbounded input
against the actual regex engine.
---
# 185. VALIDATION DOS
Massive JSON payloads or complex schema validations consuming excessive CPU.
---
# 186. JSON DEPTH
Deep nesting triggering parser or recursive algorithm failures.
---
# 187. GRAPHQL DOS
If present:
- depth
- aliases
- fragments
- complexity
- batching
---
# 188. REST BULK DOS
A single request containing millions of items.
---
# 189. ZIP/PDF/IMAGE BOMBS
Resource exhaustion via parsing routines.
---
# 190. ALGORITHM COMPLEXITY
Users selecting input triggering:
```text
O(n²)
O(2^n)
```
on large N.
---
# 191. DoS SEVERITY
Do not label every expensive request a security vulnerability if rate, size, and cost boundaries make exploitation impractical.
---
# 192. WEBSOCKET
If present:
verify:
- auth during handshake
- auth on message-level operations
- origin checks where relevant
- message size limits
- rate limits
---
# 193. SOCKET MESSAGE INJECTION
Server-side message payloads can enter SQL/HTML/command sinks just like HTTP input.
---
# 194. SSE
Smaller injection surface, but query/auth inputs and connection abuse remain relevant.
---
# 195. GRAPHQL INTROSPECTION
Not a vulnerability in itself.
---
# 196. GraphQL ERROR DETAILS
Stack traces and schema internals leaking to clients.
---
# 197. GraphQL AUTH
Detailed authorization belongs in a dedicated audit, but record resolver-level bypasses.
---
# 198. MASS ASSIGNMENT
OWASP-like broken access control pattern.
If request bodies map directly to ORM/entity updates:
inspect privileged fields.
---
# 199. EXCESSIVE DATA EXPOSURE
Serializers returning:
- password hashes
- secrets
- internal flags
- tokens
---
# 200. PROPERTY FILTER
Inspect DTOs and serializers.
---
# 201. PRODUCTION BUILD
Development-only source and debug behaviors might not exist in release builds.
Verify actual deployment configs.
---
# 202. FRAMEWORK DEFAULT
Do not claim vulnerabilities without verifying actual framework defaults and versions.
---
# 203. DEPENDENCY CVE
Do not turn this audit into a generic dependency scanner.
However, if an active attack path directly touches a known vulnerable parser/library function:
record it and refer to detailed supply-chain auditing.
---
# 204. FINDING FORMAT
Every substantive finding must include:
```text
ID:
Severity:
Category:
Confidence:
Status:
Evidence tier:
Attacker:
Authentication required:
Entry point:
Source:
Validation:
Transformations:
Sink:
File/Class:
Function:
Relevant code/config:
Vulnerability:
Exploit Preconditions:
Exploit Payload Shape:
Do not include destructive payload unless explicitly authorized.
Execution Flow:
T0:
T1:
T2:
T3:
Expected security behavior:
Actual behavior:
Confidentiality impact:
Integrity impact:
Availability impact:
Privilege impact:
Blast radius:
Root cause:
Recommended remediation:
Regression/security test:
Production verification:
Complexity:
XS / S / M / L / XL
```
---
# 205. SEVERITY
Use:
## P0 - CRITICAL
- unauthenticated remote code execution
- arbitrary sensitive server file read/write with catastrophic impact
- injection yielding full production takeover
- SSRF leading directly to critical credentials or admin takeover
## P1 - HIGH
- exploitable SQL/NoSQL/command injection with substantial data impact
- stored XSS against privileged users with realistic account/control impact
- high-impact SSRF targeting sensitive internal services
- unsafe deserialization with code execution path
- arbitrary private file access
## P2 - MEDIUM
- meaningful XSS/CSRF/path traversal/open redirect chain
- constrained SSRF
- limited injection
- exploitable resource exhaustion
## P3 - LOW
- limited information disclosure
- constrained redirect
- low-impact clickjacking
- minor parser or security misconfiguration
## P4 - HARDENING
- missing defense-in-depth without confirmed exploit paths
---
# 206. CONFIDENCE
Use:
```text
HIGH
MEDIUM
LOW
```
---
# 207. STATUS
Use:
```text
CONFIRMED
LIKELY
THEORETICAL
NOT VERIFIED
```
---
# 208. EVIDENCE TIER
Use:
```text
A - reproduced safely
B - complete executable source-to-sink path
C - strong static/config evidence
D - partial/inferred
E - theoretical
```
---
# 209. VULNERABILITY CATEGORY
Use:
```text
SQL INJECTION
NOSQL INJECTION
COMMAND INJECTION
CODE INJECTION
SSTI
XSS
CSRF
CORS
SSRF
PATH TRAVERSAL
ZIP SLIP
FILE UPLOAD
XXE
UNSAFE DESERIALIZATION
PROTOTYPE POLLUTION
OPEN REDIRECT
HOST HEADER
CACHE
REDOS
RESOURCE EXHAUSTION
SECURITY MISCONFIGURATION
DATA EXPOSURE
```
---
# 210. EXPLOIT CHAIN
If a single weakness is insufficient alone:
connect multiple findings only when the chain is genuinely coherent.
Example:
```text
open redirect
+
OAuth callback
+
token in URL
=
credential theft path
```
Do not sensationalize theoretical chains.
---
# 211. FALSE-POSITIVE PREVENTION
Before reporting P0/P1/P2 findings, verify:
1. source is attacker-controlled
2. input genuinely reaches sink
3. sanitizer/parameterization is ineffective
4. runtime/framework semantics
5. deployment exposure
6. auth/authorization preconditions
7. output/rendering context
8. library version
9. test/reproduction where safe
10. realistic impact
---
# 212. RAW SQL IS NOT AUTOMATICALLY SQLI
Parameterized raw SQL can be completely secure.
---
# 213. `dangerouslySetInnerHTML` IS NOT AUTOMATICALLY XSS
If content originates from a hardcoded or sanitized trusted source:
it is not a vulnerability.
---
# 214. SERVER-SIDE FETCH IS NOT AUTOMATICALLY SSRF
If destination is fixed/allowlisted and attacker cannot control host:
it is not SSRF.
---
# 215. XML PARSER IS NOT AUTOMATICALLY XXE
Verify external entity behavior.
---
# 216. YAML IS NOT AUTOMATICALLY RCE
Safe loaders alter the threat model.
---
# 217. FILE UPLOAD IS NOT AUTOMATICALLY RCE
Storage, serving, and processing contexts decide severity.
---
# 218. OPEN REDIRECT IS NOT AUTOMATICALLY HIGH
Severity scaled to exploit chain.
---
# 219. MISSING CSP IS NOT XSS
P4 hardening unless an XSS path exists.
---
# 220. MISSING HSTS IS NOT P1
Transport hardening according to deployment model.
---
# 221. VERSION DISCLOSURE IS NOT AUTOMATICALLY A VULNERABILITY
Low value without an exploit chain.
---
# 222. DO NOT MODIFY CODE
During the audit:
- do not execute destructive exploits
- do not modify WAF rules
- do not rotate secrets
- do not delete files
- do not execute shell payloads
- do not access third-party systems
Use controlled test environments and non-destructive verification.
---
# 223. OUTPUT - OWASP_VULNERABILITY_AUDIT.md
Structure the final report as follows:
## 1. Executive Summary
- stack
- input surfaces
- dangerous sinks
- top confirmed exploit paths
- evidence quality
## 2. Source / Sink Map
## 3. SQL Injection Audit
## 4. NoSQL / Query Injection Audit
## 5. Command / Code Injection Audit
## 6. Template Injection Audit
## 7. XSS Audit
## 8. CSRF Audit
## 9. CORS Audit
## 10. SSRF Audit
## 11. Path Traversal / Filesystem Audit
## 12. Archive / Zip Slip Audit
## 13. File Upload / Serving Audit
## 14. XML / XXE Audit
## 15. YAML / Unsafe Deserialization Audit
## 16. Prototype Pollution Audit
## 17. Open Redirect / Host Header Audit
## 18. Cache Poisoning / Private Cache Audit
## 19. Security Misconfiguration Audit
## 20. ReDoS / Resource Exhaustion Audit
## 21. GraphQL / WebSocket Attack Surface
If relevant.
## 22. Excessive Data Exposure
## 23. Exploit Chain Analysis
## 24. Test Coverage
## 25. Findings Summary
| ID | Severity | Category | Source | Sink | Impact | Confidence |
|---|---|---|---|---|---|---|
## 26. P0 Findings
## 27. P1 Findings
## 28. P2 Findings
## 29. P3 Findings
## 30. P4 Hardening
## 31. Things Done Well
## 32. Not Applicable
## 33. Not Verified
## 34. Remediation Roadmap
---
# 224. SOURCE-SINK MATRIX
| Source | Validation | Sink | Context | Risk |
|---|---|---|---|---|
---
# 225. XSS MATRIX
| Input | Storage | Output context | Escaping | Sanitization |
|---|---|---|---|---|
---
# 226. SSRF MATRIX
| Feature | User controls host | Redirects | Internal protection | Response returned |
|---|---|---|---|---|
---
# 227. FILE MATRIX
| Upload type | Validation | Storage | Serving | Processing | Risk |
|---|---|---|---|---|---|
---
# 228. PARSER MATRIX
| Format | Library | Untrusted input | Dangerous features | Status |
|---|---|---|---|---|
---
# 229. SECOND PASS - RAW QUERY HUNT
Repository-wide find all:
```text
raw SQL
raw NoSQL
dynamic query strings
```
Perform source-to-sink tracing for each.
---
# 230. SECOND PASS - HTML SINK HUNT
Locate all unsafe HTML insertion points.
Determine the origin of content for each.
---
# 231. SECOND PASS - STORED XSS
For every user-editable text field, ask:
> Where is this rendered later?
Specifically:
- admin dashboards
- support views
- email templates
- public pages
---
# 232. SECOND PASS - URL FETCH HUNT
Locate every:
```text
fetch(user-controlled URL)
```
or equivalent.
Test:
- direct internal target
- redirect
- alternative hostname
only within a safe test environment.
---
# 233. SECOND PASS - FILE PATH HUNT
Locate all:
```text
readFile
writeFile
sendFile
open
extract
```
with attacker-influenced paths.
---
# 234. SECOND PASS - COMMAND HUNT
Locate all process execution call sites.
For each, determine:
- attacker control
- shell usage
- argument handling
---
# 235. SECOND PASS - DESERIALIZER HUNT
Search for:
- pickle
- unsafe YAML
- native serialization
- dynamic object reconstruction
---
# 236. SECOND PASS - REDIRECT HUNT
Locate every endpoint/flow deriving redirect destinations from requests.
---
# 237. SECOND PASS - HOST HUNT
Locate where:
```text
Host
X-Forwarded-Host
origin
request URL
```
are used to generate security-sensitive URLs.
---
# 238. SECOND PASS - CACHE HUNT
For each cached authenticated response, check:
- key structure
- tenant/user scope
- cache-control directives
---
# 239. SECOND PASS - ACTIVE FILE HUNT
For user uploads, inspect:
- HTML
- SVG
- XML
- JavaScript
- PDF
serving contexts.
---
# 240. SECOND PASS - PARSER BOMB
If processing:
- archives
- XML
- JSON
- images
- PDFs
verify bounds and resource amplification protections.
---
# 241. SECOND PASS - DOUBLE DECODE
For path, redirect, and HTML-related code, check whether:
```text
decode
↓
validate
↓
decode again
```
exists.
---
# 242. SECOND PASS - SECURITY CONFIG
Inspect production configs for:
- debug modes
- default credentials
- public storage buckets
- exposed admin tools
- broad CORS configurations
- source/config exposures
---
# 243. SECOND PASS - EXPLOIT CHAIN
For each P2+ finding, ask:
> Can this be linked with another confirmed finding to increase overall impact?
If not:
do not fabricate chains.
---
# 244. SECOND PASS - FRAMEWORK DEFENSE
Before finalizing findings, confirm whether frameworks or libraries already neutralize the payload.
---
# 245. SECOND PASS - PRODUCTION REACHABILITY
Code paths existing only in:
- test suites
- development environments
- unreachable dead code
must not be treated as production exploits without proof.
---
# 246. FINAL QUALITY GATE
Before issuing the final report, verify:
- every serious finding has a complete source-to-sink path
- input is genuinely attacker-controlled
- framework/library defenses have been verified
- raw SQL is not automatically marked as SQLi
- dynamic identifiers are analyzed separately from values
- XSS rendering contexts are accurately classified
- stored XSS is traced to actual victim execution contexts
- CSP is not framed as a replacement for output safety
- CSRF is analyzed against the actual credential model
- CORS is not confused with authorization
- SSRF includes redirect, DNS, and internal target semantics
- cloud metadata claims match the actual deployment platform
- path traversal uses canonical filesystem semantics
- archive extraction is verified for Zip Slip/bombs
- file upload audits trace files through storage, serving, and processing stages
- XML/YAML/deserialization findings match actual parser configurations
- prototype pollution demonstrates provable gadgets/impact before high severity ranking
- open redirect severity tracks actual exploit chains
- security headers without exploit paths remain P4 hardening
- development-only behavior is not reported as a production vulnerability
- exploit verification remains non-destructive in test environments
- every P0/P1 finding features clear impact and a reproducible or complete executable path
---
# FINAL RULE
Do not generate reports like:
> Follow the OWASP Top 10, use parameterized queries, CSP, and secure headers.
That is not vulnerability hunting.
I am looking for concrete defects such as:
```text
query param:
sort
↓
backend:
ORDER BY ${req.query.sort}
↓
values are otherwise parameterized
↓
sort identifier is directly concatenated
↓
attacker controls SQL syntax in ORDER BY
↓
query injection
```
or:
```text
user writes profile bio
↓
bio stored unchanged
↓
admin dashboard renders:
dangerouslySetInnerHTML
↓
no sanitizer
↓
payload executes in admin session
↓
stored XSS
```
or:
```text
POST /preview
body:
{
"url": "https://attacker.example"
}
↓
backend fetches URL
↓
follows redirects
↓
attacker server redirects to internal service
↓
backend follows redirect
↓
internal response returned to attacker
```
or:
```text
upload ZIP
↓
backend extracts each entry using supplied path
↓
entry path:
../../config/file
↓
extractor writes outside destination directory
↓
arbitrary file overwrite
```
or:
```text
download endpoint:
GET /download?file=...
↓
backend:
join(baseDir, userFile)
↓
no canonical containment validation
↓
attacker sends traversal path
↓
server returns file outside allowed directory
```
or:
```text
application receives YAML import
↓
uses unsafe native object loader
↓
attacker controls YAML tags/object construction
↓
runtime instantiates dangerous object
↓
code execution path
```
or:
```text
password reset URL generated from request Host
↓
Host accepted directly
↓
victim receives attacker-domain reset link
↓
token appears on attacker-controlled domain
↓
account takeover chain
```
or:
```text
private authenticated response
↓
CDN cache key ignores authentication identity
↓
first user warms cache
↓
second user receives cached first-user response
↓
cross-user data disclosure
```
These are the OWASP-like vulnerabilities you must uncover.
Reason through:
- source
- trust boundary
- transform
- validation
- sink
- execution context
- attacker
- victim
- impact
For every serious finding, you must be able to answer:
> Who controls the input?
> How does the input reach the sink?
> What validation exists in between?
> Why does that validation fail to stop the exploit?
> Which exact sink interprets the input as code, query, path, URL, or markup?
> What does the attacker achieve as a result?
If the source-to-sink path is incomplete:
**NOT VERIFIED.**
If only a defense-in-depth gap exists:
**P4 - HARDENING.**
If a specific vulnerability class is entirely irrelevant:
**NOT APPLICABLE.**
It is far better to find 5 real, provable exploit paths than to write 100 generic OWASP checklist items.
The objective is to produce a forensically precise OWASP Vulnerability Hunter audit that translates directly into:
- deterministic exploit regression test
- input validation fix
- safe query construction
- contextual output encoding
- SSRF containment
- secure file handling
- safe parser configuration
- production security remediation分类与标签
编程开发、应用安全、漏洞审计、输入追踪、注入漏洞、安全修复