A menudo critico los lenguajes inseguros de la memoria., principalmente C y C ++, y c贸mo provocan un extraordinario n煤mero de vulnerabilidades de seguridad. Mi resumen, basado en el examen de la evidencia de numerosos proyectos grandes de programaci贸n C y C ++, es que necesitamos migrar nuestra industria a los lenguajes seguros para la memoria predeterminados (como Rust y Swift). Una de las respuestas que obtengo a menudo es que el problema no est谩 en C y C ++ en s铆, los desarrolladores simplemente los "preparan" incorrectamente. En particular, a menudo obtengo una respuesta en defensa de C ++ como: "C ++ es seguro si no usa la funcionalidad heredada de C" [1] o similar, que si usa los tipos y modismos modernos C ++, entonces estar谩 asegurado contra vulnerabilidades como memorias da帽adas que sufren otros proyectos.
Me gustar铆a dar cr茅dito a los punteros inteligentes de C ++, porque ayudan mucho. Desafortunadamente, mi experiencia de trabajar en grandes proyectos de C ++ usando modismos modernos es que ni siquiera est谩 lo suficientemente cerca como para detener la afluencia de vulnerabilidades. Mi objetivo para el resto de esta publicaci贸n es resaltar una serie de modismos C ++ completamente modernos que introducen vulnerabilidades.
Enlace oculto y uso gratuito
#include <iostream>
#include <string>
#include <string_view>
int main() {
std::string s = "Hellooooooooooooooo ";
std::string_view sv = s + "World\n";
std::cout << sv;
}
, s + "World\n"
std::string
, std::string_view
. std::string , sv
, . sv
use-after-free . ! ++ , , sv
-, , . std::span
, ++.
++ :
#include <memory>
#include <iostream>
#include <functional>
std::function<int(void)> f(std::shared_ptr<int> x) {
return [&]() { return *x; };
}
int main() {
std::function<int(void)> y(nullptr);
{
std::shared_ptr<int> x(std::make_shared<int>(4));
y = f(x);
}
std::cout << y() << std::endl;
}
[&]
f
. main
, x
, . y
. , . , , std::shared_ptr&
, .
std::optional
std::optional
, , , (, -1
nullptr
). , value()
, T
, , , optional
. , operator*
operator->
. T
, , optional
.
, , :
#include <optional>
int f() {
std::optional<int> x(std::nullopt);
return *x;
}
std::optional
nullptr
, ! nullptr
segfault ( , ). , nullopt
, . T*
, , , nullptr
.
, . / :
#include <optional>
#include <memory>
std::unique_ptr<int> f() {
std::optional<std::unique_ptr<int>> x(std::nullopt);
return std::move(*x);
}
std::span
std::span
. , ; std::span
, std::vector, std::array<uint8_t, N>
. - , span
, , .
STL, span::operator[]
. , operator[]
. std::vector
std::array
, , , at()
, ( , , , std::vector::operator[]
). span at()
, , .
, Firefox, Chromium std::span
operator[]
, , , std::span
.
C++ , : , std::span
, , std::variant
union
. C++ :
use-after-free, optional
span
.
++ Rust- ( Rust-, unsafe
) , ++ , , Rust Swift ( Python Javascript, , - Python, C++).
C C++ - . , , , , . ++, , ++.
[1] , , --, malloc/free . , , , , , ++ , ++- "".