Skip to main content

Boruta CVE-2026-54885

| EUVDEUVD-2026-51143 MEDIUM
Server-Side Request Forgery (SSRF) (CWE-918)
2026-07-30 EEF
6.9
CVSS 4.0 · Vendor: EEF
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Send OAuth authorization request with crafted request_uri
  2. Delivery
    Boruta fetches URI via unauthenticated Finch HTTP call
  3. Exploit
    Server reaches internal target (IMDS, internal API, RFC 1918 host)
  4. Execution
    Attacker-controlled server receives or Boruta processes internal response
  5. Impact
    Exfiltrate internal metadata or credentials

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V4 - API and Web Service URL allowlisting, SSRF prevention
MITRE ATT&CK

2 techniques across 2 tactics: Initial Access, Credential Access

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Path 1 (OAuth request_uri): Requires access to the OAuth authorization endpoint and the ability to submit an authorization request with a request_uri parameter. This path is unauthenticated and available against any deployment supporting OAuth 2.0 authorization code flow with request_uri; one code clause does not restrict URI scheme, permitting non-HTTP schemes. Path 2 (OpenID Connect dynamic client registration jwks_uri): Requires dynamic client registration to be enabled - this is a configurable feature, not universally enabled by default, but when active requires no authentication or prior client credentials. Path 3 (jwks_uri refresh): Requires that an attacker has previously registered or modified a client with a malicious jwks_uri, meaning prior authenticated access or exploitation of path 2 is a prerequisite. Shared limiting factor across all paths: the Boruta server must have network reachability to the target URI from its host environment; attackers cannot reach targets the server itself cannot reach.

Impact

The CVSS 4.0 score of 6.9 (Medium) correctly models SSRF impact: the vulnerable system (the Boruta server) itself has no confidentiality, integrity, or availability impact (VC:N/VI:N/VA:N), but subsequent systems reachable from the Boruta host carry Low confidentiality and integrity impact (SC:L/SI:L). Real-world severity is highly deployment-context-dependent. In cloud-hosted environments where the Boruta host can reach the Instance Metadata Service (IMDS) at 169.254.169.254, an unauthenticated attacker could potentially retrieve IAM credentials or instance identity documents, elevating practical impact well beyond the rated score. The no-auth, no-complexity, network-accessible nature of path 1 (request_uri) is particularly concerning because it requires no prior client relationship. Path 2 (dynamic client registration) is similarly unauthenticated if the feature is enabled but is not universally deployed. Path 3 (jwks_uri refresh) requires prior client registration, reducing its unauthenticated exposure. No KEV listing and no EPSS data were provided; no public exploit code has been identified. The three independent code paths mean that remediating one path without upgrading leaves the others open.

Exploit ScenarioDerived

An unauthenticated attacker sends an OAuth 2.0 authorization request to the Boruta server's authorization endpoint with the request_uri parameter set to http://169.254.169.254/latest/meta-data/iam/security-credentials/ - a cloud IMDS endpoint reachable from the server host. Boruta's fetch_unsigned_request/1 invokes Finch to retrieve that URI without any host or IP validation, and the IMDS response (containing IAM role credentials or instance metadata) is processed by the server. Alternatively, on deployments with dynamic client registration enabled, the attacker registers a new OIDC client specifying a jwks_uri pointing to an internal service, causing the server to probe that endpoint during registration. No public proof-of-concept code has been identified at time of analysis.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.4% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Jul 30, 2026

Server-Side Request Forgery in Boruta (malach-it/boruta_auth versions 2.3.2 through 2.3.6) enables unauthenticated remote attackers to force the OAuth/OpenID authorization server to issue outbound HTTP requests to arbitrary attacker-controlled URIs, including cloud metadata endpoints (e.g., AWS IMDS at 169.254.169.254), internal APIs, and RFC 1918 network services. Three distinct code paths - OAuth request_uri handling, OpenID Connect dynamic client registration jwks_uri, and scheduled jwks_uri refresh - all invoke Elixir's Finch HTTP client against caller-supplied URIs with no host allowlist, no private IP rejection, no redirect constraint, and no response size cap. No public exploit has been identified at time of analysis; a vendor patch is available in version 2.3.7.

RemediationAI

