offensive-parameter-pollution
v2026.11.11-fd814413 התקנות+3 ב-7 ימים11.2K כוכביםMITסונכרן לפני 13 שעות
התקנה
עדיין אין לכם את ה-CLI של NotHoly? התקינו אותו קודם.
$ curl -fsSL https://notholy.com/install.sh | sh$ notholy skills install snailsploit/offensive-parameter-pollutionנכתב אל ~/.notholy/skills אחרי בדיקת החתימה וה-SHA-256.
חתימהחתום, ed25519
חבילה2d5d52c9…a708d1e2
2d5d52c9e07c…76f8a708d1e2קובץ אחד · 6.1 KBסריקהנמוךממצא אחד
- קישורים לדומיינים חיצוניים
מקורgithub.com/SnailSploit/Claude-Red/tree/main/Skills/web/offensive-parameter-pollution@fd81441
הפריט הזה עדיין לא נכתב בעברית, ולכן הוא מוצג בשפה אחרת: English.
בעמוד הזה
Metadata
- Skill Name: parameter-pollution
- Folder: offensive-parameter-pollution
- Source: https://github.com/SnailSploit/offensive-checklist/blob/main/parameter-pollution.md
Description
HTTP parameter pollution (HPP) checklist: duplicate parameter injection, backend vs frontend parsing differences, WAF bypass via HPP, server-side vs client-side HPP, and practical exploitation patterns. Use when testing web applications for parameter handling flaws.
Trigger Phrases
Use this skill when the conversation involves any of:
parameter pollution, HTTP parameter pollution, HPP, duplicate parameter, WAF bypass, parsing differences, server-side HPP, client-side HPP, parameter injection
Instructions for Claude
When this skill is active:
- Load and apply the full methodology below as your operational checklist
- Follow steps in order unless the user specifies otherwise
- For each technique, consider applicability to the current target/context
- Track which checklist items have been completed
- Suggest next steps based on findings
Full Methodology
HTTP Parameter Pollution (HPP)
Mechanisms
HTTP Parameter Pollution (HPP) is a web attack technique that exploits how web applications and servers handle multiple occurrences of the same parameter name. When a web application receives duplicate parameters, different technologies process them differently:
flowchart TD
subgraph "HTTP Parameter Pollution"
A[Multiple occurrences of same parameter] --> B{Server Technology}
B -->|ASP.NET/IIS| C[Uses first occurrence]
B -->|PHP/Apache| D[Uses last occurrence]
B -->|JSP/Tomcat| E[Uses first occurrence]
B -->|Perl CGI| F[Concatenates with comma]
B -->|Python/Flask| G[Builds array of values]
B -->|Node.js/Express| H[Uses first occurrence]
endParameter Handling Behaviors
- ASP.NET/IIS: Uses the first occurrence of the parameter
- PHP/Apache: Uses the last occurrence of the parameter
- JSP/Tomcat: Uses the first occurrence of the parameter
- Perl CGI/Apache: Concatenates all occurrences with a comma delimiter
- Python/Flask: Builds an array of values
- Node.js/Express: Uses the first occurrence by default
Notes and modern caveats
- Node.js
expressuses eitherquerystring(first-wins) orqs(arrays/last-wins).app.set('query parser', 'extended')changes behavior. Many middlewares assumeparam[]=a¶m[]=bfor arrays; duplicates without[]can produce surprising results. - Spring MVC/Spring Boot binders often collect duplicates into lists; API gateways (Kong, APIGEE, NGINX, Cloudflare) may collapse/normalize differently than backends.
- JSON duplicate keys: most parsers accept last-wins; some gateways reject duplicates while backends accept, creating precedence gaps.
- Cookies: duplicate cookie names and comma/semicolon handling vary by proxies/agents.
HPP attacks leverage these inconsistencies in parameter handling across application layers, servers, proxies, and frameworks. Two main types of HPP exist:
- Server-side HPP: Exploiting the server's handling of multiple parameters
- Client-side HPP: Manipulating parameters that are later processed by client-side code
Hunt
Identifying HPP Vulnerabilities
sequenceDiagram
participant Attacker
participant WebApp
participant Backend
Attacker->>WebApp: Request with duplicate parameter<br/>param=safe¶m=malicious
Note over WebApp: Layer 1 processes first value
WebApp->>Backend: Forward request to backend
Note over Backend: Layer 2 processes last value
Backend->>WebApp: Process with malicious value
WebApp->>Attacker: ResponseTesting Parameter Handling
Identify forms and request parameters
Test duplicate parameters with different values:
text // Original request https://example.com/search?param=value1 // Test request https://example.com/search?param=value1¶m=value2Observe application behavior
Identify which value is used (first, last, concatenated)
Vulnerable Scenarios
- Parameter Overriding: Search for places where parameters might be overridden
- Request Proxies: Applications forwarding requests to other services
- Query String Processing: Applications that process query strings manually
- Multiple-Layer Processing: Applications where parameters pass through multiple layers
- OAuth/SAML Flows: Authentication flows where parameters may be manipulated
Testing Techniques
URL Parameter Pollution
# Original URL
https://target.com/page?parameter=original_value
# Polluted URL
https://target.com/page?parameter=original_value¶meter=malicious_valueForm Parameter Pollution
Intercept a legitimate form submission
Add duplicate parameters with different values:
text // Original POST body parameter=original_value // Modified POST body parameter=original_value¶meter=malicious_value
Hybrid Parameter Pollution
Combining parameters in both URL and POST body:
// URL
https://target.com/page?parameter=url_value
// POST body
parameter=body_valueJSON Parameter Pollution
Testing duplicate keys in JSON objects:
{
"parameter": "value1",
"parameter": "value2"
}Also test:
Cookie: role=user; role=admin
X-Role: user
X-Role: adminObserve which value the application trusts.
GraphQL Parameter Pollution
GraphQL queries can be polluted through aliasing, batch mutations, and duplicate variables:
# Alias pollution - bypass rate limits
query {
a: user(id: 1) {
name
email
}
b: user(id: 2) {
name
email
}
c: user(id: 3) {
name
email
}
# ... repeat to z or beyond
}
# Variable pollution
query ($id: Int!, $id: Int!) {
user(id: $id) {
name
}
}
# Batch mutation pollution
mutation {
a: redeemCoupon(code: "SAVE50") {
success
}
b: redeemCoupon(code: "SAVE50") {
success
}
c: redeemCoupon(code: "SAVE50") {
success
}
}WebSocket Parameter Pollution
WebSocket connections can carry polluted parameters in the upgrade request or message payloads:
GET /chat HTTP/1.1
Host: vulnerable.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Version: 13
# URL with polluted params
ws://vulnerable.com/chat?token=valid&token=malicious&room=1&room=admin// WebSocket message payload pollution
{
"action": "sendMessage",
"room": "public",
"room": "admin",
"message": "test"
}Parameter Array Notation Pollution
Different frameworks handle array notation differently, creating pollution opportunities:
# PHP - expects brackets
param[]=value1¶m[]=value2
# Express (qs parser) - bracket optional
param=value1¶m=value2
# Rails - numeric indices
param[0]=value1¶m[1]=value2
# Mixed notation confusion
param=single¶m[]=array1¶m[0]=indexedTesting strategy:
- Test with
param=a¶m=b(no brackets) - Test with
param[]=a¶m[]=b(array notation) - Test with
param[0]=a¶m[1]=b(indexed) - Mix notations to confuse parsers
Parameter Cloaking
Using encoding and case variations to bypass filters:
# URL encoding variations
param=value1&par%61m=value2
param=value1&PARAM=value2
# Double/triple encoding
param=value1&par%2561m=value2
# Unicode normalization
param=value1&pαram=value2 # Greek alpha instead of 'a'
# Null byte injection (legacy)
param=value1¶m%00=value2Vulnerabilities
Common HPP Vulnerabilities
graph LR
subgraph "HPP Attack Vectors"
A[HTTP Parameter Pollution] --> B[Access Control Bypass]
A --> C[Request Forgery Enhancement]
A --> D[Data Manipulation]
A --> E[API Vulnerabilities]
B --> B1[Parameter Override]
B --> B2[Permission Escalation]
C --> C1[CSRF Token Bypass]
C --> C2[SSRF Augmentation]
D --> D1[SQL Query Manipulation]
D --> D2[Filter Evasion]
E --> E1[Parameter Precedence]
E --> E2[OAuth Manipulation]
endAccess Control Bypass
- Parameter Override: Overriding security-related parameters
text https://example.com/admin?access=false&access=true - Permission Escalation: Adding administrative parameters
text https://example.com/profile?user=victim&user=admin
Request Forgery Enhancement
- CSRF Token Bypass: Duplicating anti-CSRF tokens
text https://example.com/transfer?token=valid_token&token=random_value&amount=1000 - SSRF Augmentation: Overriding restricted URLs
text https://example.com/fetch?url=safe.com&url=internal.server
Data Manipulation
- SQL Query Manipulation: Influencing SQL queries
text https://example.com/products?category=1&category=1 OR 1=1 - Filter Evasion: Bypassing input filters
text https://example.com/search?q=safe_value&q=<script>alert(1)</script>
API Vulnerabilities
- Parameter Precedence Confusion: Different parameter precedence between API gateway and backend
- GraphQL Parameter Pollution: Duplicate variables in GraphQL queries
- OAuth Parameter Manipulation: Manipulating OAuth redirect flows
- Header/Cookie Pollution: Conflicting header values across CDN → WAF → app layers
Impact Scenarios
Authentication Bypass
# Application authenticates using the first parameter but authorizes using the last
https://example.com/login?role=user&role=adminWAF Bypass
# WAF checks the first parameter, backend processes the last
https://example.com/search?q=safe&q=<script>alert(1)</script>XML External Entity (XXE) via HPP
# Bypassing XML filtering by parameter pollution
https://example.com/upload?xml=safe&xml=<!DOCTYPE test [ <!ENTITY xxe SYSTEM "file:///etc/passwd"> ]>API Gateway vs Backend Precedence
# Gateway picks first id, backend picks last id -> IDOR/AC bypass
/api/user?id=123&id=999Methodologies
Tools
- Burp Suite Pro: Parameter pollution testing via Repeater and Intruder
- OWASP ZAP: HTTP fuzzer for parameter testing
- Param Miner: Extension for discovering hidden parameters
- HPP Finder: Specialized tool for HPP vulnerability detection
- Burp Repeater (Parallel): Validate precedence across layers quickly
- Schemathesis: Fuzz OpenAPI-defined endpoints for duplicate-field handling
Testing Methodology
flowchart TD
A[HPP Testing Methodology] --> B[Initial Discovery]
A --> C[Exploit Development]
A --> D[Impact Assessment]
B --> B1[Map application parameters]
B --> B2[Test duplicate parameters]
B --> B3[Document behavior]
C --> C1[Access control testing]
C --> C2[Security control bypass]
C --> C3[API security testing]
D --> D1[Authentication bypass]
D --> D2[Authorization bypass]
D --> D3[Data manipulation]Initial Discovery
- Map all application parameters (URL, form, cookie, header)
- Test each parameter with duplicates to observe behavior
- Document how different application components handle parameter duplication
Exploiting HPP for Web Application Testing
Access Control Testing:
text # Test privileged parameter override https://example.com/admin?admin=false&admin=true # Test user context override https://example.com/profile?id=attacker&id=victimSecurity Control Bypass:
text # Test CSRF token pollution token=legitimate&token=fake # Test parameter validation bypass param=valid_value¶m=malicious_valueAPI Security Testing:
text # Test API parameter handling /api/v1/user?id=123&id=456 # Test with different content types Content-Type: application/json {"id": "123", "id": "456"}HTTP Request Smuggling via HPP:
text # Testing inconsistent interpretation Transfer-Encoding: chunked Transfer-Encoding: identityHeader/Cookie Pollution:
Cookie: session=abc; session=attacker
X-Forwarded-Proto: http
X-Forwarded-Proto: httpsReal-World Test Cases
E-commerce Application Testing
# Price manipulation
https://shop.com/checkout?price=100&price=1
# Quantity override
https://shop.com/cart?quantity=1&quantity=100Banking Application Testing
# Amount parameter pollution
https://bank.com/transfer?amount=100&amount=10000
# Recipient override
https://bank.com/transfer?to=legitimate&to=attackerCMS Admin Testing
# Permission bypass
https://cms.com/edit?permission=read&permission=write
# User impersonation
https://cms.com/admin?user=admin&user=victimSocial Sharing Button Parameter Pollution
A specific case of parameter pollution that affects social sharing functionality:
Testing Methodology:
text # Original share URL https://target.com/article # Polluted share URL https://target.com/article?u=https://attacker.com&text=malicious_textCommon Parameters:
uorurl: The URL to be sharedtext: Custom text for the sharetitle: Title of the shared contentdescription: Description for the shared content
Impact:
- Redirect users to malicious sites
- Modify shared content
- Social engineering attacks
- Brand reputation damage
Testing Steps:
- Identify social sharing functionality
- Analyze original share parameters
- Append malicious parameters
- Test each social platform separately
- Verify if malicious content appears in share preview
Real-World Cases and CVEs
Notable Parameter Pollution Vulnerabilities
CVE-2021-41773 - Apache HTTP Server Path Traversal:
- Parameter pollution in URL path normalization
- Multiple encoded path segments bypassed access controls
- Impact: Remote code execution via CGI scripts
CVE-2018-8033 - Apache OFBiz:
- Parameter pollution in authentication bypass
- Duplicate parameters in login form bypassed security checks
- Impact: Administrative access without credentials
HPP in OAuth Implementations (Multiple Vendors):
- Duplicate
redirect_uriparameters in OAuth flows - Gateway checked first parameter, backend used last
- Impact: Account takeover via malicious redirect
- Duplicate
API Gateway vs Backend Precedence (Bug Bounty):
- AWS API Gateway processed first
idparameter - Backend Lambda function processed last
idparameter - Impact: IDOR allowing access to other users' data
- AWS API Gateway processed first
GraphQL Rate Limit Bypass (Multiple Platforms):
- Aliased queries bypassed per-query rate limits
- 100+ identical operations in single request
- Impact: Account enumeration, resource exhaustion
WAF Bypass via HPP (Generic):
- WAF inspected first parameter for XSS/SQLi
- Backend processed last parameter
- Impact: Complete WAF bypass for injection attacks
Impact Ratings
- Critical: HPP enables authentication/authorization bypass or RCE
- High: HPP allows WAF bypass, payment manipulation, or privilege escalation
- Medium: HPP bypasses rate limiting or validation controls
- Low: HPP causes logic errors with minimal security impact
Common Bug Bounty Targets
- E-commerce checkout flows (price/quantity parameters)
- OAuth/SAML redirect parameters
- API endpoints with pagination/filtering
- File upload with filename/path parameters
- Social sharing functionality
- Payment processing integrations
- Multi-step wizards/forms
Remediation Recommendations
- Consistent Parameter Handling: Implement consistent handling across all application layers
- Parameter Validation: Validate parameters before processing
- Framework Awareness: Understand how your framework handles duplicate parameters
- Web Application Firewall: Configure WAF to detect parameter pollution attempts
- API Gateway Rules: Implement rules to reject duplicate parameters
- Canonicalization: Convert parameters to a standard form before processing
- Schema Enforcement: Use JSON Schema/OpenAPI validation to reject duplicates and unexpected fields
- Drop Duplicates at the Edge: Normalize parameters at CDN/API gateway and log events
- Explicit Parser Settings: e.g., in Express set a custom query parser and explicitly forbid duplicates without
[]suffix for arrays - GraphQL Query Complexity Limits: Enforce maximum query depth and alias counts
- WebSocket Frame Validation: Parse and validate WS message structures consistently with HTTP parameter handling
הקבצים בגרסה הזו
- SKILL.md16.4 KB
הרשאות
| הרשאה | הוצהר | נמצא בסריקה |
|---|---|---|
| קורא קבצים | לא | לא |
| כותב קבצים | כן | כן |
| מריץ פקודות shell | לא | לא |
| משתמש ברשת | כן | כן |
| משתמש במחברים | לא | לא |
| שולט בדפדפן | לא | לא |
ממצאי הסריקה
נבדק ב-13 בנוב׳ 2026
- מידעקישור · קישורים לדומיינים חיצוניים
סריקה נקייה מורידה את הסיכון, אבל לא מוכיחה שהחבילה בטוחה. כדאי לקרוא מה מתקינים.
| גרסה | פורסמה | Commit | SHA-256 | חתימה | שינוי בהרשאות |
|---|---|---|---|---|---|
| v2026.11.11-fd81441 | 13 בנוב׳ 2026 | fd81441 | 2d5d52c9 | חתומה | – |
עוד מ-SnailSploit
הכול מהמפרסם הזהעוד בקטגוריה Web ו-bug bounty
לקטגוריה- web-ssrfnoorqureshi/web-ssrf6
- src-hunterzhaoxuya520/src-hunter5
- owasp-top10-analysissecurityskills/owasp-top10-analysis5
- testing-for-xml-injection-vulnerabilitiesmukul975/testing-for-xml-injection-vulnerabilities5
- source-review-techniqueaeondave/source-review-technique5
- web-cache-poisoningnoorqureshi/web-cache-poisoning5
שאלו כל מה שהסקופ מאפשר.
יוצרים חשבון, מוסיפים קרדיטים ושואלים את השאלה הראשונה בצ׳אט או בטרמינל.
- 1/3
יצירת חשבון
פרטי או חברה. אפשר לעבור לחשבון חברה אחר כך בלי לאבד יתרה או מפתחות.
פרטיחברה - 2/3
הוספת קרדיטים
בכרטיס אשראי. תשלום לפי טוקן, בלי מנוי.
$5.00טעינה מינימלית - 3/3
שאלה ראשונה
בצ׳אט, או להתקין את ה-CLI ולהריץ notholy login בטרמינל.
$ notholy login