upvote
From a brief look, I'd say there were several wrong turns made that led to the CVE-2026-123007 overflow bug.

For why I think it's unrealistic to go all-in on signed integers in C, it's because sizeof is unsigned, and most APIs dealing with lengths use size_t, and there are many pitfalls when mixing signed and unsigned types.

But I agree that there's a good case for using signed for the task behind that CVE. As I said, there are compelling reasons.

OpenSSL is a case study in the pitfalls with mixing signed and unsigned in C code. A major reason is the careful dance it has to do mixing signed and unsigned, and it stumbles. There's no substitute for being careful with arithmetic, and at least for me, when I expend that effort I also tend to use overflow checking APIs, clamping, etc, because it's less prone to error. Do that and the benefits of signed start to disappear, or at least the debate starts to lose relevance. Why OpenSSL doesn't create and use a set of overflow checking routines is beyond me as it would simplify an incredible amount of very hairy and brittle code.

reply
The way to deal with APIs which use size_t and which works for me is to convert at the last moment.
reply
I'll have to more carefully read some of your code sometime. Any links to good exemplars? I'll admit I should be more amenable to making use of signed, and I wouldn't have said that several years ago.

At the same time, the more I employ overflow checking routines[1], the less interest I have in the whole debate. Those routines cut both ways as they also make it safer to mix signed and unsigned.

[1] GCC/clang builtins, which IIUC the new C2y API mirrors. The return value semantic is unfortunate, especially in C2y where they lack the "overflow" name prefix, but it's understandable why C2y had to copy it.

reply
Why would anyone prefer signed for indexing and sizes?

With unsigned you only need one check: 'i < bound', it works always, regardless how i is computed, and it doesn't matter if the calculation overflowed or wrapped around, still works.

With signed you need: 'i >= 0 && i < bound', and you need to be very careful how you calculate i because overflow is undefined behavior.

reply
The issue with accidental overflow leading to wrap-around is also relevant to the value of `bound`.

If `bound` is unsigned and experiences accidental wrap-around due to underflow, the simple `i < bound` check fails open: most values of i pass against the unintentionally-huge `bound`. The signed version fails closed (no i passes both i >= 0 and i < bound), which is usually safer.

That’s how the argument goes, anyway. You’re right that using signed means a missing `>= 0` check can be a problem, as well as all the risks of signed-overflow UB.

No perfect solution in C.

reply
The N >= 0 check you often get automatically using sanitizers, e.g. when using an array [N] somewhere, or by concerting to size_t at last moment and then getting a size which is so big that allocation is guaranteed to fail.

Not that are wraparound CVEs in Rust as well, so there is no perfect solution even outside of C.

reply