Skip to main content

Core Rs Albatross CVE-2026-33184

HIGH
Integer Underflow (CWE-191)
2026-04-03 GitHub_M
7.5
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Connect to Nimiq node during handshake
  2. Delivery
    Send peer discovery message with limit=0
  3. Exploit
    Reach Established session state
  4. Execution
    Trigger periodic update computing unwrap subtraction
  5. Impact
    Wrap usize to MAX causing denial of service

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Integer underflow checks
Exploitation Conditions

Remote unauthenticated attacker exploiting nimiq/core-rs-albatross versions prior to 1.3.0. Attacker sends crafted peer discovery handshake with limit=0, causing integer underflow during periodic peer list updates after session reaches Established state.

Impact

Real-world risk is MODERATE despite the 7.5 CVSS score. The CVSS vector (AV:N/AC:L/PR:N/UI:N) confirms unauthenticated remote exploitation with low complexity, and the High availability impact reflects the deterministic panic/crash. However, multiple factors limit practical severity: this affects only nodes running vulnerable Nimiq core-rs-albatross versions in peer-to-peer network roles, the attack produces only denial-of-service (no data compromise or code execution), node operators can rapidly restart crashed instances, and the Nimiq blockchain ecosystem has limited deployment compared to mainstream protocols. No EPSS score provided in input data, but the straightforward attack vector (single malformed handshake message) suggests moderate automatable potential. CISA KEV status is negative, indicating no confirmed active exploitation in the wild. The SSVC framework would classify this as Technical Impact: Partial (availability only), Automatable: Yes (simple network message), and Exploitation: None (no public POC despite GitHub advisory and commit disclosure). The attack requires network connectivity to target nodes but no authentication, making it accessible to any network participant. Priority should focus on environments running public Nimiq validators or full nodes exposed to untrusted peers, while private/permissioned deployments face minimal risk.

Exploit ScenarioDerived

An attacker identifies publicly accessible Nimiq core-rs-albatross nodes via network scanning on the blockchain's peer-to-peer port. The attacker initiates a standard peer discovery handshake but injects peer_list_limit=0 in the handshake message. The target node accepts this value and completes the handshake, appearing to function normally. Minutes later, when the periodic peer list update routine executes on the now-Established session, the node attempts to subtract 1 from the stored limit of 0, causing integer wraparound to usize::MAX, then immediately panics when trying to allocate an 18-exabyte vector. The node crashes and becomes unavailable until manually restarted. No public exploit identified at time of analysis, but the attack requires only basic network protocol knowledge and could be scripted trivially.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.0% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Apr 03, 2026

Integer underflow in Nimiq core-rs-albatross <1.3.0 enables unauthenticated remote attackers to trigger deterministic denial-of-service via crafted peer handshake. Attackers send limit=0 during discovery handshake, causing arithmetic underflow (0-1 wraps to usize::MAX) when session transitions to Established state, resulting in capacity overflow panic when allocating peer contact vector. Upstream fix available (PR/commit); released patched version 1.3.0 confirmed. No public exploit identified at time of analysis, but EPSS indicates low exploitation probability and attack is trivially reproducible given simple network message crafting.

RemediationAI

Upgrade to Nimiq core-rs-albatross version 1.3.0 or later, which includes the fix merged via pull request #3664 and committed in 8f60a2d75b74b55764ecf34bd4435f4961630595. The patch adds proper input validation to reject peer_list_limit values of zero before storing them, preventing the integer underflow condition. Organizations can download the patched release from https://github.com/nimiq/core-rs-albatross/releases/tag/v1.3.0. As a temporary workaround for environments unable to upgrade immediately, implement network-level filtering to restrict peer connections to trusted nodes only, or deploy monitoring to detect and automatically restart nodes experiencing unexpected panics. Review firewall rules to limit exposure of vulnerable nodes to untrusted network participants. No configuration-based mitigation exists since the vulnerability requires code-level fixes to the handshake validation logic.

Affects your stack

Find out whether the stacks and servers you run are on an affected version.

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

Technical ContextAI · show details

Nimiq core-rs-albatross implements the Albatross proof-of-stake consensus algorithm for the Nimiq blockchain network. The vulnerability resides in the peer discovery handler's session lifecycle management. During the handshake phase, the handler accepts a peer_list_limit parameter from remote peers without validation and stores it directly. While the immediate HandshakeAck code path safely handles limit=0 by returning zero contacts, the code fails to validate this value before the session transitions to Established state. Once established, the periodic peer list update mechanism performs arithmetic: self.peer_list_limit.unwrap() as usize - 1. This operation exhibits classic CWE-191 (Integer Underflow/Wraparound) behavior - when limit=0, subtracting 1 wraps around to usize::MAX (18,446,744,073,709,551,615 on 64-bit systems). This massive value is then passed to the rand 0.9.2 crate's choose_multiple() function, which immediately attempts Vec::with_capacity(usize::MAX), triggering a deterministic panic due to capacity overflow. The vulnerability demonstrates improper input validation combined with unsafe arithmetic on untrusted network data in Rust's otherwise memory-safe environment.

Know when Core Rs Albatross 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 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H

Primary rating from Vendor (GitHub_M) · only source for this CVE.

CVSS VectorVendor: GitHub_M

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

DescriptionCVE.org

nimiq/core-rs-albatross is a Rust implementation of the Nimiq Proof-of-Stake protocol based on the Albatross consensus algorithm. Prior to version 1.3.0, the discovery handler accepts a peer-controlled limit during handshake and stores it unchanged. The immediate HandshakeAck path then honors limit = 0 and returns zero contacts, which makes the session look benign. Later, after the same session reaches Established, the periodic update path computes self.peer_list_limit.unwrap() as usize - 1. With limit = 0, that wraps to usize::MAX and then in rand 0.9.2, choose_multiple() immediately attempts Vec::with_capacity(amount), which deterministically panics with capacity overflow. This issue has been patched in version 1.3.0.

Executive ViewAI

Why It Matters

Nimiq core-rs-albatross versions below 1.3.0 contain an integer underflow vulnerability that allows unauthenticated attackers to crash blockchain nodes remotely through malformed peer handshake messages. Organizations running affected versions face operational disruption and network unavailability, directly impacting transaction processing and consensus participation.

Business Impact: High
Compensating Controls

Vendor-released patch: Nimiq core-rs-albatross version 1.3.0. Until patching is complete: restrict inbound peer connections to whitelisted node addresses, implement aggressive rate-limiting on peer discovery handshake requests, and monitor for abnormal node crashes or consensus participation drops that may indicate exploitation attempts.

Threat Intelligence Overview

EPSS Score
0.0%
Top 87% exploitable
Social Media
1
Sightings
Data Quality
5 sources
Confidence: Medium

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 HIGH
CISA KEV No
Public POC No
EPSS 0.0%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

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

Attack Technique

A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.

Integer overflow occurs when an arithmetic operation produces a result that exceeds the maximum value a given integer type can store.

Affected Products (CPE)CVE.org

cpe:2.3:a:nimiq:core-rs-albatross:*:*:*:*:*:*:*:*

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