{"id":4244,"date":"2024-06-28T12:20:07","date_gmt":"2024-06-28T17:20:07","guid":{"rendered":"https:\/\/www.darkreading.com\/application-security\/cisa-memory-unsafe-code-open-source-projects"},"modified":"2024-06-28T12:20:07","modified_gmt":"2024-06-28T17:20:07","slug":"cisas-flags-memory-unsafe-code-in-major-open-source-projects","status":"publish","type":"post","link":"https:\/\/ddi.mohflo.net\/index.php\/2024\/06\/28\/cisas-flags-memory-unsafe-code-in-major-open-source-projects\/","title":{"rendered":"CISA’s Flags Memory-Unsafe Code in Major Open Source Projects"},"content":{"rendered":"
<\/a><\/div>\n
<\/div>\n

A comprehensive new study has unearthed fresh details on the extensive and troubling use of memory-unsafe code in major open source software (OSS) projects.<\/span><\/p>\n

However, the chances that fresh insight on a long known issue will spur any immediate changes to the software landscape remain bleak, given just how enormous, costly, and complex the task is of rewriting codebases entirely in memory-safe code.<\/span><\/p>\n

Memory-unsafe programming languages such as C and C++ allow programmers to have more direct control over memory-related functions in code, which can often lead to very common application security issues like buffer overflows and use-after-free errors. Such flaws represent a large proportion of all vulnerabilities in modern application software. In contrast, memory-safe languages \u2014 the most common examples of which include Rust, Python, Java, and Go \u2014offer guardrails such as built-in runtime and compile time checks to mitigate against common memory related errors.<\/span><\/p>\n

Most OSS Projects Contain Memory-Unsafe Code<\/h2>\n

The US Cybersecurity and Infrastructure Security Agency (CISA) along with the FBI and counterparts at the Australian Cyber Security Centre and the Canadian Centre for Cyber Security this week <\/span>released a report summarizing the results<\/a><\/span> of their investigation into the use of memory-unsafe code in OSS.<\/span><\/p>\n

The findings, while troubling, are not entirely unexpected given past data on the extensive use of memory-unsafe languages in almost all modern codebases. Fifty-two percent of the 172 major open source projects that the research authors looked at contained code written in a memory-unsafe language. More than half (55%) of the total lines of code in all the projects combined were written in a memory-unsafe language, with the larger projects being the worst culprits.<\/span><\/p>\n

Some 95% of the total lines of code in Linux for instance are memory-unsafe. For MySQL Server, that number was 84%; for TensorFlow it was 64%; for Zephyr 84%; and for Chromium 51%. On average, 26% of the total lines of code in the 10 largest open source projects consisted of memory-unsafe code. Even projects written in memory-safe languages were at risk from dependencies on unsafe components.<\/span><\/p>\n

“Most critical open source projects analyzed, even those written in memory-safe languages, potentially contain memory safety vulnerabilities,” the report noted. “This can be caused by direct use of memory-unsafe languages or external dependency on projects that use memory-unsafe languages.”<\/span><\/p>\n

In addition, the tendency \u2014 and often the need \u2014 to disable memory-safety features to accommodate functional requirements in applications can often neutralize the benefits of using otherwise memory-safe languages.  <\/span><\/p>\n

“These limitations highlight the need for continued diligent use of memory safe programming languages, secure coding practices, and security testing,” the report authors noted.<\/span><\/p>\n

CISA Consistent With Previous OSS Data<\/h2>\n

The findings are consistent with numerous previous studies that have examined the extensive problems tied to the use of memory-unsafe languages.  <\/span><\/p>\n

And indeed, concerns over the ubiquity of the problem have prompted calls for change over the years. The most recent is a <\/span>February 2024 technical report from the White House<\/a><\/span> that urged industry stakeholders to go back to the building blocks and start over with using memory safe code in all software. In 2022, the US National Security Agency (NSA) urged software makers and all organizations developing software to <\/span>consider adopting memory-safe languages<\/a><\/span> to reduce risk from memory management related software issues in modern code bases. The continued pounding away at the topic over the years has <\/span>spurred some change<\/a><\/span>, but most expect it will take years \u2014 if not even decades \u2014 for a whole scale shift to memory-safe languages to happen.<\/span><\/p>\n

“Adopting memory-safe code is challenging, primarily because changing a programming language often requires a complete rewrite of existing code,” says Neatsun Ziv, CEO and Co-Founder of OX Security. The cost and effort required to undertake such a massive overhaul without significant economic incentives will likely make any change, a slow process.<\/span><\/p>\n

Making the World Memory-Safe: A Huge & Complex Challenge<\/h2>\n

Omkhar Arasaratnam, general manager at OpenSSF says memory safety issues aren’t specifically a problem for either open or closed-source software. It’s a problem in general for all modern software.<\/span><\/p>\n

“There are many memory-safe languages available today like JavaScript, Python, and Java, but software engineers often use memory-unsafe older languages like C\/C++ for performance or low-level hardware access,” he says.<\/span><\/p>\n

Also, while Rust has emerged as a viable alternative to C\/C++ for low level systems programming in recent years, there are many embedded systems and safety-critical applications for which Rust is not appropriate, he adds.<\/span><\/p>\n

“While it is certainly possible to write memory-safe code in a memory-unsafe language, 25 years of CVEs tells us it is highly unlikely,” Arasaratnam says. “It is not that people are bad programmers, but defensively writing code that is memory-safe in a memory-unsafe language is very difficult,” he notes. As newer projects adopt memory-safe languages, expect the use of memory-unsafe languages to decrease over time, in all but niche applications.<\/span><\/p>\n

Tim Mackey, head of software supply chain risk strategy at Synopsys Software Integrity Group, says the new report does a good job showing how some major open source software projects such as Kubernetes and WordPress are authored in a memory-safe language. However, there are other issues that remain unexplored, he says. For example, it would be interesting to know if memory-safe languages are being used in new projects on GitHub, and whether memory-safe libraries are being used as dependencies in larger projects.<\/span><\/p>\n

“We can safely say that awareness of memory safe languages is growing, but is it growing at a rate that would displace older languages? For example, are the creators of new embedded software solutions using C++ or Rust, and to what degree?”<\/span><\/p>\n

Source<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"

A comprehensive new study has unearthed fresh details on the<\/p>\n","protected":false},"author":12,"featured_media":4245,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[1],"tags":[809],"class_list":["post-4244","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-uncategorized","tag-dark-reading"],"featured_image_urls":{"full":["https:\/\/i0.wp.com\/ddi.mohflo.net\/wp-content\/uploads\/2024\/06\/cisas-flags-memory-unsafe-code-in-major-open-source-projects-scaled.jpg?fit=2560%2C1440&ssl=1",2560,1440,false],"thumbnail":["https:\/\/i0.wp.com\/ddi.mohflo.net\/wp-content\/uploads\/2024\/06\/cisas-flags-memory-unsafe-code-in-major-open-source-projects-scaled.jpg?resize=150%2C150&ssl=1",150,150,true],"medium":["https:\/\/i0.wp.com\/ddi.mohflo.net\/wp-content\/uploads\/2024\/06\/cisas-flags-memory-unsafe-code-in-major-open-source-projects-scaled.jpg?fit=300%2C169&ssl=1",300,169,true],"medium_large":["https:\/\/i0.wp.com\/ddi.mohflo.net\/wp-content\/uploads\/2024\/06\/cisas-flags-memory-unsafe-code-in-major-open-source-projects-scaled.jpg?fit=640%2C360&ssl=1",640,360,true],"large":["https:\/\/i0.wp.com\/ddi.mohflo.net\/wp-content\/uploads\/2024\/06\/cisas-flags-memory-unsafe-code-in-major-open-source-projects-scaled.jpg?fit=640%2C360&ssl=1",640,360,true],"1536x1536":["https:\/\/i0.wp.com\/ddi.mohflo.net\/wp-content\/uploads\/2024\/06\/cisas-flags-memory-unsafe-code-in-major-open-source-projects-scaled.jpg?fit=1536%2C864&ssl=1",1536,864,true],"2048x2048":["https:\/\/i0.wp.com\/ddi.mohflo.net\/wp-content\/uploads\/2024\/06\/cisas-flags-memory-unsafe-code-in-major-open-source-projects-scaled.jpg?fit=2048%2C1152&ssl=1",2048,1152,true],"chromenews-featured":["https:\/\/i0.wp.com\/ddi.mohflo.net\/wp-content\/uploads\/2024\/06\/cisas-flags-memory-unsafe-code-in-major-open-source-projects-scaled.jpg?fit=1024%2C576&ssl=1",1024,576,true],"chromenews-large":["https:\/\/i0.wp.com\/ddi.mohflo.net\/wp-content\/uploads\/2024\/06\/cisas-flags-memory-unsafe-code-in-major-open-source-projects-scaled.jpg?resize=825%2C575&ssl=1",825,575,true],"chromenews-medium":["https:\/\/i0.wp.com\/ddi.mohflo.net\/wp-content\/uploads\/2024\/06\/cisas-flags-memory-unsafe-code-in-major-open-source-projects-scaled.jpg?resize=590%2C410&ssl=1",590,410,true]},"author_info":{"display_name":"Dark Reading","author_link":"https:\/\/ddi.mohflo.net\/index.php\/author\/darkreading\/"},"category_info":"Uncategorized<\/a>","tag_info":"Uncategorized","comment_count":"0","jetpack_featured_media_url":"https:\/\/i0.wp.com\/ddi.mohflo.net\/wp-content\/uploads\/2024\/06\/cisas-flags-memory-unsafe-code-in-major-open-source-projects-scaled.jpg?fit=2560%2C1440&ssl=1","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/ddi.mohflo.net\/index.php\/wp-json\/wp\/v2\/posts\/4244","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ddi.mohflo.net\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ddi.mohflo.net\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ddi.mohflo.net\/index.php\/wp-json\/wp\/v2\/users\/12"}],"replies":[{"embeddable":true,"href":"https:\/\/ddi.mohflo.net\/index.php\/wp-json\/wp\/v2\/comments?post=4244"}],"version-history":[{"count":0,"href":"https:\/\/ddi.mohflo.net\/index.php\/wp-json\/wp\/v2\/posts\/4244\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ddi.mohflo.net\/index.php\/wp-json\/wp\/v2\/media\/4245"}],"wp:attachment":[{"href":"https:\/\/ddi.mohflo.net\/index.php\/wp-json\/wp\/v2\/media?parent=4244"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ddi.mohflo.net\/index.php\/wp-json\/wp\/v2\/categories?post=4244"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ddi.mohflo.net\/index.php\/wp-json\/wp\/v2\/tags?post=4244"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}