Skip to the stories
AI & ML

How Malwarebytes Secures the Antivirus Service Running With System Privileges

  • Thomas Brown
  • 720 reads

Malwarebytes describes how it protects privileged components with layered checks, AI-assisted review, testing and signed fixes, while managing performance costs.

How Malwarebytes Secures the Antivirus Service Running With System Privileges

An antivirus has to inspect hostile files and protect the operating system, which means its own code becomes a high-value target. Malwarebytes says its Windows product limits that risk through checks between processes, security reviews throughout development, and a cycle that carries findings through fixes and follow-up tests.

Prevent, detect, fix, learn workflow.

The practical challenge is keeping those safeguards effective without making the product unstable or slow. Malwarebytes says security work takes roughly 10–20% of each development sprint, and that checks on privileged operations add some execution time. Those costs reflect a basic constraint: an antivirus must be difficult to disable, but its defenses must also keep working across varied Windows configurations.

A privileged service needs to distrust its callers

The product has two main components: a user interface running with the signed-in user’s permissions, and a background service running as SYSTEM. They communicate through COM, a Windows mechanism for calls between programs, including programs in separate processes.

Two layers, one boundary diagram

The interface can request actions such as adding a scan exclusion, restoring a quarantined file, or pausing real-time protection. The privileged service carries them out. That division limits what the interface can do directly, but it creates a boundary that needs careful checks: malware may want to exclude its own files or switch protection off.

The service also can’t assume that a request came from Malwarebytes’ interface. Another process running as the same user could create its own COM client and call the same methods. For each request, the service therefore needs to establish who is calling and whether that caller may perform the requested action. Authentication alone isn’t enough; permission must match the operation.

This boundary illustrates a broader engineering problem. Security software handles untrusted input, runs with extensive access, and depends on components that must work together. A change to protect one interface still has to preserve detection, performance and system stability.

AI shortens vulnerability investigations

Malwarebytes argues that AI is lowering the effort needed to investigate possible weaknesses. A typical investigation involves spotting a suspicious pattern, preparing test code and an environment, running tests, and interpreting the results. Models can help at each stage by explaining unfamiliar code, generating diagnostics, and making sense of compiler output, logs and debugger results.

That assistance changes who can investigate and how quickly an experienced engineer can test an idea. An engineer who understands Windows privileges and process boundaries can use AI to produce variations of a diagnostic client and run them under different accounts, integrity levels and configurations. The engineer still has to decide whether a result demonstrates a real security failure. A model on its own, Malwarebytes says, can’t reliably compromise an antivirus.

Agent systems extend the loop by connecting a model to code navigation, build tools, a debugger and a test environment. They can suggest a hypothesis, generate a test, observe what happens and refine the next test. The unresolved challenge is separating a suspicious code pattern from an exploitable flaw. Faster investigation makes that judgment more valuable, not less.

CNET Editors' Choice Award 2026

Several examples point to the wider use of AI in security research. Google reported in July 2025 that its Big Sleep agent found a critical SQLite flaw, CVE-2025-6965, that attackers already knew about; Google said the work stopped attackers from exploiting it. Mozilla confirmed 22 security-sensitive bugs found with Anthropic and fixed by Firefox 148, rating 14 of them high severity.

HackerOne reported 46,947 vulnerability submissions in March 2026, 76% more than a year earlier, while the share of findings it considered valid and exploitable remained about 25%. OpenAI reported in November 2026 that an autonomous pipeline using an unreleased model built working root exploits for 948 distinct Linux kernel local privilege escalation vulnerabilities in one scan. These examples differ in scope, but they reinforce the same operational point: finding flaws can accelerate.

Discovery needs a matching response

More findings are useful only if teams can validate and fix them. HackerOne’s 2026 report found that its backlog of valid, unresolved findings had grown 131% over two years, even as critical issues were being resolved faster. If discovery speeds up while remediation capacity stays flat, unresolved issues accumulate.

Malwarebytes describes its response as a continuous loop: prevent, detect, fix and learn. Before building a feature, engineers model how it could be attacked, what privileges it can reach and where it accepts untrusted input. Components receive only the privileges they need. The company also says its components authenticate and authorize each privileged request, and that it keeps exposed interfaces limited to defined entry points.

Secure coding rules cover memory handling, untrusted input and privileged operations. Code review and automated checks enforce those rules. Build settings add another layer: strict compiler warnings can flag risky code, while stack protection, control-flow integrity and address randomization make some remaining bugs harder to exploit.

Detection combines code review and hostile testing

Malwarebytes uses static analysis to find risky code patterns before execution, and dynamic analysis to catch memory and runtime errors in test builds. The company says it has also built an internal AI scanner that examines source code in context and follows untrusted data through the code.

A separate AI agent reviews every pull request for security concerns, including unsafe memory handling, missing validation and problems at privilege boundaries. Engineers still perform the regular review and assess the agent’s findings. AI-assisted review may widen coverage, but it adds noise: the company says an engineer checks every finding and proposed fix, and that its agents raise fewer false alarms as models and processes improve.

Testing also targets the inputs attackers might use against an antivirus itself. Malwarebytes says its release builds fuzz file parsers, unpackers and inter-process communication interfaces with malformed input and large data streams. Company-wide pipelines scan code repositories for exposed secrets, vulnerable dependencies and insecure configurations.

Fixes must protect the product as well as the system

Each reported issue is validated and reproduced, then assessed for the conditions an attacker would need to exploit it. Malwarebytes assigns a CVSS score, an owner and a deadline based on severity. The scoring helps structure priorities, but the engineering work continues after a weakness is understood.

For example, adding an authorization check between the interface and the privileged service sounds straightforward. In a mature antivirus, components may authenticate one another, start during boot, or run in the kernel. A poorly placed change can break the product. Malwarebytes says even a small patch in a large, long-lived codebase can cause a blue screen, slow the system or disrupt features for many users.

AI can help engineers inspect suspicious code, test whether a behavior is exploitable and compare potential fixes. Engineers review the final changes to confirm that a patch addresses the underlying weakness without causing regressions. Malwarebytes says updates are cryptographically signed and that critical security fixes are shipped first.

After a fix, the team adds a regression test and puts the input that triggered the problem into its fuzzing corpus. It also searches for the same pattern elsewhere, investigates how the flaw entered the code, and updates scanner rules, fuzzing targets and coding guidance. Tracking time to remediation helps the team check whether issues are being fixed within deadlines set for their severity.

The cost is time, testing and runtime work

Malwarebytes says security work consumes roughly 10–20% of every sprint, a share it protects from being redirected to feature development. Each fix adds tests that must be run and maintained. That work has an ongoing cost, but it also gives the team a way to catch a known flaw if it returns.

Checks between components, protections for files and processes, and more secure installation and updates also add work to product operations. Malwarebytes accepts that overhead to verify privileged actions and protect the product’s own code. The tradeoff for users is less visible: security changes need to block attacks while preserving the antivirus’s reliability and performance.

AI may keep reducing the time needed to identify and investigate vulnerabilities. Whether that leads to stronger products will depend on teams’ ability to verify findings, ship safe patches and check for related flaws. For software that runs with system-level privileges, the measure of progress is not just how quickly a weakness is found, but how reliably the fix reaches users and stays fixed.

Source: Thomas Brown · www.malwarebytes.com

From the same set