Technical Summary: Detecting Privilege Escalation in Polyglot Microservices via Agentic Program Analysis

Problem Statement

Microservice architectures, while offering scalability and fault tolerance, introduce significant complexity in permission control. These systems are often polyglot (implemented in diverse languages like Java, Python, Go) and distributed, making it difficult to ensure that privileged operations are properly protected.

The core challenge is detecting privilege escalation vulnerabilities, where attackers gain unauthorized access to resources or operations. Existing solutions fail to address this effectively due to three specific challenges:

1. Distributed and Heterogeneous Complexity (C1): A single request often spans multiple services with different languages and protocols (e.g., gRPC, REST, Kafka). No single service has a complete view of the end-to-end privilege enforcement logic, and traditional static analysis tools are typically single-language.
2. Semantic Understanding (C2): Identifying privilege escalation requires understanding the intent of code (e.g., recognizing that setUserRole is privileged) and the adequacy of security checks (e.g., distinguishing between general authentication and specific role eligibility). This goes beyond structural patterns like buffer overflows.
3. Correlating Checks and Operations (C3): Determining which authorization checks protect a specific operation requires tracing control and data dependencies across diverse structures (decorators, middleware, routers). Fixed analysis pipelines cannot adapt to the varying structural patterns of different applications.

Prior tools either focus on single-language taint analysis (e.g., MScan) or lack cross-service reasoning (e.g., CodeQL), while existing agentic solutions (e.g., EnIGMA) struggle with scalability when reading entire files as unstructured text.

Methodology: The NEO Framework

The authors present NEO, an agentic program analysis framework that combines Large Language Models (LLMs) for semantic reasoning with classic program analysis for scalable cross-service tracking. NEO operates through an iterative loop where an LLM agent orchestrates code search primitives to identify vulnerabilities.

1. Code Search Engine and Primitives

To bridge the gap between LLM reasoning and scalable analysis, NEO introduces a set of code search primitives built on top of CodeQL. These primitives abstract language-specific syntax into unified, language-agnostic interfaces, allowing the LLM to query the codebase without needing to generate complex, error-prone CodeQL queries directly. The core primitives include:

• Qname: Name-based lookup to find functions, variables, or types by identifier.
• Qast: AST-based lookup to identify syntactic patterns (e.g., method calls, field accesses) across languages.
• Qflow: Flow tracking to trace data propagation between elements within a service.
• Qcg: Call-graph traversal to explore interprocedural relationships (callers/callees).
• Qsource / Qinter / Qglobalflow: Specialized operations to identify data sources, inter-service communication points, and global cross-service flows.

2. Agentic Workflow

NEO decomposes the detection task into three interconnected phases:

1. Privileged Operation Identification: The agent uses LLM reasoning and code search primitives to identify operations that access sensitive resources or modify protected state. It validates candidates by retrieving source code (getSource()) and assessing semantic intent.
2. Cross-Service Flow Tracking: The agent constructs a global reachability graph. It traces data from external user inputs (sources) through inter-service communication channels to the identified privileged operations (sinks). This involves stitching intra-service flows (Qflow) with inter-service calls (Qinter).
3. Security Check Validation: For each flow, the agent traverses the path to locate authentication (authN) and authorization (authZ) checks. It uses the LLM to:
   • Localize checks: Find decorators, middleware, or inline logic protecting the operation.
   • Assess sufficiency: Determine if the check adequately protects the specific operation (e.g., verifying if a check validates specific role eligibility rather than just general access).
   • Validate path feasibility: Extract path constraints from conditional logic, convert them to SMT-LIB format, and use the Z3 solver to filter out infeasible paths (reducing false positives).

Key Contributions

1. Code Search Primitives: The design of a small set of unified, language-agnostic primitives that enable flexible and scalable code exploration across polyglot codebases, overcoming the limitations of direct LLM-based code reading.
2. NEO Framework: A novel agentic program analysis system that dynamically orchestrates these primitives with LLM reasoning to identify privileged operations, trace cross-service flows, and validate security checks.
3. Extensibility: Demonstration that the framework's core architecture can be adapted to detect other vulnerability types (e.g., command injection, SQL injection) and apply to generic (non-microservice) applications with minimal modification.

Evaluation Results

The authors evaluated NEO on 25 open-source microservice applications (spanning 7 languages and 6.2 million lines of code).

• Vulnerability Discovery: NEO uncovered 24 zero-day privilege escalation vulnerabilities in the evaluation corpus.
• Ground Truth Performance: On a ground-truth dataset of 4 applications containing 20 verified vulnerabilities, NEO achieved 81.0% precision and 85.0% recall.
• Comparison:
  • Compared to MScan (a state-of-the-art taint analysis tool), NEO found significantly more vulnerabilities, particularly those involving application-specific privileged operations.
  • Compared to CodeQL, NEO demonstrated superior capability in cross-service analysis.
  • Compared to EnIGMA (an agentic tool), NEO found 24 more vulnerabilities. EnIGMA often failed due to context exhaustion when reading entire files, whereas NEO's search primitives efficiently retrieved relevant context.
• Ablation Study: Removing code search primitives caused recall to drop to 4.8%, highlighting their necessity. Removing iterative context retrieval significantly increased false positives.
• Extensibility: In a separate study, NEO identified 18 additional zero-day vulnerabilities across other types (command injection, SQL injection) and generic applications.

Significance and Claims

The paper claims that NEO represents a significant advancement in automated security analysis for modern cloud systems. Its primary significance lies in successfully addressing the polyglot and distributed nature of microservices, a domain where previous tools have struggled.

By combining the semantic reasoning capabilities of LMs with the structural precision and scalability of static analysis, NEO overcomes the limitations of purely text-based agents (which lack scalability) and traditional static analyzers (which lack semantic depth and cross-language support). The authors assert that this agentic program analysis paradigm offers a promising direction for detecting complex, logic-based vulnerabilities that are difficult to identify through manual review or existing automated tools.

The work emphasizes responsible disclosure, with 18 of the 42 discovered vulnerabilities acknowledged by developers and 8 patched at the time of submission. The authors note limitations regarding dynamic language features (e.g., reflection) and configuration file analysis, which remain areas for future work.