Upgrade boruta_auth to version 2.3.7 or later, which introduces the Boruta.HttpClient module enforcing per-client outbound request allowlists via the new trusted_hosts (list of allowed hostnames) and trusted_authorities (trusted CA string) fields on the Client schema. After upgrading, operators must configure these fields on each client - the patched library rejects outbound requests from clients with neither field populated, returning an error rather than silently proceeding. Patch commits 001e3dc5c259e67c6f907e98867eda4141c96d0d and 95fb10b78129355e475681f324c9a01ef0af2be5 are available in the malach-it/boruta_auth repository. If immediate upgrade is not possible, disable OpenID Connect dynamic client registration to close the unauthenticated jwks_uri path (path 2), though this does not address the OAuth request_uri path (path 1) or the jwks_uri refresh path (path 3). As a compensating network control, apply egress filtering at the host, container, or cloud security group level to block outbound HTTP/HTTPS requests to RFC 1918 ranges (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16), loopback (127.0.0.0/8), and link-local ranges (169.254.0.0/16, including AWS IMDS); note that this does not address SSRF against external attacker-controlled infrastructure. Advisory: https://github.com/malach-it/boruta_auth/security/advisories/GHSA-5q9h-vf5j-fr2g.

Affected VersionsENISA

boruta 2.3.2 <2.3.7
boruta 15455b86206e0370eabd64c1856a5c996b436455 <*

Affected Packages

euvd boruta fix: 2.3.7

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

Boruta is an Elixir library (hex package boruta_auth) implementing OAuth 2.0 and OpenID Connect for building authorization servers. The root cause is CWE-918 (Server-Side Request Forgery): three code paths in the library directly pass caller-supplied URI strings to Finch.build(:get, uri) |> Finch.request(OpenIDHttpClient) with validation limited to URI parseability. The three paths are: (1) Boruta.Oauth.Request.Base.fetch_unsigned_request/1 in lib/boruta/oauth/request/base.ex, which dereferences the OAuth 2.0 request_uri parameter - notably one clause does not restrict the URI scheme to http/https, permitting file:// or other schemes; (2) Boruta.Openid.parse_registration_params/2 in lib/boruta/openid.ex, which fetches the jwks_uri submitted during OpenID Connect dynamic client registration; and (3) Boruta.Ecto.Clients.refresh_jwk_from_jwks_uri/1 in lib/boruta/adapters/ecto/clients.ex, which re-fetches a stored jwks_uri for key refresh. CPE cpe:2.3:a:malach-it:boruta covers versions 2.3.2 through 2.3.6. The fix (commits 001e3dc and 95fb10b) introduces a new Boruta.HttpClient module that enforces per-client trusted_hosts and trusted_authorities allowlists and restricts schemes to http/https, replacing direct Finch calls in all three paths.

Know when Boruta gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (EEF) PRIMARY 6.9 MEDIUM
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:N/SC:L/SI:L/SA:N
vuln.today AI 7.2 HIGH

Network-accessible, no-auth SSRF causes scope change to internal systems; C:L/I:L reflects internal service probing with no direct availability impact on Boruta itself.

3.1 AV:N/AC:L/PR:N/UI:N/S:C/C:L/I:L/A:N
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:N/SC:L/SI:L/SA:N

Primary rating from Vendor (EEF).

CVSS VectorVendor: EEF

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
None
Subsequent system: Confidentiality
Low
Subsequent system: Integrity
Low
Subsequent system: Availability
None

DescriptionCVE.org

Server-Side Request Forgery vulnerability in malach-it Boruta allows an unauthenticated remote attacker to cause the OAuth/OpenID authorization server to issue outbound HTTP requests to attacker-chosen URIs, including internal services and cloud metadata endpoints.

Three code paths fetch remote URIs supplied by the requester without sufficient validation of the target. Boruta.Oauth.Request.Base.fetch_unsigned_request/1 in lib/boruta/oauth/request/base.ex dereferences the OAuth request_uri parameter from the authorization request via Finch.build(:get, request_uri) |> Finch.request(OpenIDHttpClient). Boruta.Openid.parse_registration_params/2 in lib/boruta/openid.ex dereferences the jwks_uri supplied in an OpenID Connect dynamic client registration request. Boruta.Ecto.Clients.refresh_jwk_from_jwks_uri/1 in lib/boruta/adapters/ecto/clients.ex later refreshes the stored jwks_uri for an existing client. In all three paths the only validation is that the URI parses with a scheme (and one of the two request_uri clauses does not even restrict the scheme to http or https). The implementations do not require HTTPS, do not enforce a host or IP allowlist, do not reject loopback, private, link-local, or other non-public ranges after DNS resolution, do not cap response size, and do not constrain redirects. An attacker can therefore steer the server's HTTP client at arbitrary network targets reachable from the Boruta host.

This issue affects boruta: from 2.3.2 before 2.3.7.

Threat Intelligence Overview

EPSS Score
0.4%
Top 70% exploitable
Prevalence
Low
niche Elixir OAuth library, limited broad enterprise adoption
Data Quality
6 sources
Confidence: High

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

34
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +34
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Server-Side Request Forgery exploits applications that fetch remote resources based on user-supplied URLs.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy