返回提示词目录第 1377 页

应用文件上传链路安全审计

沿文件接收、验证、存储、处理和下载全流程排查风险,整理可复现的安全问题与加固建议。

完整提示词

I want you to perform a maximally deep, systematic, evidence-first, and production-oriented analysis of the application's entire file upload system, from the moment a file leaves the client to its:

- ingestion
- parsing
- validation
- temporary staging
- permanent storage
- post-processing
- previewing
- downloading
- public serving
- deletion
- archiving

Main goal:

> Determine whether an attacker can upload a file that bypasses validation, executes active content under the application origin, overwrites or reads local files, triggers parser exploits, SSRF, Zip Slip, decompression bombs, storage exhaustion, malware distribution, cross-user/cross-tenant data access, or other concrete security failures.

This is not:

- generic advice to check MIME types
- an automatic demand for antivirus scanning on every upload
- an automatic ban on SVG, PDF, or ZIP files
- assuming file extensions dictate actual file types
- assuming magic bytes solve all validation problems
- automatically migrating everything to object storage
- merely a path traversal audit
- merely a malware audit
- merely a file size limit audit
- automatically declaring every user-uploaded file an RCE risk

The focus is on the complete lifecycle:

```text
client-selected file
↓
HTTP upload
↓
body/multipart parser
↓
temporary storage
↓
validation
↓
renaming/key generation
↓
permanent storage
↓
processing/transformation
↓
metadata extraction
↓
serving/download
↓
deletion/retention
```

Priority:

**arbitrary code execution > arbitrary file write/read > active content under trusted origin > parser exploitation > cross-user/cross-tenant exposure > SSRF/path traversal > archive attacks > storage/resource abuse > malware distribution > hardening**

It is better to identify 5 real, exploitable upload failures than to write 100 generic file security recommendations.

---

# 1. INVENTORY ALL UPLOAD SURFACES

Locate every upload workflow:

- avatars
- profile images
- attachments
- documents
- invoices
- CSV imports
- ZIP imports
- backup restores
- media uploads
- videos
- audio
- PDFs
- spreadsheets
- office documents
- admin imports
- webhook-attached files
- API bulk uploads

For each, document:

```text
Endpoint:
Method:
Authenticated:
Required permission:
Accepted file types:
Max size:
Max count:
Temporary storage:
Permanent storage:
Processing:
Publicly served:
Retention:
```

---

# 2. DO NOT EXAMINE ONLY `multipart/form-data`

Uploads can arrive via:

- multipart forms
- raw binary request bodies
- base64 JSON payloads
- presigned object storage uploads
- chunked uploads
- remote URL imports
- drag-and-drop frontend interfaces
- direct mobile uploads
- archive imports

---

# 3. MAP THE ACTUAL EXECUTION FLOW

For each upload feature, diagram:

```text
request
↓
body parser
↓
temporary file/buffer
↓
validation
↓
rename
↓
storage
↓
metadata DB record
↓
post-processing
↓
serving
```

---

# 4. IDENTIFY TRUST BOUNDARIES

Differentiate:

```text
browser/client input
server parser
local filesystem
object storage
third-party processor
public CDN
```

Every boundary alters the underlying threat model.

---

# 5. ORIGINAL FILE NAMES

The original filename is attacker-controlled input.

Never treat it as a trusted filesystem path.

---

# 6. SERVER-GENERATED FILE NAMES

Prefer server-generated:

- UUIDs
- random cryptographic identifiers
- content-addressed storage keys

where architecture allows.

Original filenames can be retained as metadata.

---

# 7. PATH TRAVERSAL

Test relevant traversal sequences:

```text
../../file
..\..\file
```

and platform-specific encodings where the runtime permits.

---

# 8. ABSOLUTE PATHS

Test:

```text
/etc/passwd
C:\Windows\...
\server\share
```

strictly within a controlled test environment.

---

# 9. PATH NORMALIZATION

Verify the execution order:

```text
decode
normalize
validate
join
```

---

# 10. DOUBLE DECODING

Classic bypass pattern:

```text
%252e%252e%252f
↓
decode once
↓
validation
↓
decode again
↓
../
```

Relevant only if the stack genuinely performs multiple decoding passes.

---

# 11. PREFIX CHECKS

Naive checks like:

```text
resolved.startsWith(base)
```

can be flawed without canonical path separator semantics.

---

# 12. WINDOWS PATHS

If the server can run on Windows:

inspect:

