Using Claude to reduce the attack surface of code

Anthropic researcher Chris Rohlf published research on automated attack surface analysis and reduction, demonstrating how frontier artificial intelligence models can map reachable code paths and restrict exposed functions in deployed software. According to anthropic.com's report, Claude evaluated twenty-five open-source codebases spanning five million lines of code across C, C++, Java, PHP, and Python. The model identified 493 security issues by analyzing default configurations, configuration interactions, and early reachability across public, gated, and private software architectures.

This report details the findings and methodology of automated attack surface reduction, explaining how AI isolates unnecessary exposure before vulnerabilities can be exploited. The analysis is intended for software engineers, systems architects, and security teams managing complex networked applications or open-source infrastructure.

Using Claude to reduce the attack surface: what actually changed

The research shifts security defense from patching isolated bugs toward systematically constraining the reachability of exposed code. Anthropic tested Claude across twenty-five open-source projects containing more than five million lines of code, cataloging over 17,000 configuration options. From that inventory, Claude identified 3,842 settings directly tied to security-relevant controls. Analyzing those controls revealed 493 specific issues where code paths were unintentionally exposed or protections were weakened. Rather than hunting for memory corruption flaws, Claude mapped execution flows to identify routines that ran before authentication or remained reachable despite disabled settings.

The evaluated projects were divided into three operational categories to assess exposure profiles across distinct architectures. Ten projects fell into the public category, which process unauthenticated data from unknown sources like DNS resolvers and proxies. Eleven projects were classified as gated, designed strictly for authenticated users with valid passwords, certificates, or enrolled devices. Four projects formed the private cohort, built exclusively for an operator's internal environment. This breakdown allowed Claude to identify where software violated its deployment assumptions, particularly in gated software where unauthenticated exposure represents a severe architectural flaw.

Using Claude to reduce the attack surface: how it works

The analysis operates across three core evaluation methodologies: default configuration analysis, configuration interaction analysis, and early reachability mapping. In default configuration reviews, Claude identified code reachable in out-of-the-box deployments that supported no intended default functions. During configuration interaction checks, the model evaluated pairs of options that appeared safe alone but caused failures when configured together. For early reachability mapping, Claude traced complex routines that executed prior to security controls like authentication or before protocol state transitions. By modeling state machines rather than simple syntax, Claude flagged code left accessible to pre-session network callers.

Configuration interaction analysis uncovered 162 security-sensitive option pairs accepted without error messages, warnings, or documentation. In 94 of those cases, the combination silently turned off an active security control. The remaining 68 cases represented internal inconsistencies in security mechanisms. Network listeners or login paths remained reachable even when configuration parameters explicitly declared them disabled. In other instances, configured protections did nothing while their underlying code remained accessible, or two conflicting settings resolved based purely on the physical order of keys within a configuration file.

Using Claude to reduce the attack surface: why it matters now

Traditional vulnerability management relies on discovering and fixing individual bugs, an approach that scales poorly across large codebases. Fixing a critical vulnerability provides no assurance regarding remaining flaws in production. In contrast, reducing code reachability lowers the severity of both known and unknown bugs, including zero-day vulnerabilities under active exploitation. Moving exposed routines behind authentication or shifting features from zero-click processing to explicit opt-in eliminates attack vectors without requiring prior vulnerability discovery. When vulnerable routines cannot be reached by unauthenticated clients, underlying programming errors cannot be triggered by external attackers.

Software systems naturally accumulate complexity over time as developers add abstraction layers, third-party dependencies, and optional features. This code churn causes software to function differently than original maintainers designed, allowing adversaries to exploit real-world execution paths. Claude demonstrated that automated analysis can uncover these structural discrepancies at scale across C, C++, Java, PHP, and Python codebases. By converting security expectations into reachable execution tests, defensive teams can enforce least-privilege boundaries and prevent legacy code paths from remaining accessible to unauthenticated network actors.

Using Claude to reduce the attack surface: who is affected

The findings directly affect organizations running authenticated network services, as all eleven gated open-source projects contained unintentionally reachable code. Claude discovered 93 unnecessary pre-authentication surfaces within default configurations of these gated applications. Additionally, the model located 37 code locations where execution occurred or state was recorded before client authentication was completed. Another 61 configuration combinations silently weakened pre-authentication security controls set by administrators. While not immediately exploitable on their own, these pre-authentication exposures unnecessarily expanded the attack surface of services that operators assumed were protected behind access credentials.

System administrators managing access controls face subtle failure modes when combining security options. Claude identified a recurring issue across four unrelated projects involving access rules written with hostnames or wildcard patterns instead of IP addresses. When a client connected, the server compared the rule against the client hostname. Because reverse DNS lookups were disabled by default, the server only possessed the client IP address, which never matched a hostname pattern. Consequently, deny rules failed to match and access control lists failed open, granting access to disallowed clients without warning.

Using Claude to reduce the attack surface: what to watch

Engineering teams must monitor silent configuration interactions that completely bypass identity verification. In one evaluated codebase, administrators could configure a policy requiring connecting clients to present valid cryptographic certificates. When paired with a separate setting designed to delay verification until required by the protocol, the software failed to enforce the certificate check entirely. The server accepted connections from any client without verification, exposing an extensive body of request handling routines directly to unauthenticated actors. Because the software accepted both options together without warnings, administrators had no indication that authentication was bypassed.

Organizations adopting automated attack surface reduction should establish rigorous checks across configuration parsers, protocol state transitions, and pre-authentication handlers. Security teams must verify whether access rules rely on secondary mechanisms like reverse DNS lookups that might be disabled by default. Developers must also ensure configuration loaders reject conflicting option pairs rather than resolving precedence through file order or silently disabling protections. Integrating automated reachability analysis into continuous integration pipelines helps teams ensure code churn does not expose sensitive internal functions or allow gated services to accept unauthenticated external inputs.