Many of the most serious security flaws in widely used software come from one family of programming mistakes known as memory safety errors. This article explains what they are, what the US Cybersecurity and Infrastructure Security Agency (CISA) and the National Security Agency (NSA) recommend, and what that means for companies that build or buy software.
What is a memory safety vulnerability?
Every program stores data in a computer’s memory while it runs: a customer name, an image, a login token. A memory safety vulnerability appears when a program reads or writes memory it was never meant to touch. A program might write more data into a space than the space can hold, or keep using a piece of memory after it has been handed back to the system.
The results range from crashes to, in the worst cases, an attacker taking control of the program. Because the flaw sits in how the software handles its own memory, it often stays hidden until someone deliberately goes looking for it.
Older languages such as C and C++ leave memory management largely to the programmer. That gives developers fine control and speed, but it also means one slip can open a hole. Newer languages are designed so that the language itself manages memory and blocks whole categories of these mistakes. They are called memory safe languages.
How big is the problem?
CISA’s guidance on the urgent need for memory safety, written by CISA senior technical advisor Bob Lord and released September 20, 2023 (revised December 6, 2023), collects figures that major software organizations have published about their own code:
| Organization | Reported finding |
|---|---|
| Microsoft | About 70% of the vulnerabilities it assigns a CVE are memory safety issues |
| Chromium project (Google) | Around 70% of serious security bugs are memory safety problems |
| Mozilla | In one analysis, 32 of 34 critical or high-severity bugs were memory-related |
| Google Project Zero | Of 58 zero-day vulnerabilities in a year, 39 (67%) were memory corruption |
Two terms need unpacking. A CVE is an entry in the public catalog of known software vulnerabilities, each with its own identifier. A zero-day is a flaw that attackers exploit before the software’s maker has a fix.
The figures come from different organizations, years and methods, so they should not be added together or treated as a single industry average. They also come from large, security-conscious projects that publish their data. Still, the pattern is consistent enough that CISA treats the category as a priority.
The arithmetic is easy to check. Thirty-nine out of 58 zero-days is about 67%, matching the reported figure. Thirty-two out of 34 Mozilla bugs is about 94%, though that figure comes from a single analysis and should not be read as a general rate.
Why not just fix the bugs one by one?
The traditional response to memory errors has been patching: find a flaw, release a fix, repeat. Teams also use testing tools, code review and protections added around the program. All of these help, and none should be dropped.
The limitation is that they depend on continued effort. CISA’s article makes this point directly. Once code is written in a memory safe language, it requires no ongoing work to stay memory safe, unlike other mitigations (defensive measures that make flaws harder to exploit rather than removing them). A patch process catches a bug after it exists; a safer language prevents a large class of bugs from being written in the first place.
That is why the agency frames the issue as a design choice made early, not a cleanup chore carried out later. For readers who manage patching work, the companion piece on CISA’s patch prioritization directive shows how that cleanup side is handled when flaws do reach production.
What do CISA and its partners recommend?
CISA, working with the NSA, the FBI and cybersecurity agencies from several allied countries, published “The Case for Memory Safe Roadmaps” on December 6, 2023. It is part of CISA’s Secure by Design effort, which asks software makers to take ownership of security outcomes instead of leaving customers to absorb the risk. CISA describes the aim as practicing “radical transparency” and a top-down approach to developing secure products.
According to CISA’s September 2023 article, software manufacturers should:
- Make reducing, and eventually eliminating, memory safety vulnerabilities a top-level company goal.
- Publish a memory safety roadmap describing changes to the software development lifecycle, including a date after which new products or components will be built in a memory safe language.
- Support memory safety work in the open source libraries used in their supply chain.
- Investigate hardware mitigations, such as CHERI and memory tagging extensions.
- Investigate memory safe languages, such as Rust.
- Avoid ignoring the problem, because no single approach fits all products.
A roadmap, in this sense, is a public plan with dates. It signals that a vendor has decided where it is going, which matters to customers weighing long-term risk.
What did the 2025 follow-up add?
On June 24, 2025, CISA and the NSA released a joint guide titled “Memory Safe Languages: Reducing Vulnerabilities in Modern Software Development.” According to CISA’s announcement, the guide identifies memory safe languages as the most comprehensive mitigation for this class of flaw, because they include built-in safeguards that support security by design.
The 2025 document focuses on the practical side: the main challenges to adopting memory safe languages, ways to overcome them, and factors organizations should weigh when moving toward them. CISA directs the guidance at academia, the US government and private industry, and says it should be read alongside the earlier roadmaps document.
The announcement does not include new statistics, so the numbers above remain the best-known evidence cited in CISA’s own materials.
Does switching languages fix everything?
No, and the agencies do not claim it does. Memory safe languages remove one category of flaw. Software written in them can still contain logic errors, weak authentication, exposed secrets or insecure settings. Passwords, access rules and configuration mistakes remain separate problems, covered in cybersecurity basics for small teams.
Rewriting is also costly. Large existing programs often contain decades of accumulated behavior, and rewriting them risks introducing new errors. That is why CISA’s advice emphasizes roadmaps with phases and dates, and why it says no single approach fits all products. A sensible plan usually starts with new components and with the pieces most exposed to untrusted input, such as code that parses files or network traffic, and leaves stable older code to be replaced gradually or protected by other measures.
What should buyers of software ask?
Most readers of this magazine run companies that buy software instead of writing systems-level code. The guidance still gives them useful questions to put to vendors:
- Does the vendor have a published memory safety roadmap, or a comparable secure-by-design commitment?
- Are new components written in memory safe languages, and from what date?
- How does the vendor handle flaws in the open source libraries it depends on?
- How quickly does it publish fixes and security advisories?
A vendor that cannot answer these is not necessarily unsafe, but the answers help separate firms that treat security as a design goal from those that treat it as a patch queue. The same thinking belongs in a purchasing checklist; see how to evaluate a SaaS tool before you commit for a broader framework.
What can builders do this quarter?
Teams that write software can act without waiting for a grand rewrite:
- Take stock. List which products and components are written in C or C++ and which handle data from outside the company.
- Choose a safe default for new work. Set a date after which new components start in a memory safe language, as the CISA article suggests.
- Support dependencies. Track the open source libraries in use and contribute to, or at least monitor, their memory safety work.
- Keep the other defenses. Testing, code review and patching remain necessary during the long transition.
A direction, not a deadline
The core message from CISA and its partners is that a recurring, well-documented source of serious vulnerabilities can be designed out of new software instead of being chased forever after release. The published figures show why the agencies care, and the roadmap approach gives vendors a way to make progress visible. For buyers, the practical step is to ask about the plan; for builders, it is to decide on a date and start with new code.
This article provides general information and is not professional security or legal advice. Consult a qualified security professional about your own environment.
Sources: Cybersecurity and Infrastructure Security Agency
