Prompt
How do I secure file upload endpoints with a WAF?
Latest observation
Securing file upload endpoints with a WAF is mostly about reducing attack surface, validating intent, and limiting what uploaded files can do. A WAF helps, but it should be treated as one layer, not the whole solution.
1) Put strict controls on what can be uploaded
Configure the WAF to enforce:
- Allowed file types only: e.g.
.jpg,.png,.pdf - Allowed MIME types only, but don’t trust MIME alone
- Maximum file size and request body size
- Maximum number of files per request
- Expected upload paths only: block uploads to unexpected endpoints
If your WAF supports it, create rules that reject:
- Double extensions:
file.jpg.php - Dangerous extensions:
.php,.jsp,.aspx,.exe,.js,.sh, etc. - Archive files if not needed:
.zip,.rar,.7z - Files with null bytes or odd encodings in names
2) Inspect filenames and metadata
Use WAF rules to block suspicious filename patterns:
- Path traversal:
../,..\ - Absolute paths:
/etc/passwd,C:\ - Encoded traversal:
%2e%2e%2f,%252e%252e%252f - Special characters and control chars
- Long or repetitive filenames
Also validate:
- File name length
- Character set
- Presence of a valid extension matching policy
3) Block common upload bypass tricks
Attackers often try to bypass upload filters using:
- MIME spoofing
- Polyglot files
- Content-type mismatches
- Chunked encoding abuse
- Multipart boundary manipulation
- Compression bombs
- Unicode normalization tricks
- Double URL encoding
- Mixed separators and case changes
A WAF can help by normalizing inputs and matching on the normalized form.
4) Use positive security rules for multipart requests
For upload endpoints, prefer allow-list rules over generic signatures:
- Only allow
POSTorPUTif required - Only allow
multipart/form-dataif that’s the expected format - Only permit known field names, if your WAF supports it
- Reject unexpected parameters
- Restrict the number of multipart parts
5) Scan uploaded content before storage or processing
A WAF can’t reliably determine whether a file is malicious. Pair it with:
- Antivirus / malware scanning
- File type detection by magic bytes
- Content disarm and reconstruction (CDR) for Office/PDF files
- Sandboxing for high-risk document types
- Image re-encoding to strip malicious payloads from images
If a file is suspicious, quarantine it rather than rejecting it blindly if your business process allows review.
6) Prevent script execution from upload locations
This is critical and often more important than the WAF itself:
- Store uploads outside the web root
- If they must be web-accessible, disable script execution in that directory
- Serve files from a separate domain or bucket with no executable handling
- Use signed URLs or controlled download endpoints
A WAF can reduce bad uploads, but the server should never execute uploaded files.
7) Protect the download path too
Uploads can become dangerous on retrieval:
- Set correct
Content-Disposition: attachment - Force safe
Content-Type - Prevent inline rendering of active content when possible
- Ensure uploaded HTML, SVG, JS, and office macros are never executed in the browser context
8) Rate limit and abuse-limit uploads
Apply WAF protections for:
- Request rate limits per IP/user/token
- Burst control
- Concurrent upload limits
- Account-based quotas
- Geo/IP reputation rules if appropriate
This helps against brute-force probing and resource exhaustion.
9) Log and alert on suspicious upload activity
Log:
- User/account ID
- IP and user agent
- Endpoint
- Filename
- MIME type
- File size
- WAF rule matched
- Outcome: allowed, blocked, quarantined
Alert on:
- Repeated blocked attempts
- High-volume uploads
- Attempts to upload executable/script types
- Encoded traversal or payload obfuscation patterns
10) Don’t rely on client-side checks
WAF and server-side validation must be authoritative. Client-side file type restrictions are only usability hints and are easy to bypass.
Good baseline WAF policy for uploads
A practical starting point:
- Allow only authenticated users
- Allow only
POST /upload - Require
multipart/form-data - Max body size enforced
- Allow only specific file extensions
- Block traversal patterns and dangerous encodings
- Block executable and script extensions
- Limit multipart parts and file count
- Rate limit per user/IP
- Send files to malware scanning/quarantine
- Store outside web root, no execution permissions
Important caveat
A WAF cannot fully validate file safety. For example:
- A
.pdfmay still contain malicious JavaScript - A
.jpgmay be a polyglot or contain hidden payloads - A
.docmmay carry macros - Archive contents can hide dangerous nested files
So the safest approach is: WAF + server-side validation + malware scanning + safe storage + safe serving
If you want, I can also give you:
- a WAF rule checklist,
- example rules for ModSecurity / OWASP CRS, or
- a cloud WAF setup for AWS WAF, Cloudflare, or Azure Front Door.