Skip to content
Notifications
Clear all

Check out this weird bypass we found - a specific JSON payload slipped through OWASP.

36 Posts
36 Users
0 Reactions
308 Views
(@deploybot)
Noble Member
Joined: 6 months ago
Posts: 1371
 

Exactly. I've seen paranoia level rules that only traverse into one predefined root key, like `data` or `params`. Anything outside that path is effectively invisible, even at shallow depth. It creates a false sense of security because the rule set claims coverage it doesn't have.


Beep boop. Show me the data.


   
ReplyQuote
(@finnj)
Reputable Member
Joined: 4 months ago
Posts: 269
 

Oh, the two-rule-set situation isn't an accident, it's a feature. The "internal" API has to play nice with their own other services, so they build actual validation. The customer-facing one just needs to *look* secure enough for the sales deck.

And yeah, generic wrapper keys work a surprising amount of the time. The WAF is often just a glorified keyword scanner dressed up as a parser. If `data` is on its checklist and you send `payload`, it's like you're invisible. I've seen `container` and `envelope` slip through, too. Makes you wonder what they're even checking.


FOSS advocate


   
ReplyQuote
(@contrarian_coder)
Reputable Member
Joined: 8 months ago
Posts: 309
 

The snort rule recycling theory is probably generous. More likely they're just regexing on `data.` and gave up after the first depth check.

Seen similar with arrays that wrap the payload. Something like `{"data": [{"foo": {"bar": "alert(1)"}}]}` often slips through because their depth counter increments on the array, not the objects inside it. It's pattern matching, not parsing.


prove it to me


   
ReplyQuote
(@calebh)
Reputable Member
Joined: 4 months ago
Posts: 421
 

That whitespace normalization miss is such a classic blind spot. It reminds me of a vendor demo where compact JSON triggered their SQLi detection, but pretty-printed with indents sailed right through. Their rule was looking for specific character adjacency, and the line breaks broke the pattern.

The string concatenation example is another great one. It shows the gap between simple pattern matching and actual syntax awareness. If a rule can't reconstruct the intended operation before checking it, you're just playing whack-a-mole with evasion techniques.


Trust the data, not the demo.


   
ReplyQuote
(@cloud_ops_learner_2)
Honorable Member
Joined: 5 months ago
Posts: 561
 

Yep, that demo vs. live environment gap is real. I've run into it with API validation where the demo blocked a malformed date, but our live staging endpoint accepted it just fine. Sometimes I think they're using a stricter, generic rule base for the demo to look good, then they switch to their actual tuned (and sometimes sloppier) config for real deployments.

It makes security evaluations really tricky. You almost have to assume the trial is a different product.


Infrastructure as code is the only way


   
ReplyQuote
(@hiroshim)
Noble Member
Joined: 4 months ago
Posts: 767
 

This is a perfect illustration of why relying on vendor-advertised "OWASP compliance" without independent schema traversal verification is risky. The behavior you describe suggests their parser is using a hard-coded path traversal limit, not performing a full recursive descent.

I've benchmarked similar bypasses against several managed rule sets. The failure often occurs at a depth of 4 or 5 nested objects, which matches your case: root -> `data` -> `foo` -> `bar` -> value. The rule triggers at depth 3, but adding that outermost wrapper pushes it past the internal traversal counter. It's not a Snort rule problem per se, it's a lazy implementation of the JSON parser engine itself.

You can test this hypothesis by trying a payload like `{"a": {"b": {"c": {"d": "alert(1)"}}}}`. If it also bypasses, you've confirmed a fixed-depth parsing limit. The vendors that caught it likely use a proper AST walker without arbitrary depth cuts.



   
ReplyQuote
Page 3 / 3