REDHAT-BUG-2502719: Medium severity rpcbind vulnerability

Published Jul 20, 2026
·
Updated

A flaw was found in rpcbind's rpcinfo utility. In rpcbdump() short mode, used by rpcinfo -s, version values returned by a remote RPCBPROCDUMP reply are appended via unbounded sprintf() calls into a fixed 256-byte stack buffer without tracking remaining space:

c char buf[256]; char p = buf; for (vl = rs->vlist; vl; vl = vl->next) { sprintf (p, "%d", vl->vers); p = p + strlen (p); if (vl->next) sprintf (p++, ","); }

A malicious or compromised rpcbind endpoint that returns enough distinct version numbers for a single program (roughly 24 maximum-width decimal values plus separators) can overflow this buffer. A user or administrator must run rpcinfo -s <host> against the hostile endpoint; no privileges on the victim are required, but user interaction is needed. Current evidence supports client-side stack memory corruption leading to a crash/denial of service of the rpcinfo client process; disclosure or reliable code execution are not established.

This bug was originally reported bundled together with a related, since-fixed overflow in rpcbaddrlist() (now tracked separately as CVE-2026-16277). Confirmed via direct inspection of upstream commit bb9bb7286a4c345442946dc2ce3c9e7f67e96d4d (rpcbind 1.2.9) that this rpcbdump() short-mode overflow is NOT fixed by that commit and remains present in the latest upstream release.

Steps to reproduce: 1. Build rpcbind with AddressSanitizer: CFLAGS="-O1 -g -fsanitize=address -fno-omit-frame-pointer" ./configure && make -j 2. Run a malicious rpcbind-compatible endpoint, or an instrumented test responder. 3. Return an RPCBPROCDUMP list for one program with enough distinct versions (~24+ max-width decimal values) to exceed 256 bytes. 4. Run ./src/rpcinfo -s <attacker-host>. 5. Observe an ASan stack-buffer-overflow report or client crash.

Proposed fix (not yet applied upstream): convert the version-list formatter to bounded snprintf() calls that track remaining buffer space. diff char p = buf; +char p = buf; +sizet rem = sizeof(buf); +int n; +buf[0] = '\0'; for (vl = rs->vlist; vl; vl = vl->next) { - sprintf (p, "%d", vl->vers); - p = p + strlen (p); - if (vl->next) - sprintf (p++, ","); + n = snprintf(p, rem, "%d%s", vl->vers, vl->next ? "," : ""); + if (n < 0) + break; + if ((sizet)n >= rem) { + p = buf + sizeof(buf) - 1; + break; + } + p += n; + rem -= (sizet)n; }

Affected Software

1 affected component
rpcbind

Remediation

Recommended actions to resolve this vulnerability, in priority order.

  1. Upgrade

    Upgrade rpcbind (rpcinfo / rpcbdump short mode) to a version that resolves this vulnerability.

    Fixed in 1.2.9
  2. Configuration

    In rpcbdump() short mode (used by `rpcinfo -s`), change the formatter code that currently does `sprintf(p++, ",")` and `sprintf(p, "%d", vl->vers)` into bounded `snprintf()` calls that track remaining space (`size_t rem = sizeof(buf)`). This is the proposed fix described in the material (not yet applied upstream).

    rpcbind (rpcinfo utility / rpcbdump() short mode) Replace unbounded sprintf() with bounded snprintf() while tracking remaining buffer space in the version-list formatter = Use snprintf(p, rem, ...) and decrement `rem` after each append; keep `p` within the fixed `char buf[256]`.
  3. Compensating control

    Do not run `rpcinfo -s <host>` against untrusted or potentially malicious rpcbind endpoints; user interaction is required to trigger the client-side stack-buffer overflow.

  4. Compensating control

    Mitigate by building rpcbind (including rpcinfo) with AddressSanitizer instrumentation using `CFLAGS="-O1 -g -fsanitize=address -fno-omit-frame-pointer" ./configure && make -j` to detect and prevent unnoticed stack-buffer-overflow exploitation during testing.

  5. Operational

    After applying the proposed bounded-snprintf code change, reproduce and verify: (1) run `./src/rpcinfo -s <attacker-host>` against a malicious rpcbind-compatible endpoint (or instrumented responder) that returns enough distinct version numbers to overflow the 256-byte buffer; (2) confirm the client crash/stack-buffer-overflow no longer occurs (e.g., via ASan reports).

Event History

Jul 20, 2026
Data Sourced
via Red Hat·10:36 AM
DescriptionSeverityAffected Software
Free Weekly Intel

Don't miss critical vulnerabilities

Join thousands of security professionals who receive our weekly digest of trending CVEs, zero-days, and exploited vulnerabilities.

No spam. Unsubscribe anytime.

Frequently Asked Questions

1

What is the severity of REDHAT-BUG-2502719?

The severity of REDHAT-BUG-2502719 is classified as medium.

2

What type of vulnerability is REDHAT-BUG-2502719?

REDHAT-BUG-2502719 is a stack buffer overflow vulnerability in rpcbind's rpcinfo utility.

3

How do I fix REDHAT-BUG-2502719?

To fix REDHAT-BUG-2502719, update to the latest version of the rpcbind software that addresses this issue.

4

What software is affected by REDHAT-BUG-2502719?

The affected software in REDHAT-BUG-2502719 is rpcbind.

5

When was REDHAT-BUG-2502719 published?

REDHAT-BUG-2502719 was published on July 20, 2026.

Contact

SecAlerts Pty Ltd.
132 Wickham Terrace
Fortitude Valley,
QLD 4006, Australia
info@secalerts.co
By using SecAlerts services, you agree to our services end-user license agreement. This website is safeguarded by reCAPTCHA and governed by the Google Privacy Policy and Terms of Service. All names, logos, and brands of products are owned by their respective owners, and any usage of these names, logos, and brands for identification purposes only does not imply endorsement. If you possess any content that requires removal, please get in touch with us.
© 2026 SecAlerts Pty Ltd.
ABN: 70 645 966 203, ACN: 645 966 203