Skip to main content

geopy CVE-2026-77387

| EUVDEUVD-2026-90923 MEDIUM
Inefficient Regular Expression Complexity (ReDoS) (CWE-1333)
2026-10-01 GitHub_M GHSA-mhvh-fq92-pfmr
4.0
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Identify geopy string-parsing endpoint
  2. Delivery
    Send long malformed coordinate string
  3. Exploit
    Trigger catastrophic regex backtracking
  4. Execution
    Exhaust CPU/worker threads
  5. Impact
    Deny service to legitimate users

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V2 - Validation and Business Logic Regex complexity limits
MITRE ATT&CK

1 technique across 1 tactic: Impact

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

Exploitation Conditions

The affected application must pass attacker-controlled string input into geopy.Point, Point.from_string(), or a geocoder reverse() method called with string (rather than numeric) arguments, on geopy < 2.5.0 without the 256-character input cap. The numeric Point constructor is unaffected and is not an exploitation path. Exploitation is limited by requiring that the application actually exposes one of these string-parsing entry points to untrusted input; deployments that only use numeric coordinates, validate/length-limit input upstream, or have upgraded to 2.5.0 are not exploitable. No authentication or user interaction is needed at the library level, but overall reachability depends on the host application's input handling.

Impact

This is a ReDoS (CWE-1333) denial-of-service issue in the geopy Python library (< 2.5.0) with a confirmed availability-only impact (C:N/I:N/A:L) and no code-execution or data-exposure risk. The supplied CVSS 3.1 vector rates it AV:L (local), yet the description explicitly states the vulnerable parsing path is reached via geocoder reverse methods and attacker-controlled string requests, which in a typical web/service deployment is network-reachable - CVSS indicates local vector but the description implies remote request-driven exploitation, so the AV:L rating likely understates reach for applications that pass untrusted strings to geopy. No EPSS score was provided, there is no CISA KEV listing, and no weaponized public exploit was supplied; the vendor PR/issue (#608, #610) does include a timing-based reproducer test demonstrating the slow-parse condition, but a reproducer is not the same as active exploitation. Net: this is a low-to-moderate real-world priority - a patched, availability-only library bug that matters chiefly where geopy parses untrusted input at scale, not a high-urgency critical issue.

Exploit ScenarioDerived

An application exposes a geocoding feature that forwards user-supplied location strings into geopy.Point, Point.from_string(), or a geocoder reverse() call. An attacker repeatedly submits a long malformed coordinate string (e.g. a '<' followed by ~100,000 spaces and a trailing character), each request forcing catastrophic regex backtracking in POINT_PATTERN and pinning a CPU core for seconds. A modest volume of such requests exhausts worker threads and denies service to legitimate users; the vendor PR includes a timing reproducer but no weaponized exploit was provided.

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

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

Alert me

AnalysisAIv1 – Oct 01, 2026

Denial of service in geopy versions prior to 2.5.0 allows an unauthenticated remote attacker to consume excessive CPU by supplying a long, malformed coordinate string to geopy.Point, Point.from_string(), or a geocoder reverse() method invoked with a string argument. The root cause is catastrophic backtracking (CWE-1333) in the POINT_PATTERN regular expression; the fix in 2.5.0 adds a 256-character input cap that rejects oversized input immediately, while the numeric Point constructor is unaffected. Impact is availability-only (C:N/I:N/A:L) with no code execution or data exposure; no public exploit code was identified at time of analysis, and reachability depends on the host application exposing one of the string-parsing entry points to untrusted input.

RemediationAI

Vendor-released patch: upgrade geopy to 2.5.0, which is the exact fixed release and enforces a 256-character cap in Point.from_string() via _MAX_STRING_LENGTH, causing oversized input to raise ValueError immediately instead of triggering regex backtracking. Install with 'pip install --upgrade geopy==2.5.0' (or the latest 2.5.x) and confirm the resolved version, since geopy is a transitive dependency in many geospatial and data-processing stacks and may need pinning in requirements files, lockfiles, and container images; advisory and release details are at https://github.com/geopy/geopy/security/advisories/GHSA-mhvh-fq92-pfmr and https://github.com/geopy/geopy/releases/tag/2.5.0. If upgrading is temporarily blocked, apply a specific compensating control at the application boundary: reject or truncate any coordinate string longer than 256 characters before it reaches Point, from_string(), or reverse(), and prefer the numeric Point constructor for programmatic coordinates, which never enters the vulnerable parsing path - the trade-off is that legitimate strings exceeding the cap (rare, since valid coordinate strings are far shorter) would be rejected. Where input length cannot be constrained, wrap the parsing call in a worker process or thread with a hard execution timeout and a request-level rate limit so a single slow parse cannot exhaust the request-handling pool; this adds latency and operational complexity and should be treated as a temporary stopgap rather than a substitute for upgrading.

Affected VersionsENISA

geopy < 2.5.0

Affected Packages

pypi geopy fix: 2.5.0

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in pypi

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

Technical ContextAI · show details

The flaw is an inefficient regular expression complexity issue (CWE-1333, ReDoS) in geopy's coordinate string parser. geopy.Point accepts both a numeric constructor form and a string form routed through Point.from_string(), which applies POINT_PATTERN to the input. When the regex encounters a very long malformed string, its alternation and optional matching structure triggers pathological backtracking, so the matcher explores an exponential number of paths before failing - the upstream regression test uses an input of a leading angle bracket followed by 100,000 spaces and a trailing character, which reputedly takes tens of seconds to fail without the guard. The PR diff (https://github.com/geopy/geopy/pull/610) introduces a class-level _MAX_STRING_LENGTH = 256 constant and raises ValueError for inputs exceeding it, on the rationale that any realistic valid coordinate string is far shorter, so lengthened input cannot be a legitimate point. Geocoder reverse() methods that accept string coordinates also funnel into this same parsing path, widening the attack surface beyond direct Point construction. The regex itself is unchanged; the mitigation is a pre-parse length bound, which is why the numeric constructor never reaches the vulnerable code path.

Know when Geopy 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 (GitHub_M) PRIMARY 4.0 MEDIUM
AV:L/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
vuln.today AI 5.3 MEDIUM

Library is typically reached via network-facing geocoder string inputs so AV:N/PR:N/UI:N; a single long string triggers it (AC:L) and only availability (CPU exhaustion) is affected.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Local
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
Low

Lifecycle Timeline

1
Patch available
Oct 01, 2026 - 17:17 EUVD

DescriptionCVE.org

geopy is a geocoding library for Python. Prior to 2.5.0, geopy.Point and Point.from_string() can spend excessive CPU time due to inefficient regular-expression behavior when an application passes a long malformed coordinate string without the 256-character input limit used by the fix. Geocoder reverse methods also reach the vulnerable parsing path when called with string inputs. Repeated attacker-controlled requests can cause a denial of service, while the numeric Point constructor is unaffected. This issue is fixed in version 2.5.0.

Threat Intelligence Overview

EPSS Score
0.2%
Top 91% exploitable
Prevalence
Medium
popular Python geocoding library, common in geo apps but not ubiquitous infrastructure
Threat Intel
1
1 sources
Social Media
1
Sightings
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA Vendor CIRCL GitHub

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.2%
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
Defer
Exploitation
Poc
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

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

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

Vendor StatusVendor

SUSE

Severity: Moderate
Product Status
openSUSE Tumbleweed Fixed

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