An antivirus is also software, and it can have weaknesses of its own.
That makes antivirus development particularly demanding. The product must safely handle files that may be hostile, run reliably across very different Windows environments, and resist attackers who try to abuse its privileges or shut it down completely.
Imagine a piece of malware that can disable your antivirus and leave you unprotected. That’s exactly what we as engineers work to prevent.
The attack surface of a privileged process
You might wonder why vulnerabilities matter for a desktop application that runs locally.
Our software runs with high privileges, so it has access to the entire system. That access is what lets it protect the system from exploits, data theft, and ransomware. It also makes our software an attractive target. An attacker who can disable our protection, or abuse it to gain those privileges, has a much easier path to taking over the system.
Two layers, one critical boundary
At a basic level, Malwarebytes has two layers: a user interface running as the signed-in user, and a background service running as SYSTEM. They communicate through COM (Component Object Model), a built-in Windows mechanism that lets one program call functions in another program, even one running in a separate process.

The UI can’t do much on its own. When you add an exclusion, restore a file from quarantine, or pause real-time protection, the UI only asks, and the SYSTEM service does the work. Those are exactly the operations malware would like to perform: excluding its own folder from scanning or turning protection off.
And malware doesn’t need our UI to act. Any process running as the same user can write its own COM client and call the same methods. So on every call, the service must answer two questions: who is really calling, and is this caller allowed to do this specific operation?
This is just one small example of an attack surface we keep in mind and protect. An antivirus has many more, and every fix to any of them has to preserve protection, performance, and system stability.
AI is making vulnerabilities cheaper to find
Finding a vulnerability usually involves four stages, and AI now speeds up every one of them:
- Identifying possible weaknesses
- Preparing test code and an environment
- Running the tests
- Analyzing the results before trying again
AI is a multiplier not just in development or business processes, but in finding vulnerabilities as well.
AI can explain unfamiliar code, generate diagnostic programs, and interpret compiler errors, logs, and debugger output. That lets people attempt investigations that used to be beyond their skills or would have taken far longer, even though a model alone still can’t reliably compromise an antivirus.
An experienced Windows engineer already understands privileges, process boundaries, and common security mistakes, and they know which assumptions to question. AI turns those questions into tests without the engineer having to write every variation by hand. It can build a diagnostic client and repeat the same test under different user accounts, integrity levels, and configurations, while the engineer decides whether the results show a real security failure.
The next step is already here: agents that combine a model with code navigation, build tools, a debugger, and a test environment. They propose a hypothesis, generate a test, observe the result, and refine the investigation in a loop. The hard part is still verification: telling a suspicious pattern apart from a real weakness. But a few years ago, none of this was possible.
The evidence is accumulating:
- In July 2025, Google reported that its AI agent Big Sleep discovered a critical SQLite flaw (CVE-2025-6965) that attackers already knew about. Google says this stopped attackers from exploiting it.
- Mozilla confirmed 22 security-sensitive bugs found through its collaboration with Anthropic and fixed by Firefox 148. Mozilla rated 14 bugs from the work high severity.
- HackerOne reported a record 46,947 vulnerability submissions in March 2026, 76% more than a year earlier, with the share of valid, exploitable findings holding steady at about 25%.
- In November 2026, OpenAI reported that an autonomous AI pipeline running an unreleased model built working root exploits for 948 unique Linux kernel local privilege escalation (LPE) vulnerabilities in a single scan.
Vulnerabilities will be found in greater numbers and at greater speed, and teams need to be ready.
Finding is only half the problem
Discovering is easier, but fixing vulnerabilities still takes substantial engineering effort, and the industry is already feeling the gap. HackerOne’s 2026 report found that the backlog of valid, unresolved findings grew 131% in two years, even though critical issues are being resolved faster than before.
If discovery speeds up and remediation doesn’t, the backlog grows, and open vulnerabilities present an opportunity for an attacker.
For a security company, the goal is to get ahead of the pace of discovery, and that takes dedicated resources and focus.
How we keep pace: prevent, detect, fix, learn
The inter-process boundary from the example above is just one of many areas attackers may target, and new ones appear as the product grows. At Malwarebytes we approach security as a continuous engineering process.