- `\`
- drive letters
- UNC paths
- reserved device names
- alternate path separators

---

# 13. RESERVED NAMES

On Windows:

```text
CON
PRN
AUX
NUL
COM1
LPT1
```

can trigger platform edge cases.

Severity scaled strictly to real impact.

---

# 14. FILENAME LENGTH

Extremely long filenames can:

- crash filesystems
- overflow database columns
- break loggers
- distort UI layouts

Enforce bounded maximum lengths.

---

# 15. UNICODE FILENAMES

Normalization and confusable issues can trigger:

- duplicate file overwrites
- extension confusion
- moderation bypasses

Report only with demonstrable security impact.

---

# 16. NULL BYTES

Historically:

```text
file.php%00.jpg
```

Modern runtimes predominantly block this.

Do not report without concrete library or runtime verification.

---

# 17. EXTENSION VALIDATION

Client-provided extensions do not prove actual file type.

---

# 18. CASE VARIATIONS

```text
.PHP
.JpG
.SvG
```

If validation routines perform case-sensitive comparisons.

---

# 19. MULTIPLE EXTENSIONS

Examples:

```text
shell.php.jpg
invoice.pdf.exe
```

---

# 20. TRAILING DOTS AND SPACES

Certain filesystems normalize:

```text
file.php.
file.php 
```

Verify only on relevant operating systems.

---

# 21. MIME TYPES

The multipart `Content-Type` header is attacker-controlled.

Never treat it as authoritative.

---

# 22. MAGIC BYTES

Can assist in identifying known file signatures.

However:

> Magic bytes are not a universal defense against polyglot or active content files.

---

# 23. POLYGLOT FILES

A file can be simultaneously valid across multiple formats.

Examples:

- image structures containing executable scripts
- archive headers wrapping executable binaries

Report only where serving or processing contexts enable exploitation.

---

# 24. FILE SIGNATURE LIBRARIES

If employing type detection libraries:

inspect:

- library version
- supported formats
- fallback handling

---

# 25. UNKNOWN TYPES

Ask:

> What happens if type detection returns unknown?

Unknown types must never be allowed by default.

---

# 26. ALLOWLISTS

For high-risk uploads, explicitly allowing required types is vastly superior to attempting to blacklist malicious formats.

---

# 27. BLACKLISTS

If an implementation merely blocks:

```text
.exe
.php
.js
```

an attacker may leverage other active formats.

---

# 28. FILE TYPES MUST MATCH THE USE CASE

Avatars:

```text
JPEG/PNG/WebP
```

must enforce a much narrower allowlist than general attachment systems.

---

# 29. FILE SIZES

Enforce limits across multiple layers:

- reverse proxies
- application body parsers
- business logic validators
- object storage configurations

---

# 30. CLIENT-SIDE LIMITS ARE NOT SECURITY CONTROLS

Frontend `maxSize` guards are insufficient.

Backend and storage layers must enforce constraints.

---

# 31. REQUEST BODY LIMITS

Unbounded request bodies can exhaust server memory prior to business validation.

---

# 32. PER-FILE LIMITS

---

# 33. PER-REQUEST TOTAL LIMITS

Ten 100 MB files are not equivalent to a single 100 MB upload.

---

# 34. FILE COUNT LIMITS

Uploading 100,000 tiny files can cause resource denial of service.

---

# 35. CONCURRENT UPLOAD LIMITS

A single user opening excessive concurrent upload connections.

---

# 36. ACCOUNT AND TENANT STORAGE QUOTAS

Per-request limits alone do not prevent cumulative storage exhaustion.

---

# 37. GLOBAL STORAGE CAPACITY

If utilizing local storage:

audit disk full failure behaviors.

---

# 38. TEMPORARY STORAGE

Multipart parsers may buffer incoming files in:

- system RAM
- temporary disk paths

before validation logic executes.

---

# 39. MEMORY BUFFERING

Scenario:

```text
500 MB upload
↓
entire body buffered in RAM
↓
several concurrent requests
↓
OOM crash
```

---

# 40. STREAMING

Streaming mitigates memory exhaustion.

However, it does not inherently solve:

- malicious content ingestion
- total storage consumption
- incomplete partial uploads

---

# 41. TEMPORARY FILE CLEANUP

On:

- successful completion
- validation failure
- unhandled exceptions
- client disconnections

temporary files must be reliably purged.

---

# 42. ORPHANED TEMPORARY FILES

Repeated failed uploads can silently exhaust disk space.

---

# 43. PARTIAL UPLOADS

A client drops connection mid-stream.

Determine:

- what data remains on disk
- whether temporary files persist
- whether metadata falsely flags the upload as complete

---

# 44. CHUNKED UPLOADS

If supported:

map:

```text
init
↓
chunks
↓
complete
```

---

# 45. CHUNK OWNERSHIP

An attacker must not be able to append chunks to another user's upload session.

---

# 46. CHUNK ORDERING

Out-of-order or duplicate chunks can corrupt assembled files.

---

# 47. CHUNK SIZES

Every individual chunk must be bounded by size limits.

---

# 48. TOTAL CHUNKED SIZE

Prevent cumulative bypasses:

```text
per chunk < limit
```

where:

```text
10,000 chunks
```

exceed total storage limits.

---

# 49. UPLOAD SESSION IDENTIFIERS

If possessing a session token confers write permissions:

it must be cryptographically unguessable or bound to user authentication.

---

# 50. FINALIZE RACE CONDITIONS

Concurrent finalization requests must not produce duplicate metadata records or duplicated side effects.

---

# 51. PRESIGNED UPLOADS

If clients upload directly to cloud object storage:

audit the endpoint generating presigned credentials.

---

# 52. PRESIGNED URL SCOPING

Inspect:

- target bucket
- object key restrictions
- permitted HTTP methods
- expiration duration
- content constraints where applicable

---

# 53. ARBITRARY OBJECT KEYS

Users must never be able to request signed PUT operations for:

```text
another-user/file
system/config
```

---

# 54. OVERWRITE PERMISSIONS

If PUT requests against existing objects are permitted:

verify strict object-level authorization.

---

# 55. CREATE-ONLY SEMANTICS

If a user is only authorized for new uploads, the presigned flow should enforce create-only semantics to the extent supported by storage APIs.

---

# 56. PRESIGNED URL EXPIRATION

Must not exceed reasonable use case requirements.

Do not mandate an arbitrary expiration duration.

---

# 57. CONTENT-TYPE IN PRESIGNED URLS

If signature binding enforces a content type:

ensure backend verification does not blindly trust that client assertion later.

---

# 58. POST-UPLOAD VALIDATION

Direct storage uploads often require subsequent server-side validation or processing before the file is marked trusted or public.

---

# 59. QUARANTINE STATES

Potential lifecycle states:

```text
UPLOADED
↓
SCANNING/VALIDATING
↓
READY
```

Do not introduce if unneeded, but audit if present.

---

# 60. FILES BECOMING PUBLIC BEFORE VALIDATION

High-signal vulnerability for active and malicious content.

---

# 61. STORAGE LOCATIONS

Determine:

- local web root
- local non-web directory
- private cloud bucket
- public cloud bucket
- CDN distribution

---

# 62. WEB ROOT PLACEMENT

If uploaded files land directly inside directories where the web server executes or serves application code:

critical risk.

---

# 63. SERVER-SIDE CODE EXECUTION

Most dangerous scenario:

```text
upload .php/.jsp/.aspx/etc
↓
web server interprets file as executable code
```

valid only if the specific server and runtime environment can execute it.

---

# 64. STATIC FILE SERVERS

A Node.js or static server may merely return `.php` files as raw binary bytes.

Do not report RCE if the server lacks an execution interpreter.

---

# 65. FILE SERVING ORIGINS

Ask:

> From which origin does the browser retrieve user-uploaded files?

---

# 66. SAME-ORIGIN SERVING

Active content served directly from:

```text
https://app.example.com
```

carries far greater impact than serving from an isolated untrusted domain.

---

# 67. DEDICATED FILE DOMAINS

Significantly mitigates XSS and origin compromise risks.

P4/P2 depending on actual active content exposure.

---

# 68. HTML UPLOADS

If users can upload HTML files and open them inline under the application origin:

immediate stored XSS and account takeover candidate.

---

# 69. SVG FILES

SVG files can contain executable scripts and external entity references.

---

# 70. SVG `<script>` TAGS

The rendering and embedding context determines whether script execution occurs.

---

# 71. SVG `<foreignObject>` TAGS

Can encapsulate arbitrary HTML markup.

---

# 72. SVG EXTERNAL RESOURCES

Can trigger client-side tracking, privacy leaks, or server-side SSRF if backend parsers fetch references.

---

# 73. SVG SANITIZATION

If SVG uploads must be supported:

verify robust sanitization routines, not mere XML parsing.

---

# 74. PDF FILES

PDF files can embed:

- links
- form actions
- attached files
- JavaScript in certain viewer engines

Severity depends on the target viewer and serving configuration.

---

# 75. PDF PREVIEWERS

If the application utilizes embedded or custom PDF viewers:

evaluate their sandbox boundaries and security configurations.

---

# 76. OFFICE DOCUMENTS

May contain:

- macros
- external OLE links
- embedded payloads

If the application only stores and serves downloads, server execution is not automatically an issue.

---

# 77. MALWARE DISTRIBUTION

If users share uploaded attachments with one another:

malware distribution risks become highly relevant.

---

# 78. MALWARE SCANNING

Do not mandate antivirus scanning for every application.

Evaluate:

- user-to-user sharing patterns
- enterprise threat profile
- permitted file types
- exposure to untrusted parties

---

# 79. SCANNING WORKFLOW

If antivirus scanning is implemented:

map:

```text
uploaded
↓
scan
↓
clean / infected / failed
```

---

# 80. SCANNER OUTAGES

If the scanning engine becomes unavailable:

determine behavior:

- fail closed
- queue for retry
- fail open

Evaluated against business risk.

---

# 81. PUBLICATION BEFORE SCANNING

Infected files must not become downloadable if the security model mandates scanning prior to release.

---

# 82. PARSER ATTACK SURFACES

Inventory all backend media processing utilities:

- ImageMagick
- FFmpeg
- ExifTool
- PDF rendering libraries
- LibreOffice/headless office tools
- archive extraction libraries
- OCR engines
- media metadata extractors

---

# 83. PARSERS ARE TRUST BOUNDARIES

Validating file extensions does not render parser input trusted.

---

# 84. IMAGE DECODING

Attacker-controlled image decoders expose memory safety, CPU exhaustion, and third-party dependency vulnerabilities.

---

# 85. IMAGE DIMENSIONS

A small compressed image can decompress into a massive in-memory raw bitmap.

Example:

```text
50,000 × 50,000 pixels
```

---

# 86. PIXEL DIMENSION LIMITS

Often more critical than raw file size limits.

---

# 87. IMAGE DECOMPRESSION BOMBS

Verify decoding library safeguards and dimension caps.

---

# 88. EXIF METADATA

Metadata structures can contain:

- oversized attribute blocks
- attacker-crafted strings
- sensitive GPS coordinates and PII

---

# 89. EXIF OUTPUT HANDLING

If extracted metadata flows into HTML, logs, or database queries:

it acts as untrusted second-order input.

---

# 90. EXIF STRIPPING

Privacy hardening for public images where desirable.

Not a universal vulnerability requirement.

---

# 91. VIDEO FILES

FFmpeg-based processing represents a high-value untrusted parser attack surface.

---

# 92. VIDEO DURATION

A small file can entail extremely complex or lengthy transcoding operations.

---

# 93. TRANSCODING RESOURCE LIMITS

Enforce:

- CPU limits
- memory ceilings
- maximum execution time
- worker concurrency
- processing timeouts

---

# 94. AUDIO FILES

Same transcoding and parser constraints apply.

---

# 95. DOCUMENT CONVERSION

Office and PDF conversion pipelines can expose:

- shell execution risks
- filesystem access
- parser crashes
- macro execution
- outbound network requests

---

# 96. SANDBOXED PROCESSING

For high-risk untrusted parsers, evaluate:

- isolated worker processes
- container sandboxing
- restricted OS permissions
- network isolation

Do not automatically demand full sandboxing unless justified by the threat profile.

---

# 97. PARSER NETWORK ACCESS

Critical question:

> Can the file parser initiate outbound network requests during processing?

---

# 98. FILE-BASED SSRF

Documents, images, or SVGs referencing:

```text
http://internal-service
```

If server-side parsers resolve external references:

SSRF vulnerability.

---

# 99. PDF/HTML RENDERING SSRF

If uploaded documents or HTML are processed via headless browsers:

verify strict isolation from internal network resources.

---

# 100. LOCAL FILE REFERENCES

Parsers may support:

```text
file://
```

or relative local filesystem paths.

---

# 101. XXE

If uploads include XML, SVG, or XML-based office formats:

verify parser external entity resolution settings.

---

# 102. ZIP AND ARCHIVE FILES

Inventory:

- ZIP
- TAR
- GZ
- 7z
- RAR

if decompressed on the server.

---

# 103. ZIP SLIP

Entries containing:

```text
../../target
```

must never escape the intended destination extraction directory.

---

# 104. ABSOLUTE ARCHIVE PATHS

Block absolute paths according to archive extraction library semantics.

---

# 105. SYMLINKS IN ARCHIVES

Archives may package symlinks that subsequent entries traverse to write files outside the sandbox.

---

# 106. HARDLINKS

If supported by archive formats and extraction tools.

---

# 107. EXTRACTION ORDER

Symlink and hardlink safety frequently depends on the sequencing of extracted entries.

---

# 108. DECOMPRESSION BOMBS

Raw:

```text
10 MB
```

can decompress into:

```text
100 GB
```

---

# 109. COMPRESSION RATIOS

Enforce limits on:

- total expanded byte volume
- maximum extracted entry count
- archive nesting depth

---

# 110. NESTED ARCHIVES

Archives within archives can bypass single-layer inspection thresholds.

---

# 111. ARCHIVE ENTRY COUNTS

Extracting millions of tiny files triggers filesystem inode and resource exhaustion.

---

# 112. EXTRACTION TIMEOUTS

Extraction operations must be strictly bounded in execution time.

---

# 113. EXTRACTION DISK QUOTAS

Cap the cumulative disk footprint during extraction, not merely the archive input size.

---

# 114. DUPLICATE ENTRY NAMES

Archives containing multiple entries with identical paths.

Determine precedence rules and potential validation bypasses.

---

# 115. VALIDATE-THEN-EXTRACT MISMATCH

If validation inspects the first entry while the extraction tool overwrites it with the last entry:

critical bypass.

---

# 116. TOCTOU

If file validation and processing operate across mutable shared paths:

attackers or concurrent processes may substitute contents between steps.

Relevant according to filesystem permissions.

---

# 117. CONTENT HASHES

Cryptographic hashes help maintain immutable file tracking throughout processing pipelines.

Not mandatory, but valuable.

---

# 118. POST-VALIDATION MUTATION

If an object can be overwritten after validation, scan results no longer guarantee current safety.

---

# 119. PRESIGNED OVERWRITE AFTER SCANNING

Scenario:

```text
upload clean file
↓
scan = CLEAN
↓
same signed key overwritten with malicious file
↓
status remains CLEAN
```

Verify object immutability and versioning semantics.

---

# 120. STORAGE KEY COLLISIONS

Server-generated storage keys must eliminate accidental or deliberate overwrites.

---

# 121. USER-SUPPLIED IDENTIFIERS AS STORAGE KEYS

If paths follow:

```text
uploads/{userInput}
```

verify collision risks and ownership boundaries.

---

# 122. CASE-INSENSITIVE FILESYSTEMS

`File.jpg` and `file.jpg` can collide on case-insensitive filesystems.

---

# 123. OBJECT STORAGE CASE SENSITIVITY

Cloud object stores may behave differently than local host filesystems.

---

# 124. OVERWRITING EXISTING FILES

Can enable:

- avatar substitution
- unauthorized modification of third-party documents
- system asset corruption

---

# 125. STATIC ASSET OVERWRITES

If upload paths can target:

```text
index.html
app.js
config.json
```

critical application compromise.

---

# 126. DATABASE METADATA

Every upload record must be tightly bound to:

- owner identity
- tenant identity
- storage object key
- lifecycle state

---

# 127. ORPHANED STORAGE OBJECTS

Storage upload succeeds, but database metadata insertion fails.

---

# 128. ORPHANED DATABASE RECORDS

Database metadata is created, but storage upload fails or is aborted.

---

# 129. FALSE READY STATES

Metadata must never declare:

```text
READY
```

if the underlying object is missing or processing has not completed.

---

# 130. DELETION WORKFLOWS

Map:

```text
authorization
↓
DB delete/state
↓
storage delete
```

---

# 131. STORAGE DELETION FAILURES

Database records may be purged while private or public files remain exposed in storage.

---

# 132. ORPHANED PUBLIC FILES

High-risk privacy and security exposure.

---

# 133. SOFT DELETIONS

Direct or presigned URLs may remain active even after application records are flagged as deleted.

---

# 134. CDN CACHING

Deleted or restricted files may persist inside CDN edge caches.

---

# 135. PUBLIC TO PRIVATE VISIBILITY TRANSITIONS

When changing visibility from public to private:

verify immediate cache purging and access restriction enforcement.

---

# 136. SIGNED DOWNLOAD URLS

If signed URLs remain valid long after permissions are revoked:

determine whether this constitutes intended capability semantics or an access control flaw.

Document clearly.

---

# 137. DOWNLOAD AUTHORIZATION

Do not audit uploads in isolation.

Private file downloads demand identical access control enforcement.

---

# 138. FILE IDOR

Substituting file identifiers or storage keys with another user's resource.

---

# 139. THUMBNAIL IDOR

Preview and thumbnail endpoints must not circumvent parent file authorization checks.

---

# 140. DERIVATIVE FILES

Transcoded media, thumbnails, OCR text, and extracted document pages must retain owner and tenant scoping.

---

# 141. OCR OUTPUTS

Extracted text can be confidential even when original binary access is controlled.

---

# 142. PREVIEW HTML GENERATION

Preview renderers must not inject extracted text or document markup as unsanitized raw HTML.

---

# 143. METADATA XSS

Filenames, document titles, and EXIF metadata displayed unsanitized in admin dashboards:

classic stored XSS second-order attack path.

---

# 144. CONTENT-DISPOSITION

For potentially active file formats:

```text
attachment
```

is substantially safer than inline serving.

Evaluate against product requirements.

---

# 145. CONTENT-TYPE ON DOWNLOAD

Servers must serve accurate and safe MIME types.

---

# 146. `X-Content-Type-Options: nosniff`

Essential defense-in-depth header for all user-generated content delivery.

---

# 147. CSP ON FILE SERVING ORIGINS

Restrictive Content Security Policies further constrain active content execution.

P4/P2 depending on actual exposure.

---

# 148. CONTENT SECURITY SANDBOXES

Dedicated untrusted file domains paired with restrictive CSPs are recommended for preview systems.

---

# 149. SAME-SITE COOKIES

If file-serving origins share application authentication cookies:

the impact of active content execution multiplies.

---

# 150. COOKIE DOMAIN SCOPE

A `.example.com` cookie scope exposes credentials to untrusted file subdomains.

Verify cookie boundaries.

---

# 151. `document.domain` AND LEGACY BEHAVIORS

Evaluate only against actual modern browser specifications.

---

# 152. STORAGE CORS CONFIGURATIONS

Private storage buckets must not grant overly permissive CORS headers allowing unauthorized cross-origin reads.

---

# 153. PUBLIC BUCKETS

Audit object ACLs and bucket policies.

---

# 154. DIRECTORY AND PREFIX LISTINGS

Determine whether attackers can enumerate storage object keys.

---

# 155. GUESSABLE OBJECT KEYS

If buckets are public, unguessable keys may serve as the sole access barrier:

this constitutes a capability-by-obscurity model.

---

# 156. OBJECT KEY LEAKAGE

Access logs, referrer headers, and UI views can leak private capability URLs.

---

# 157. STORAGE CREDENTIALS

Backend cloud storage access keys must never be exposed to clients.

---

# 158. TEMPORARY CLOUD CREDENTIALS

If using direct uploads via temporary credentials:

strictly audit granted IAM scopes and expiration lifetimes.

---

# 159. MULTIPART CLOUD UPLOADS

In S3-compatible multipart uploads, verify ownership over:

- upload IDs
- part numbers
- completion and abort commands

---

# 160. ABORTED UPLOADS

Abandoned multipart uploads can silently accumulate storage billing costs.

---

# 161. FILE HASH DEDUPLICATION

If the server deduplicates files globally by hash:

privacy side channels may allow attackers to detect whether another user uploaded a specific file.

---

# 162. "FILE ALREADY EXISTS" RESPONSES

Can disclose the existence of sensitive documents across accounts.

---

# 163. CROSS-TENANT DEDUPLICATION

Shared storage objects must never cause authorization rights to bleed across tenant boundaries.

---

# 164. SERVER-SIDE DEDUPLICATION REFERENCES

A single physical object may link to multiple logical records, but authorization must remain strictly per-reference.

---

# 165. DOWNLOAD COUNTERS

Public and share link download quotas can be bypassed via race conditions.

---

# 166. ONE-TIME DOWNLOAD LINKS

If links are single-use:

enforce atomic token invalidation.

---

# 167. SHARE LINKS

Capability tokens must be strictly scoped to specific files and permitted operations.

---

# 168. PUBLIC TOKENS

URL-based tokens can leak via:

- proxy logs
- analytics
- referrer headers
- browser history

---

# 169. UPLOAD CALLBACKS

Cloud storage events notifying backends of completed uploads must be validated for authenticity and tenant safety.

---

# 170. MALICIOUS STORAGE EVENTS

Never trust event metadata without verifying cloud provider message authenticity.

---

# 171. REMOTE URL IMPORTS

If the application supports:

```text
Import file from URL
```

this combines file upload risks with SSRF attack surfaces.

---

# 172. URL IMPORT CONTROLS

Inspect:

- URI schemes
- target hosts
- HTTP redirects
- DNS resolution
- payload size caps
- content type assertions
- connection timeouts

---

# 173. UNKNOWN CONTENT-LENGTH

Remote servers may omit `Content-Length` headers.

The backend must enforce byte ceilings progressively during stream consumption.

---

# 174. SPOOFED CONTENT-LENGTH

Never rely on headers as the sole file size control.

---

# 175. SLOW REMOTE SERVERS

Remote imports can monopolize worker threads and connection pools.

---

# 176. REDIRECTS TO LARGE FILES

Validating the initial URL size is insufficient if redirects lead to massive payloads.

---

# 177. REDIRECTS TO INTERNAL SERVICES

SSRF via redirect.

---

# 178. REMOTE ARCHIVE IMPORTS

Combines:

- SSRF
- massive downloads
- decompression bombs

---

# 179. ADMINISTRATIVE IMPORTS

Administrative roles do not render uploaded data inherently trusted.

---

# 180. BACKUP RESTORATION

One of the most dangerous upload attack surfaces.

---

# 181. RESTORE ARCHIVES

Can package:

- configurations
- directory paths
- user accounts
- role assignments
- raw database states

---

# 182. BACKUP PATH TRAVERSAL

Restoration routines must never write outside designated data directories.

---

# 183. BACKUP SCHEMA VERSIONING

Restoring incompatible schemas must not corrupt system state.

Reliability and integrity boundary.

---

# 184. BACKUP AUTHORIZATION

Who is authorized to trigger restorations?

High-privilege operation.

---

# 185. BACKUP REPLACE MODES

Destructive operations purging active data demand explicit authorization guards.

---

# 186. IMPORTED OWNER AND TENANT IDS

Import routines must not permit ordinary users to inject records into foreign tenants.

---

# 187. CSV IMPORTS

CSVs can introduce:

- oversized rows
- formula injections
- malformed escaping
- unauthorized privilege columns

---

# 188. CSV FORMULA INJECTION

If imported data is subsequently exported or reviewed in spreadsheet software:

cells prefixed with:

```text
=
+
-
@
```

can execute formulas.

Evaluate against real user workflows.

---

# 189. CSV PARSER CONSTRAINTS

Enforce limits on:

- row counts
- column counts
- individual field lengths

---

# 190. JSON IMPORTS

Deep nesting and massive array structures.

---

# 191. XML IMPORTS

XXE and entity expansion attacks.

---

# 192. YAML IMPORTS

Unsafe deserialization.

---

# 193. FILE PROCESSING QUEUES

If uploads are dispatched to async workers:

audit:

- job payloads
- idempotency
- retry behaviors
- stale file states

---

# 194. RETRYING PROCESSING JOBS

Job retries must not duplicate database metadata or external side effects.

---

# 195. FILES REPLACED BEFORE RETRIES

Worker retries might inadvertently process modified content stored under the same key.

---

# 196. IMMUTABLE VERSION IDENTIFIERS

Ensure background workers process the precise validated file version.

---

# 197. CANCELLING UPLOADS

If a user deletes a file while processing is active:

workers must not republish or mark the file as ready.

---

# 198. PROCESSING RACE CONDITIONS

```text
delete
||
scan completes
```

Which state takes precedence?

---

# 199. SCAN RESULTS FOR STALE VERSIONS

If files can be overwritten:

scanning verdicts must bind directly to specific content versions or hashes.

---

# 200. CRYPTOGRAPHIC HASHING

Useful for:

- integrity validation
- immutable content addressing
- scan result binding

Does not replace authorization checks.

---

# 201. ANTIVIRUS SIGNATURES

Antivirus results include:

- clean
- infected
- error
- timeout
- unknown

An `error` state must never be treated as `clean`.

---

# 202. SANITIZATION

Content Disarm and Reconstruction (CDR) can be considered for high-risk enterprise systems.

Do not mandate generically.

---

# 203. LOGGING

Do not log:

- raw binary contents
- presigned credentials
- private capability URLs

without operational necessity.

---

# 204. FILENAMES IN LOGS

Attacker-crafted filenames can trigger log injection or massive log bloat.

---

# 205. METADATA LOGGING

Sensitive EXIF and document attributes can leak into application logs.

---

# 206. ERROR RESPONSES

Parser exceptions must never disclose:

- local filesystem paths
- internal shell commands
- temporary directory locations
- library version internals

---

# 207. OBSERVABILITY

Monitor where relevant:

- total upload volumes
- rejected uploads
- max-size rejections
- scanning failures
- parser exceptions
- processing latency
- orphan file counts
- storage utilization

---

# 208. ABUSE DETECTION

Spikes in:

- upload frequency
- aggregate byte volume
- decompression failures

frequently signal deliberate abuse.

---

# 209. RATE LIMITING

Upload endpoints require cost-aware rate limiting.

Detailed rate limiting audits are covered separately.

---

# 210. BYTE TRANSFER RATE

Request counts alone do not constrain bandwidth exhaustion.

---

# 211. USER QUOTAS

Upload rate limits operate independently from total persistent storage quotas.

---

# 212. TENANT QUOTAS

A single tenant must not consume shared disk or cloud storage budgets without intended product limits.

---

# 213. UNAUTHENTICATED UPLOADS

If public uploads exist:

rigorously analyze abuse vectors and storage exhaustion costs.

---

# 214. PUBLIC TEMPORARY UPLOADS

Unclaimed temporary uploads must enforce strict TTL cleanup policies.

---

# 215. CAPTCHA

Do not mandate automatically.

Implement only where bot and spam abuse justifies user friction.

---

# 216. DOWNLOAD SECURITY

Audit download workflows alongside ingestion paths.

---

# 217. CONTENT RANGE REQUESTS

Large file downloads frequently utilize `Range` headers.

Ensure authorization checks govern partial content requests equally.

---

# 218. HEAD REQUESTS

Can disclose the existence and metadata of private files without body download.

---

# 219. CACHING

Private file downloads must never be cached by shared public intermediaries.

---

# 220. CDN SIGNED URLS

Verify path constraints and token expiration lifetimes.

---

# 221. PERMISSION REVOCATION

If a user loses file permissions, long-lived CDN tokens may continue to grant access.

Document capability lifetimes.

---

# 222. RETENTION POLICIES

Expired or deleted private files must be permanently purged in accordance with privacy policies.

Avoid legal assessments; focus on technical mechanisms.

---

# 223. BACKUPS OF UPLOADED DATA

Deleted files may persist inside historical backups.

This is standard operational reality; document retention lifecycles.

---

# 224. SECURITY TESTING

Map existing automated upload security test coverage.

---

# 225. VALID FILE TESTS

Verify each permitted file type.

---

# 226. EXTENSION MISMATCH TESTS

Discrepancies between file extension and actual content.

---

# 227. MIME TYPE MISMATCH TESTS

---

# 228. UNKNOWN FILE TYPE TESTS

---

# 229. OVERSIZED FILE TESTS

---

# 230. EXCESSIVE FILE COUNT TESTS

---

# 231. CONCURRENT UPLOAD TESTS

---

# 232. PATH TRAVERSAL FILENAME TESTS

---

# 233. DUPLICATE FILENAME TESTS

---

# 234. FILE OVERWRITE TESTS

---

# 235. ACTIVE CONTENT TESTS

For HTML, SVG, and PDF according to allowed formats.

---

# 236. STORED XSS TESTS

Upload malicious metadata and test rendering in:

- standard user UI
- administrative dashboards
- preview views

---

# 237. ZIP SLIP TESTS

Controlled synthetic archive containing traversal path entries.

---

# 238. DECOMPRESSION BOMB TESTS

Use safe synthetic limits; avoid creating actual disk exhaustion events.

---

# 239. ARCHIVE SYMLINK TESTS

Where supported by extraction libraries.

---

# 240. IMAGE DIMENSION BOMB TESTS

Small compressed files with extreme pixel dimensions tested in safe environments.

---

# 241. PARSER TIMEOUT TESTS

Complex or pathological inputs causing parsing hangs.

---

# 242. SSRF FILE TESTS

If parsers resolve external references:

test against controlled local test endpoints.

---

# 243. TEMPORARY FILE CLEANUP TESTS

Abort uploads mid-transfer and verify disk cleanup.

---

# 244. DATABASE FAILURE TESTS

Storage write succeeds, database record fails.

---

# 245. STORAGE FAILURE TESTS

Database record succeeds, storage write fails.

---

# 246. DELETION FAILURE TESTS

Database record deleted, storage object persists.

---

# 247. PERMISSION ISOLATION TESTS

User A file access attempts by User B.

---

# 248. CROSS-TENANT ACCESS TESTS

Tenant A credentials targeting Tenant B storage objects.

---

# 249. PRESIGNED URL AUTHORIZATION TESTS

Attempting to request signed URLs for unauthorized object keys.

---

# 250. PRESIGNED OVERWRITE TESTS

Attempting to overwrite existing objects when workflows mandate create-only semantics.

---

# 251. SCANNING BYPASS TESTS

If scan statuses exist:

attempt accessing objects prior to achieving `CLEAN/READY` state.

---

# 252. SCAN VERSION RACE TESTS

Scan clean version 1, overwrite with version 2, attempt serving.

---

# 253. FINDING FORMAT

Every substantive finding must include:

```text
ID:
Severity:
Category:
Confidence:
Status:
Evidence tier:

