Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessFind app exposing IFSC lookup
-
DeliverySubmit crafted IFSC as network-path/absolute URI
-
ExploitURI.join resolves attacker/internal host
-
ExecutionGem issues GET to that host
-
ImpactParsed response fields returned to attacker
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 | Exploitation requires the consuming application to pass attacker-controlled input directly into IFSC.find or IFSC#get; the attacker supplies a network-path reference (e.g. //evil.host) or an absolute URI that Ruby's URI.join interprets as a new host, overriding the intended Razorpay API base. The core limiting factor is that the application must expose this lookup to untrusted input and return or act on the parsed response - the gem itself performs no authentication (PR:N) and needs no user interaction, but impact is confined to reading parsed response fields (low confidentiality), with no write or availability effect. Internal reachability of the target host from the server running the gem is also required for SSRF to reach sensitive endpoints. |
| Impact | This is a medium-severity SSRF (CWE-918) rated CVSS 4.0 base 6.9 with vector AV:N/AC:L/AT:N/PR:N/UI:N and VC:L (only low confidentiality impact; VI:N/VA:N). The signals are internally consistent: network-reachable, low complexity, no authentication or user interaction, but limited to reading parsed response fields rather than full code execution or data destruction. No EPSS score was provided in the input, so exploitation probability cannot be quantified. The vulnerability is NOT listed in CISA KEV and no public exploit code is confirmed in the provided data, though a HackMD write-up and a VulnCheck advisory are referenced and may contain technical detail - treat POC status as unconfirmed. SSVC-style read: exploitation status is unproven, technical impact is partial (confidentiality-only SSRF), and automatability is plausible but unconfirmed. Net: this is a real but moderate-priority issue - the 6.9 score is honest, not inflated, but the confidentiality-only impact and dependence on an application exposing the vulnerable lookup to untrusted input keep it below critical. Prioritize for Ruby/Rails fintech stacks that call this gem on user-supplied IFSC values; it is lower urgency for environments that do not. |
| Exploit ScenarioDerived | An attacker interacts with a web application that passes user-supplied IFSC codes to IFSC.find or IFSC#get (e.g., a bank-account validation form). Instead of a valid IFSC, the attacker submits a network-path reference or absolute URI that URI.join resolves as a new host, coercing the gem into issuing a GET request to an internal metadata endpoint or attacker-chosen host and returning parsed response fields. No authentication or user interaction is required per the CVSS vector; no public exploit is confirmed in the provided data, though referenced advisories may detail the technique. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 14, 2026
Razorpay IFSC Ruby gem through version 2.0.62 is affected by a server-side request forgery (SSRF) vulnerability. Unauthenticated remote attackers can supply a crafted IFSC code to IFSC.find or IFSC#get - such as a network-path reference (//evil.host) or an absolute URI - that Ruby's URI.join resolves as a new host, redirecting API requests to internal or attacker-chosen hosts and returning parsed response fields. Exploitation requires the consuming application to pass untrusted input directly to these methods; impact is limited to low confidentiality (CVSS 4.0 base 6.9) with no write or availability effect, and no public exploit has been identified at time of analysis.
RemediationAI
No vendor-released patch has been identified at time of analysis. Until an update is available, apply the following compensating controls: sanitize all user-supplied IFSC codes before passing them to IFSC.find or IFSC#get, allowing only the expected 11-character alphanumeric IFSC format (e.g., using a strict regex such as /^[A-Z]{4}0[A-Z0-9]{6}$/); this prevents network-path references and absolute URIs but may reject malformed yet legitimate inputs if the application relies on permissive parsing. Alternatively, override the base URL resolution by using a custom URI join that enforces the Razorpay API host and rejects any input containing '//' or '://' or a leading scheme. Restrict outbound network access from the server running the gem to only the required Razorpay API endpoints (e.g., api.razorpay.com) and block requests to private IP ranges (RFC 1918, loopback, link-local) to prevent SSRF to internal services; this egress filtering may need to be tailored to the environment and could interfere with other legitimate outbound traffic. Monitor the vendor repository (https://github.com/razorpay/ifsc) and the VulnCheck advisory for a patched release, and upgrade to a version above 2.0.62 once available.
Affected VersionsENISA
Affected Packages
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
The vulnerability is a classic CWE-918 server-side request forgery in the Razorpay IFSC Ruby gem's lookup logic. IFSC.find and IFSC#get construct a request URL by joining a base Razorpay API URL with the user-supplied IFSC code. Ruby's URI.join follows RFC 3986 reference resolution, so a network-path reference (e.g., //attacker.com) or an absolute URI (e.g., http://internal-host/) overrides the base host. The gem then issues a GET request to the resolved host and returns parsed response fields. The affected component is the Ruby gem 'ifsc' (all versions up to and including 2.0.62), as distributed via RubyGems. No authentication is required (PR:N) and no user interaction is needed (UI:N); the limiting factor is that the consuming application must expose these methods to attacker-controlled input and act on or return the parsed response.
Know when Ruby 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
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N
Network-reachable, low-complexity, no auth or interaction because the gem resolves untrusted input via URI.join; impact is confined to reading parsed response fields, so C:L with I:N/A:N.
Primary rating from Vendor (vulncheck).
CVSS VectorVendor: vulncheck
DescriptionCVE.org
Razorpay IFSC Ruby gem through 2.0.62 contains a server-side request forgery vulnerability that allows attackers to redirect API requests by supplying a crafted IFSC code to IFSC.find or IFSC#get. Attackers can submit network-path references or absolute URIs that URI.join resolves as a new host, sending GET requests to internal or attacker-chosen hosts and returning parsed response fields.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Server-Side Request Forgery exploits applications that fetch remote resources based on user-supplied URLs.
Ruby before 2.4.3 allows Net::FTP command injection. Rated high severity (CVSS 8.8), this vulnerability is remotely expl
The lazy_initialize function in lib/resolv.rb in Ruby through 2.4.3 uses Kernel#open, which might allow Command Injectio
Ruby through 2.2.7, 2.3.x through 2.3.4, and 2.4.x through 2.4.1 can expose arbitrary memory during a JSON.generate call
Type confusion exists in two methods of Ruby's WIN32OLE class, ole_invoke and ole_query_interface. Rated critical severi
Authenticated remote code execution in OpenC3 COSMOS (Ruby gem 'openc3' versions 5.1.0 through 7.2.1) lets any logged-in
Type confusion exists in _cancel_eval Ruby's TclTkIp class method. Rated critical severity (CVSS 9.8), this vulnerabilit
An exploitable heap overflow vulnerability exists in the Fiddle::Function.new "initialize" function functionality of Rub
An issue was discovered in Oniguruma 6.2.0, as used in Oniguruma-mod in Ruby through 2.4.1 and mbstring in PHP through 7
Stored XSS in Bugsink error tracking tool before 2.0.13 allows unauthenticated attackers to inject persistent scripts th
Ruby before 2.4.2, 2.3.5, and 2.2.8 is vulnerable to a malicious format string which contains a precious specifier (*) w
Heap-based buffer overflow in Ruby 1.8, 1.9 before 1.9.3-p484, 2.0 before 2.0.0-p353, 2.1 before 2.1.0 preview2, and tru
Heap-use-after-free in the Ruby json gem's native C extension (versions 2.20.0 through 2.21.1) allows an unauthenticated
EUVD-2026-99007
GHSA-crh7-6qx8-9v9q
NVD
CVE.org
EPSS
Exploit-DB