防ぐ
Security by design. Before writing code, we build a threat model for each new feature: how could it be attacked, what privileges can it reach, and where does it accept untrusted input? Each component gets only the privileges its job requires, so a flaw in one part can’t easily lead to a full system compromise.
Zero trust between components. No component trusts another by default. Even our own processes must authenticate and be authorized on every privileged request, so a compromised or spoofed caller can’t ride on someone else’s trust. This is the per-call check the SYSTEM service runs in the two-layer example above.
Minimize the attack surface. Every interface we expose is something an attacker could probe, so we expose as few as possible. Features that aren’t needed are turned off, and privileged operations are reachable only through well-defined, authenticated entry points.
Secure development practices. Our engineers follow secure coding standards that define how to handle memory, untrusted input, and privileged operations, and which unsafe functions and patterns are not allowed. These rules are enforced in code review and by automated checks, not left to individual judgment. The compiler is part of our defense too: strict warning levels catch risky code at build time, and built-in protections such as stack protection, control-flow integrity, and address randomization make any remaining bugs much harder to exploit.
検出
Static and dynamic analysis. Memory-safety bugs such as buffer overflows and use-after-free errors are among the most common causes of arbitrary code execution. Static analysis catches dangerous patterns before code runs; dynamic analysis catches memory and runtime errors as they happen in our test builds.
An AI vulnerability scanner. We built an internal scanner using modern AI models for source code analysis. It reasons about context and follows untrusted data through the code.
AI security review on every pull request. A dedicated AI agent reviews every pull request purely for security: unsafe memory handling, missing validation, privilege-boundary problems, and more. Engineers still do the regular review, but every change, however small, gets security attention.
Fuzzing and hostile testing. Malware authors craft files to attack scanners, so our file parsers, unpackers, and inter-process communication (IPC) interfaces are tested with malformed data, huge data streams, and fuzzed input on every release build.
Company-wide pipelines continuously scan our repositories for exposed secrets, vulnerable dependencies, and insecure configurations.
Fix
Structured triage. Every finding, whatever its source, is validated and reproduced. We then establish what an attacker would need to do to exploit it, give it a CVSS score, and assign an owner with a deadline based on that severity.
Safe fixes. Let’s imagine an authorization vulnerability between layers is found. The obvious response is to add an additional check. In practice, that check is often tricky to get right. An antivirus is made up of many components that authenticate each other; some start at boot, and some run in the kernel. If one piece breaks, the whole product can fail.
In a large codebase with years of history, even a small patch can cause a blue screen of death (BSOD), slow the system down, or break features for millions of users at once. A security fix has to preserve protection, performance, and stability.
AI-assisted remediation. AI helps our engineers investigate suspicious code, test hypotheses about exploitability, and explore possible fixes. Engineers review every change to confirm it fixes the root problem without introducing regressions.
Safe delivery. Fixes reach users through cryptographically signed updates, with critical security fixes released first.
Learn
A vulnerability isn’t closed when the patch is merged. For each fix, we add a regression test and put the triggering input into our fuzzing corpus. We search for the same bug pattern elsewhere in the code, analyze why the flaw was introduced, and update our scanner rules, fuzzing targets, and coding guidelines. We also track time to remediation, so we can make sure that fixes are shipped on time according to their severity.
What this costs us
Running Prevent, Detect, Fix, and Learn as a continuous loop isn’t free, and we accept the costs on purpose.
The tradeoff on people is time.
Security work takes roughly 10–20% of every sprint. We guard that time, so it isn’t pulled into new feature development.
The tradeoff on AI review is noise.
AI pipelines review pull requests, scan source code, and propose fixes, but an engineer still checks every finding and proposal. Each month, as the models and our process improve, the agent raises fewer false alarms.
The tradeoff on testing is volume.
Every fixed vulnerability gets its own tests, so the same flaw can’t quietly return. That’s more tests to write, run, and maintain, but a regression in a security fix is a flaw we’ve already paid for once.
The tradeoff on runtime checks is execution time.
Verifying who is calling across the boundary, locking down our files, folders, and processes, and hardening installs and updates all add a little work to every operation. We accept that overhead so every task runs securely.
これはあなたにとって何を意味するのか
You won’t see most of this work, but it protects you every day:
- Protection that holds up under attack. Malwarebytes is designed so that malware can’t switch it off, tamper with it, or turn its privileges against you. We protect every point where attackers might try, from how components talk to each other to our own files and processes.
- Fixes don’t trade one problem for another. Every security fix has to keep protection, performance, and stability intact.
- Fixes reach you safely. They arrive as cryptographically signed updates, with critical security fixes first.
- Fixed stays fixed. Each fix gets a regression test, and we look for the same bug elsewhere in the code.
Security comes first
AI has lowered the cost of finding vulnerabilities, for defenders and attackers alike, and that shift isn’t slowing down. For a product that runs with the highest privileges on a machine and protects millions of users, the only durable answer is to keep up with, and get ahead of, the discovery of flaws. That’s why at Malwarebytes we treat security as one continuous loop—prevent, detect, fix, and learn—where every finding makes the next release stronger.
When your application protects other applications, its own security deserves the same attention as the threats it detects.