Upload feature:
Endpoint:
Authentication:
Required role:

File type:
Original filename:
Detected type:
Size:
Processing pipeline:

Storage:
Serving origin:
Public/private:

File/Class:
Function:
Relevant config:

Vulnerability:

Attacker prerequisites:

Upload timeline:

T0:
T1:
T2:
T3:

Expected security behavior:

Actual/Possible behavior:

Arbitrary file read:
YES / NO

Arbitrary file write:
YES / NO

Server code execution:
YES / NO / NOT VERIFIED

Browser active content:
YES / NO

SSRF:
YES / NO

Cross-user:
YES / NO

Cross-tenant:
YES / NO

Resource exhaustion:
YES / NO

Malware distribution:
YES / NO

Impact:

Blast radius:

Root cause:

Recommended remediation:

Regression/security test:

Production verification:

Complexity:
XS / S / M / L / XL
```

---

# 254. SEVERITY

Use:

## P0 - CRITICAL

- file upload leads to unauthenticated or low-privilege remote code execution
- arbitrary overwrite of critical server or application files resulting in takeover
- unrestricted cross-tenant file exposure at scale
- malicious backup restore or upload causing catastrophic system compromise

## P1 - HIGH

- arbitrary private file read or write capabilities
- active uploaded content executing under trusted application origin with substantial account takeover impact
- parser-driven SSRF targeting sensitive internal network services
- upload validation bypass leading to broad cross-user data disclosure
- archive extraction writing files outside designated storage sandboxes

## P2 - MEDIUM

- significant stored XSS through uploaded content or metadata
- resource exhaustion via realistic low-cost exploit vectors
- upload/deletion race conditions leading to private data exposure
- limited cross-user file access
- malware distribution gaps in applications actively sharing uploads across users

## P3 - LOW

- limited metadata disclosure
- minor temporary file cleanup deficiencies
- minor serving header weaknesses
- constrained edge cases

## P4 - HARDENING

- additional scanning, sandboxing, or observability recommendations without confirmed exploit paths

---

# 255. CONFIDENCE

Use:

```text
HIGH
MEDIUM
LOW
```

---

# 256. STATUS

Use:

```text
CONFIRMED
LIKELY
THEORETICAL
NOT VERIFIED
```

---

# 257. EVIDENCE TIER

Use:

```text
A - safely reproduced
B - complete executable upload-to-impact path
C - strong static/config evidence
D - partial/inferred
E - theoretical
```

---

# 258. CATEGORY

Use:

```text
TYPE VALIDATION
PATH TRAVERSAL
ARBITRARY FILE WRITE
ARBITRARY FILE READ
ACTIVE CONTENT
XSS
PARSER
SSRF
XXE
ARCHIVE / ZIP SLIP
DECOMPRESSION BOMB
RESOURCE EXHAUSTION
MALWARE
STORAGE AUTHORIZATION
PRESIGNED URL
CROSS-TENANT
RACE CONDITION
TEMP STORAGE
SERVING / DOWNLOAD
```

---

# 259. FALSE-POSITIVE PREVENTION

Before reporting P0/P1/P2 findings, verify:

1. upload endpoint is reachable
2. attacker holds required authentication and role
3. validation code path
4. actual storage location
5. actual serving origin
6. processing library behavior
7. file execution semantics
8. object and file authorization logic
9. infrastructure deployment behavior
10. reproducible impact

Do not infer vulnerabilities solely from extension allowlists.

---

# 260. DO NOT REPORT `.php` UPLOADS AS RCE IF THE SERVER CANNOT EXECUTE PHP

An active execution interpreter path must exist.

---

# 261. DO NOT AUTOMATICALLY REPORT SVG AS XSS

Depends on:

- inline, embed, object, img, or download context
- serving origin
- CSP restrictions
- sanitization logic

---

# 262. DO NOT REPORT PDF AS MALWARE MERELY BECAUSE IT IS A PDF

A realistic malicious content model must exist.

---

# 263. DO NOT DEMAND ANTIVIRUS AUTOMATICALLY

If an application merely stores private photos that are never downloaded by third parties:

antivirus scanning may not represent a core priority.

---

# 264. DO NOT TRUST CLIENT MIME TYPES

The client controls them completely.

---

# 265. DO NOT TRUST EXTENSIONS

Extensions are similarly attacker-controlled.

---

# 266. DO NOT TRUST MAGIC BYTES AS AN ABSOLUTE GUARANTEE

Polyglot and active content formats can circumvent simple magic byte checks.

---

# 267. DO NOT RELY ON UUIDS AS THE SOLE FILE AUTHORIZATION BARRIER

Knowledge of unguessable URLs does not replace a comprehensive authorization model unless explicitly designed as capability tokens.

---

# 268. DO NOT CONFINE VALIDATION TO THE FRONTEND

Backend and storage layers must strictly enforce validation rules.

---

# 269. DO NOT ADOPT OBJECT STORAGE MERELY FOR CHECKLIST COMPLIANCE

Local storage can be secure if properly isolated and aligned with architectural scale.

---

# 270. DO NOT MODIFY CODE

During the audit:

- do not delete files
- do not upload real malware
- do not attempt server takeovers
- do not fill disk storage
- do not query unauthorized internal services
- do not modify bucket ACLs

Use safe synthetic testing techniques.

---

# 271. OUTPUT - FILE_UPLOAD_SECURITY_AUDIT.md

Structure the final report as follows:

## 1. Executive Summary

- upload surfaces
- storage model
- serving model
- parser inventory
- top security risks

## 2. Upload Surface Inventory

## 3. Upload Lifecycle Map

## 4. Filename / Path Security Audit

## 5. Extension / MIME / Type Validation Audit

## 6. File Size / Count / Quota Audit

## 7. Multipart / Temp Storage Audit

## 8. Chunked Upload Audit

If relevant.

## 9. Presigned Upload Audit

If relevant.

## 10. Storage Security Audit

## 11. Public / Private Object Audit

## 12. Active Content / Same-Origin Audit

## 13. SVG / HTML / PDF Audit

## 14. Image Processing Audit

## 15. Video / Audio Processing Audit

## 16. Document Conversion Audit

## 17. Parser / Sandbox Audit

## 18. SSRF Through File Processing Audit

## 19. XML / XXE Audit

## 20. Archive / Zip Slip Audit

## 21. Decompression / Resource Exhaustion Audit

## 22. Malware Distribution Audit

## 23. Metadata / Stored XSS Audit

## 24. DB / Storage Consistency Audit

## 25. Delete / Retention Audit

## 26. Download / Preview Authorization Audit

## 27. CDN / Cache Audit

## 28. Remote URL Import Audit

## 29. CSV / Backup / Import Audit

## 30. Async Processing / Race Audit

## 31. Logging / Observability Audit

## 32. Security Test Coverage

## 33. Findings Summary

| ID | Severity | Upload surface | Category | Impact | Confidence | Status |
|---|---|---|---|---|---|---|

## 34. P0 Findings

## 35. P1 Findings

## 36. P2 Findings

## 37. P3 Findings

## 38. P4 Hardening

## 39. Things Done Well

## 40. Not Applicable

## 41. Not Verified

## 42. Remediation Roadmap

---

# 272. UPLOAD SURFACE MATRIX

| Feature | Types | Max size | Storage | Processing | Public |
|---|---|---:|---|---|---|

---

# 273. VALIDATION MATRIX

| Type | Extension | MIME | Magic | Parser validation | Result |
|---|---|---|---|---|---|

---

# 274. STORAGE MATRIX

| Upload | Storage | Object key source | Public | Encryption | Tenant scoped |
|---|---|---|---|---|---|

---

# 275. PROCESSOR MATRIX

| File type | Processor | Network access | Timeout | Memory bound | Isolation |
|---|---|---|---|---|---|

---

# 276. ARCHIVE MATRIX

| Format | Extraction | Traversal protection | Expanded-size limit | Symlink handling |
|---|---|---|---|---|

---

# 277. SECOND PASS - VALIDATION BYPASS HUNT

For each permitted file type, attempt mismatches:

```text
extension A
MIME B
magic C
actual content D
```

Determine which signals the backend genuinely relies upon.

---

# 278. SECOND PASS - ACTIVE CONTENT

For each upload type displayable in browsers, test:

- HTML
- SVG
- XML
- PDF

according to permitted types.

Determine:

- serving origin
- Content-Type
- Content-Disposition
- CSP headers

---

# 279. SECOND PASS - PATH ATTACKS

Probe filename and object key resolution with:

- traversal sequences
- absolute paths
- duplicate path separators
- encoded traversal tokens

strictly in test environments.

---

# 280. SECOND PASS - OVERWRITE PROBING

Attempt targeting:

- user's existing files
- third-party files
- static web assets
- predictable object keys

according to upload flows.

---

# 281. SECOND PASS - TEMPORARY STORAGE

Abort uploads at:

```text
25%
50%
99%
```

and inspect temporary file cleanup.

---

# 282. SECOND PASS - CONCURRENT UPLOADS

Initiate the maximum permitted concurrent uploads.

Monitor:

- memory usage
- disk consumption
- socket exhaustion
- temporary file accumulation

---

# 283. SECOND PASS - LARGE DIMENSIONS

Upload valid compressed image files with extreme pixel dimensions.

Monitor image decoder memory utilization.

---

# 284. SECOND PASS - ARCHIVE ATTACKS

Test controlled synthetic archives featuring:

- traversal path entries
- symlinks
- excessive entry counts
- high compression ratios

---

# 285. SECOND PASS - PARSER NETWORK REQUESTS

If processors support external references:

test with controlled URLs to verify if the server initiates network requests.

---

# 286. SECOND PASS - REMOTE IMPORTS

If URL imports are supported:

test:

```text
public URL
redirect
oversized response
slow response
internal-test target
```

without interacting with unauthorized external systems.

---

# 287. SECOND PASS - CROSS-USER FILES

User A uploads a private file.

User B attempts:

- viewing metadata
- previewing
- downloading
- generating thumbnails
- deleting
- requesting signed URLs

---

# 288. SECOND PASS - CROSS-TENANT FILES

Repeat cross-user testing across Tenant A and Tenant B boundaries.

---

# 289. SECOND PASS - PRESIGNED FLOWS

Attempt:

```text
request signed URL for unauthorized object key
```

and:

```text
reuse URL after expected expiry
```

---

# 290. SECOND PASS - CLEAN FILE OVERWRITING

Where scanning workflows exist:

```text
upload clean v1
↓
scan clean
↓
overwrite same key with v2
↓
request file
```

---

# 291. SECOND PASS - DELETION RACES

```text
processing completes
||
user deletes file
```

Determine whether deleted files can erroneously revert to READY or public states.

---

# 292. SECOND PASS - STORAGE FAILURES

Simulate storage write failures.

Verify whether database records falsely assert file readiness.

---

# 293. SECOND PASS - DATABASE FAILURES

Storage succeeds, but database metadata insertion fails.

Inspect:

- orphaned files
- cleanup mechanisms
- unintended public exposure

---

# 294. SECOND PASS - DOWNLOAD HEADERS

For active file types, inspect:

- Content-Type
- Content-Disposition
- X-Content-Type-Options: nosniff
- Cache-Control headers

---

# 295. SECOND PASS - METADATA XSS

Inject attacker-controlled strings into:

- filenames
- document titles
- EXIF metadata

and trace where attributes are rendered across the UI.

---

# 296. SECOND PASS - FILE VERSION RACES

If object keys can be reused:

verify that validation and scan results map strictly to the version currently served.

---

# 297. SECOND PASS - BACKUP RESTORATION

If supported:

test synthetic archives containing:

- unexpected path definitions
- foreign tenant identifiers
- incompatible schemas
- duplicate entities

without destructive production execution.

---

# 298. SECOND PASS - QUOTAS

Ask:

> Can an attacker incur significant storage or processing costs with minimal request volumes?

---

# 299. FINAL QUALITY GATE

Before issuing the final report, verify:

- all upload surfaces have been cataloged
- multipart forms are not assumed to be the sole upload mechanism
- original filenames are treated as attacker-controlled input
- path normalization mirrors actual operating system and runtime behaviors
- extensions, MIME types, and magic bytes are not individually treated as absolute proof
- backend and storage layers enforce limits rather than relying on frontend checks
- temporary file lifecycles and cleanup paths have been audited
- chunked and presigned workflows undergo ownership and cumulative size reviews
- direct object storage uploads do not become trusted prior to required server validation
- storage locations and serving origins have been mapped
- RCE findings are filed only when the server can genuinely execute the uploaded file
- SVG, HTML, and PDF findings depend on serving and rendering contexts
- file parsers are treated as untrusted input boundaries
- image dimension and decompression bomb risks are evaluated
- archive extraction routines enforce traversal, symlink, and expanded size boundaries
- file-based SSRF is evaluated where parsers fetch external resources
- malware scanning is recommended only where the product threat model justifies it
- deletion and public-to-private lifecycles account for CDN and storage caching
- preview, thumbnail, and derivative assets enforce authorization checks
- scanning verdicts bind strictly to the specific content version served
- remote URL imports include size, timeout, redirect, and SSRF analyses
- storage and database partial failure states have been reviewed
- metadata is tracked as second-order attacker input
- every P0/P1 finding features a complete upload-to-impact path
- P4 hardening recommendations are separated from confirmed exploit vectors

---

# FINAL RULE

Do not generate reports like:

> Check MIME types, limit file sizes, and scan files with an antivirus.

That is not a File Upload Security Audit.

I am looking for concrete defects such as:

```text
POST /avatar
↓
backend allows .svg
↓
file stored unchanged
↓
served from app.example.com/uploads/...
↓
browser opens SVG inline
↓
uploaded active content executes under trusted application origin
↓
stored XSS/account impact
```

or:

```text
multipart filename:
../../public/index.html

