News for hackers. Stuff that matters.
Re:Glibc getaddrinfo stack-based buffer overflow by cmrx64 on Tuesday February 16, 2016 @11:41AM (#11111062)
> Written properly, C++ is not unsafe.

This is abusing what "unsafe" means. As a language, C++ is inherently unsafe. However, some C++ programs ("written properly") are correct.

If written properly C++ is not unsafe, then written properly C is not unsafe.

Re:Glibc getaddrinfo stack-based buffer overflow by SCHiM on Tuesday February 16, 2016 @12:28PM (#11111504)
No I think he meant that if you adhere to certain language constructs the language is just as memory safe as Rust/others.

Eg. Don't use C++ as C with vectors, use C++ with the more modern language features:

It's the difference between:

    // where f is of type fstream of a file containging "this is a string\r\n"No I think he meant that if you adhere to certain language constructs the language is just as memory safe as Rust/others.
Eg. Don't use C++ as C with vectors, use C++ with the more modern language features:

It's the difference between:

    std::string A = "ab" + std::string("c");

    // And:
    char Buffer[512] = {};
    strcat(Buffer, "ab");
    strcat(Buffer, "c");
Or alternatvily:

    std::vector<uint8_t> SomeData = { 1,2,3 }
    std::vector<uint8_t> OtherData(SomeData.begin(), SomeData.end());

    // and:
    std::vector<uint8_t> SomeData = { 1,2,3 }
    std::vector<uint8_t> OtherData;
    OtherData.reserve(3);
    memcpy(...)

In the first one you're 'protected' by the stl code, which is arguably the same level of protection as afforded by any memory safe language’s library code.

    std::string A = "ab" + std::string("c");

    // And:
    char Buffer[512] = {};
    strcat(Buffer, "ab");
    strcat(Buffer, "c");
Or alternatvily:

    std::vector<uint8_t> SomeData = { 1,2,3 }
    std::vector<uint8_t> OtherData(SomeData.begin(), SomeData.end());

    // and:
    std::vector<uint8_t> SomeData = { 1,2,3 }
    std::vector<uint8_t> OtherData;
    OtherData.reserve(3);
    memcpy(...)

In the first one you're 'protected' by the stl code, which is arguably the same level of protection as afforded by any memory safe language’s library code.
Re:Glibc getaddrinfo stack-based buffer overflow by dbaupp on Tuesday February 16, 2016 @01:39PM (#11112077)
> No I think he meant that if you adhere to certain language constructs the language is just as memory safe as Rust/others.

It's not; as soon as code uses (for instance) references, you're running the memory-unsafety gantlet. E.g. even something super-modern like

  for (auto& thing: vector)
is risky: what if the loop body happens to somehow call `vector.push_back(x)`?
Re:Glibc getaddrinfo stack-based buffer overflow by tomjakubowski on Tuesday February 16, 2016 @02:35PM (#11112513)
> is risky: what if the loop body happens to somehow call `vector.push_back(x)`?

Some people like to say that these bugs are trivial to avoid ("who would write code like that?!"), but they miss the insidious (and common) case: when code several layers down the call stack (in some arbitrary callback assigned at runtime, say) grows the vector/map from under you.

Re:Glibc getaddrinfo stack-based buffer overflow by kccqzy on Wednesday February 17, 2016 @02:44AM (#11116063)
It's still easy to avoid though. Just take a const reference to the vector and use that in the loop and pass that to the callback. It just requires discipline, and in fact less discipline than writing C.
Re:Glibc getaddrinfo stack-based buffer overflow by gpderetta on Tuesday February 16, 2016 @12:36PM (#11111579)
I don't subscribe to the "properly written Modern C++ is safe" meme, but still it must be recognized that there are degrees of unsafety [1] between languages.

[1] not talking about memory safety, but as a general "probability of having a defect".

Re:Glibc getaddrinfo stack-based buffer overflow by cmrx64 on Tuesday February 16, 2016 @01:44PM (#11112119)
I really dislike the "safe"/"unsafe" terminology, there isn't a commonly-agreed upon definition of "safe". But I think it's safe to say that it's a combination of type and memory safety, not "low probability of having a defect".

There certainly is a spectrum.