Jul 29, 2026·6 min read·107 visits
Prebid Server versions prior to 4.4.0 fail to validate or sanitize dynamic host and subdomain parameters within several bidder adapters. This allows unauthenticated remote attackers to manipulate the destination of outbound HTTP requests by supplying control characters in OpenRTB requests.
CVE-2026-54735 is a critical Server-Side Request Forgery (SSRF) vulnerability in Prebid Server's bidder adapters, allowing unauthenticated remote attackers to route HTTP requests to arbitrary locations, including internal local host loopbacks and cloud provider metadata endpoints.
Prebid Server is a cloud-based server-side header bidding platform designed to execute real-time ad auctions. To fetch bids, it communicates with multiple downstream advertising endpoints through dedicated bidder adapters. The application exposes endpoints like /openrtb2/auction to ingest publisher-supplied OpenRTB bid request structures.
Prior to version 4.4.0, the server-side request architecture did not enforce proper security boundaries on parameters provided within the bid request object. Specifically, multiple bidder adapters accepted dynamically configured connection endpoints, subdomains, and hostnames directly from unauthenticated API clients.
Because these adapters trusted client-supplied input without parsing or validation, they allowed attackers to manipulate outbound transport requests. The resulting Server-Side Request Forgery (SSRF) vulnerability, tracked as CVE-2026-54735, carries a CVSS base score of 10.0 and allows unauthenticated remote attackers to control the target authority of internal outbound HTTP calls.
The root cause of CVE-2026-54735 lies in the handling of dynamic bidder-specific parameters inside the OpenRTB imp[].ext.<bidder> path. Certain bidder adapters require custom routing parameters, such as host, account, zone, endpoint, or pbsHost, to dynamically direct bid queries to partner-specific geographic clusters or instances.
During the request-building phase, affected adapters used Go-based macro expansion or simple string concatenation to construct outbound target URLs. The core implementation invoked functions like macros.ResolveMacros with the user-supplied string directly populated into the template. No validation or character-class restriction was enforced on these string parameters before their insertion into the URL template.
When an adapter processes a template like https://{{.Host}}.bidding-service.com/rtb, the parser expects a simple subdomain. However, if the Host value contains path-traversal characters, query separators, or fragment specifiers, the underlying URL parser redirects the destination authority. Characters like /, ?, #, or @ allow an attacker to redefine the protocol host and path components of the generated URL, completely overriding the intended destination.
The patch introduced a defense-in-depth approach spanning strict regular expression validation and JSON schema restrictions. The core security logic was added to a new helper module in util/urlutil/security.go to provide deterministic validation of host strings.
package urlutil
import "regexp"
// safeHostPattern restricts host strings to alphanumeric characters, dots, and hyphens,
// with an optional port number suffix.
var safeHostPattern = regexp.MustCompile(`^[a-zA-Z0-9.-]+(:[0-9]+)?$`)
// IsSafeHost evaluates if the input contains only valid domain/IP and port syntax.
// It rejects characters like '/', '?', '#', '@', or protocol schemes.
func IsSafeHost(host string) bool {
return safeHostPattern.MatchString(host)
}This validation pattern prevents any injection of control characters. Individual bidder adapters were refactored to intercept input. For example, the AcuityAds adapter in adapters/acuityads/acuityads.go was updated to reject requests before resolving the endpoint macro.
// adapters/acuityads/acuityads.go
func (a *AcuityAdsAdapter) buildEndpointURL(params *openrtb_ext.ExtAcuityAds) (string, error) {
+ if !urlutil.IsSafeHost(params.Host) {
+ return "", &errortypes.BadInput{Message: "Invalid Host"}
+ }
endpointParams := macros.EndpointTemplateParams{Host: params.Host, AccountID: params.AccountID}
return macros.ResolveMacros(a.endpoint, endpointParams)
}Additionally, JSON schemas were updated to block invalid inputs at the initial parsing layer. In static/bidder-params/acuityads.json, the property definition was hardened.
{
"host": {
"type": "string",
"description": "Network host to send request",
"minLength": 1,
"pattern": "^[a-zA-Z0-9.-]+(:[0-9]+)?$"
}
}Exploitation of CVE-2026-54735 is straightforward and does not require active authentication sessions. An attacker targets the /openrtb2/auction endpoint of a vulnerable Prebid Server deployment and submits an OpenRTB payload referencing an affected adapter.
By supplying an input value like evil.com/path?redirect=http://attacker.com# for the host parameter of the acuityads adapter, the resulting outbound request is redirected to the attacker's server. The trailing path .bidding-service.com/rtb is discarded because the fragment character # designates it as a client-side fragment rather than part of the request path.
An alternative variation leverages the vulnerability to query local endpoints or metadata services. If the host parameter is set to localhost:8080, the Prebid Server's outbound HTTP client will target internal administrative services. Because Prebid Server is often deployed inside container environments, this enables host reconnaissance and connection manipulation.
The impact of this vulnerability is critical, leading to a complete compromise of the outbound trust boundary. A successful attack allows unauthenticated remote request forgery against any network service reachable by the Prebid Server instance.
In containerized environments such as Kubernetes or cloud provider instances (AWS, GCP, Azure), the Prebid Server can be leveraged to query the cloud metadata service. On AWS, for instance, targeting 169.254.169.254 could expose sensitive temporary credentials, IAM roles, and configuration parameters if the IMDSv1 interface is enabled.
Furthermore, this vulnerability acts as a pipeline to bypass network perimeters. Attackers can perform internal port scanning, trigger state changes on internal microservices that lack authentication, or exfiltrate local environment information. Due to the wide distribution of Prebid Server in the ad tech ecosystem, the potential exposure across ad exchanges is broad.
While the introduced validation checks successfully mitigate syntax injection vectors, they are not a complete security solution against all forms of SSRF. The regular expression check ^[a-zA-Z0-9.-]+(:[0-9]+)?$ evaluates the syntax of the input, but it does not resolve the hostname to verify its target network.
Consequently, the patch does not prevent an attacker from supplying an authorized syntax that points to an unauthorized destination. Inputting 127.0.0.1, localhost, or private network addresses (such as 10.0.0.1) is syntactically valid under this regex and will pass the Go and JSON schema checks.
To guarantee complete protection, the application layer checks must be complemented by transport-layer restrictions. Without strict IP blocklisting on the outbound dialer of the Go HTTP client, DNS rebinding attacks and direct internal routing are still possible. Security teams must ensure that outbound network connections are restricted at the operating system or gateway level.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
prebid-server prebid | < 4.4.0 | 4.4.0 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-918 |
| Attack Vector | Network |
| CVSS v3.1 | 10.0 (Critical) |
| Exploit Status | Proof of Concept available |
| CISA KEV Status | Not listed |
| Impact | Server-Side Request Forgery, Local Host Enumeration, Credential Disclosure |
The web application receives a user-supplied URL or host parameters, fails to properly validate, restrict, or sanitize the input, and subsequently issues an outbound request to that destination.
CVE-2026-63672 is an open redirect and insecure Identity Provider (IdP) selection vulnerability in the SAML Single Sign-On (SSO) authentication module of EGroupware. In affected versions, the login method in api/src/Auth/Saml.php accepts an unauthenticated HTTP request parameter (idp) and passes it to the underlying SimpleSAMLphp library after only verifying that the string begins with https://. Because the input is not validated against the application's configured whitelist of trusted identity providers, an attacker can construct a malicious link that redirects authenticating users to an arbitrary, attacker-controlled SAML Identity Provider.
CVE-2026-62336 (GHSA-xhv5-8fpq-g7hf) is a high-severity local privilege escalation, arbitrary file overwrite, and denial-of-service vulnerability in qbee-agent, the client daemon for the qbee.io IoT device management platform. Prior to version 2026.27, the root-privileged agent failed to validate path components against symbolic links during directory creation and file opening operations in app/configuration/file_manager.go. Local unprivileged users can exploit this flaw by planting symlinks in user-controlled configuration paths or predictable temporary staging locations, causing the daemon to overwrite, truncate, or change ownership of sensitive root-owned system files.
CVE-2026-110782 is an authentication bypass and cryptographic signature verification failure in the SimpleSAMLphp SAML2 library (simplesamlphp/saml2). Resulting from an incomplete fix for CVE-2026-49283, the HTTP-Artifact binding implementation verifies the outer ArtifactResponse signature but unconditionally returns unsigned embedded SAML Responses without verifying signatures or validating that the embedded issuer matches the artifact issuer. In multi-IdP federation environments, an attacker controlling one trusted Identity Provider (IdP) can forge arbitrary identity assertions claiming to originate from another trusted IdP.
CVE-2026-110789 (GHSA-rvfr-cqwq-rc4j) is a high-severity pre-authentication Denial of Service (DoS) vulnerability in the @libp2p/crypto package of the js-libp2p networking stack prior to version 5.1.22. An improper length validation flaw in the ASN.1 DER decoder allows an unauthenticated remote peer to send a crafted RSA public key during the Identify protocol exchange, forcing the parser into a synchronous loop over attacker-claimed length values. Because this loop executes within a single Node.js event-loop tick prior to identity or cryptographic signature verification, it bypasses application timeouts, stalls the event loop for 4 to 5 seconds per connection, and transiently allocates up to 2 GB of memory.
CVE-2026-119793 (GHSA-x2vm-cf3p-m2w8) is a resource consumption vulnerability in the @libp2p/gossipsub module of the js-libp2p ecosystem. Prior to @libp2p/gossipsub version 17.0.0 and js-libp2p version 3.3.9, the GossipSub implementation processed incoming subscription RPC messages without enforcing per-peer or global limits on the number or cumulative byte size of subscribed topics in its default configuration. An unauthenticated remote peer can exploit this flaw by streaming continuous batches of unique topic subscription strings over an established connection, causing unbounded growth of the internal topics Map. This leads to V8 heap exhaustion (Out-Of-Memory crash) and severe CPU starvation on the main event loop during peer disconnection teardown.
Filament Curator, a media picker plugin for Filament panels in Laravel applications, contains a Stored Cross-Site Scripting (XSS) vulnerability in versions prior to 3.7.9, 4.1.2, and 5.1.2. The application accepts image/svg+xml uploads by default and stores them on disk without stripping executable XML markup. When a panel user opens an uploaded SVG via the View action, the file renders as a top-level document in the browser, executing embedded JavaScript within the origin of the Filament application.