News for hackers. Stuff that matters.
Re:Git Security Vulnerabilities Announced by sshine on Tuesday January 17, 2023 @02:31PM (#34417440)
Rust does have a fix for this:

  error: this arithmetic operation will overflow
   --> src/main.rs:2:18
    |
  2 |     let a: u64 = u64::MAX + 1;
    |                  ^^^^^^^^^^^^ attempt to compute `u64::MAX + 1_u64`, which would overflow
    |
    = note: `#[deny(arithmetic_overflow)]` on by default
Rust also allows for overflowing arithmetic (preserving the default to fail):

https://doc.rust-lang.org/std/?search=overflowing

It's generally less ergonomic, e.g.

  let (zero, _did_overflow) = u64::MAX.overflowing_add(1);
Re:Git Security Vulnerabilities Announced by deathanatos on Tuesday January 17, 2023 @02:39PM (#34417567)
Edit: Gah, I'm a bit wrong too. There's the compiler error (this), and the runtime error (what I'm talking about below.)

As a sibling notes, currently, this is for debug builds. (I love this feature, and I wish they had done it in release mode too. The sibling comment has some notes on that, too.)

(But, e.g., were `git` written in Rust, presumably the end product would be a release build. Now, you can enable the check there, but that is something you have to do, today.)

Re:Git Security Vulnerabilities Announced by howinteresting on Tuesday January 17, 2023 @02:37PM (#34417539)
You'll get a compile error when rustc can statically prove that it'll overflow (as in your example above). That is generally not possible.

The correct answer is what shepmaster said in a sibling comment.

Re:Git Security Vulnerabilities Announced by hypeatei on Tuesday January 17, 2023 @02:43PM (#34417648)
Slightly related, I wonder why the return type for `overflowing_add` isn't `Result<T>` and instead a tuple containing a boolean?
Re:Git Security Vulnerabilities Announced by re on Tuesday January 17, 2023 @02:54PM (#34417815)
There are times when you want to know how much overflow occurred -- think of the way you learn to do multi-digit addition. There is a checked_add that returns an Option<T> if you only care about success/failure.
Re:Git Security Vulnerabilities Announced by sshine on Tuesday January 17, 2023 @03:46PM (#34418759)
An example is efficient prime-field arithmetic:

https://cp4space.hatsya.com/2021/09/01/an-efficient-prime-fo...

> If A happened to be larger than C, and therefore the result of the subtraction underflowed, then we can correct for this by adding p to the result. [...] we can multiply B by 2^32 using a binary shift and a subtraction, and then add it to the result. We might encounter an overflow, but we can correct for that by subtracting p.

(Highlighting the parts that relate to reacting to overflow.)

Re:Git Security Vulnerabilities Announced by sshine on Tuesday January 17, 2023 @03:04PM (#34418035)
My guess is:

The `(T, bool)` that gets returned is friendly towards optimization.

If you don't use the bool, the overflowing arithmetic is reduced to efficient arithmetic which is overflowing by default. If you do use the bool, the generated code contains one extra instruction.

Re:Git Security Vulnerabilities Announced by jcparkyn on Tuesday January 17, 2023 @02:56PM (#34417874)
Probably because you'd want to access the value in either case, depending on your application.
Re:Git Security Vulnerabilities Announced by howinteresting on Tuesday January 17, 2023 @04:15PM (#34419287)
Could be a `Result<T, T>` which would seem to express the intent better.
Re:Git Security Vulnerabilities Announced by 3836293648 on Tuesday January 17, 2023 @04:23PM (#34419405)
Sometimes, sure. But an overflow doesn't have to be an error, it can be what you're after and you just want to know when it happens.
Re:Git Security Vulnerabilities Announced by howinteresting on Tuesday January 17, 2023 @04:30PM (#34419527)
Binary search is the same way and the return type there is already Result<usize, usize>.