↓
backend:
join(uploadDir, originalFilename)

↓
no canonical containment check
↓
upload writes outside upload directory
↓
application file overwritten
```

or:

```text
ZIP import
↓
validator checks archive file itself
↓
extractor trusts entry names
↓
archive contains:
../../config/app.json

↓
entry written outside extraction directory
↓
arbitrary file overwrite
```

or:

```text
image upload limit:
5 MB

↓
attacker uploads 1 MB compressed image
↓
decoded dimensions:
50,000 x 50,000
↓
image processor allocates gigabytes of memory
↓
worker crashes
```

or:

```text
direct object-storage upload
↓
file marked CLEAN after scan
↓
same object key can still be overwritten
↓
attacker replaces clean object with malicious version
↓
database scan status remains CLEAN
↓
malicious content is served
```

or:

```text
GET /files/:id
↓
route checks authentication
↓
metadata loaded only by file ID
↓
no owner/tenant scope
↓
User B changes ID to User A's file
↓
private document disclosure
```

or:

```text
remote file import
↓
backend validates original host as public
↓
HTTP client follows redirect
↓
redirect points to internal service
↓
backend downloads internal response as "file"
↓
SSRF
```

or:

```text
upload succeeds to object storage
↓
database insert fails
↓
object remains in public bucket
↓
no metadata record exists
↓
normal app cleanup can no longer find it
↓
orphan sensitive public file persists
```

These are the file upload vulnerabilities you must uncover.

Reason through:

- filename
- type
- bytes
- size
- parser
- path
- storage
- origin
- authorization
- post-processing
- races
- cleanup
- serving

For every serious finding, you must be able to answer:

> Who is permitted to upload the file?

> What part of the file or metadata does the attacker control?

> What validation does the file undergo?

> Where is it physically or logically stored?

> Which parser processes it?

> Does the parser have network or filesystem access?

> How is the file subsequently served?

> Does it execute as active content in the browser?

> Can a user access another user's file?

> What happens if processing or storage fails between pipeline steps?

If server execution behavior cannot be confirmed:

**SERVER EXECUTION NOT VERIFIED.**

If parser or network semantics are not confirmed:

**PARSER BEHAVIOR NOT VERIFIED.**

If only a general hardening enhancement without a confirmed exploit path:

**P4 - HARDENING.**

It is far better to find 5 real upload, storage, parser, or serving exploit paths than to write 100 generic file security rules.

The objective is to produce a forensically precise File Upload Security Audit that translates directly into:

- upload regression test
- path containment fix
- content validation correction
- safe storage architecture
- active-content isolation
- parser sandboxing
- archive protection
- file authorization fix
- production upload hardening

分类与标签

编程开发、文件上传、应用安全、存储权限、文件解析

前往 AI 图片创作