Follow @Openwall on Twitter for new release announcements and other news
[<prev] [next>] [thread-next>] [day] [month] [year] [list]
Message-ID: <20261120215330.GA18184@brightrain.aerifal.cx>
Date: Fri, 20 Nov 2026 16:53:30 -0500
From: Rich Felker <dalias@...c.org>
To: musl@...ts.openwall.com
Subject: Proposed CVE policy

I've never had to write up a policy for this before because it always
seemed obvious, but with the deluge of non-issue or minor bug reports
other projects are getting hit with and pressured to treat as security
bugs meriting CVE assignment, I'd like to make it explicit:


For library code with gigantic interface surface and an unbounded set
of library consuming applications, any deviation, no matter how minor,
from the specified interface contract is *potentially* a security
issue. It's always possible a caller uses an interface in a way that
its security/integrity properties depend on the contract being met
precisely, and that the bug breaks these properties. However, for most
bugs, it's very unlikely that this would happen unless the application
has been written to be intentionally fragile just to make a point.

Regardless, it is entirely unhelpful to treat each bug as a security
issue, for many reasons including:

- Burying the serious issues among a sea of nothingburgers, causing
  defenders to miss announcements of issues that actually matter.

- Overwhelming defenders and pressuring them to rely on unvetted
  upgrade/patching advice from automated processes/chatbots that are
  likely to be wrong.

- Hiding fix for normal bugs behind embargo procedures where there is
  no public input, making the process opaque and untrustworthy and
  likely resulting in new bugs when there are fewer additional eyes on
  the fixes being proposed.

So I will not be jumping on the "everything is a CVE!" bandwagon.



In the past, my informal approach to whether to treat a bug as a
security issue and seek (or request that the reporter seek) CVE
assignment for it has been based on:

1. It actually being a bug, rather than just a lack of hardening or a
   footgun or similar. Unlike many things, libc (at least the
   standards-governed part) does have rigorous interface contracts
   that establish which party has a burden to fix.

2. Exposure of the affected interface(s) to untrusted input, and
   whether these interfaces can be reasonably expected to be safe with
   untrusted input. For example, printf with untrusted format strings
   is unsafe (UB from argument type mismatch), regcomp/regexec with
   BRE is unsafe (exponential time for backrefs), and wordexp is
   wildly unsafe (shell processing). Some interfaces like the
   passwd/group database, the dynamic linker, and timezone data
   process inherently-trusted data. In the other direction, things
   like iconv, DNS resolution, crypt, etc. are very much expected to
   be exposed as attack surface.

3. What happens when the bug is triggered - are there risks of
   arbitrary code execution, data loss, authentication bypass, log
   falsification, or even just crashing of important long-lived
   processes under reasonable use of the affected interfaces?

Going forward, I want to continue to assess things from these
perspectives, but with bug reporters also having knowledge of them so
that we're on the same page about what to expect.

Going into some detail on item 1 above and how interface contracts are
involved;

- If the application-libc system is vulnerable but the libc behavior
  is in a standards-specified function and behaving in a conforming
  manner, it is not a libc security bug. It may merit hardening.

- If the application-libc system is vulnerable but the libc behavior
  is part of a nonstandard extension, and there are other historical
  implementations of this extension that would be similarly affected,
  it is not a libc security bug. It may of course merit hardening or
  other improvements.

- If the application-libc system is vulnerable and an application
  honoring the interface contracts of the libc interfaces can cause
  libc-internal undefined behavior, corruption of state, etc. then it
  very much is a libc bug, and may be a security one depending on the
  other principles 2 and 3 above.


This document is a draft largely written on the spot based on my
understanding of how we've done things in the past. If anything in it
seems off or if folks disagree (either that it accurately describes
past informal policy, or disagree with it as principles for going
forward), particularly from a distros/integrators/users perspective,
I'd be happy to discuss improvements.

Rich

Powered by blists - more mailing lists

Confused about mailing lists and their use? Read about mailing lists on Wikipedia and check out these guidelines on proper formatting of your messages.