C ++ modern tidak akan menyelamatkan kita

Saya sering mengkritik bahasa yang tidak aman mengingat , terutama C dan C ++, dan bagaimana mereka memprovokasi sejumlah besar kerentanan keamanan. Ringkasan saya, berdasarkan bukti pemeriksaan dari banyak proyek pemrograman C dan C ++ besar, adalah bahwa kita perlu memigrasi industri kita ke bahasa aman-memori default (seperti Rust dan Swift). Salah satu jawaban yang sering saya dapatkan adalah bahwa masalahnya bukan pada C dan C ++ itu sendiri, pengembang hanya “mempersiapkan” secara tidak benar. Secara khusus, saya sering mendapatkan jawaban untuk membela C ++ seperti: "C ++ aman jika Anda tidak menggunakan fungsionalitas yang diwarisi dari C" [1] atau serupa dengannya, itu jika Anda menggunakan tipe dan idiom modern C ++, maka Anda akan diasuransikan terhadap kerentanan seperti memori kerusakan yang diderita proyek lain.

Saya ingin memberikan penghargaan kepada C ++ smart pointer, karena mereka banyak membantu. Sayangnya, pengalaman saya mengerjakan proyek C ++ besar menggunakan idiom modern adalah bahwa itu bahkan tidak cukup dekat untuk menghentikan masuknya kerentanan. Tujuan saya untuk sisa posting ini adalah untuk menyoroti sejumlah idiom C ++ yang benar-benar modern yang memperkenalkan kerentanan.

---

Tautan tersembunyi dan gunakan setelah bebas

#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 . , , , , , ++ , ++- "".