betaFeedback

WorksComputer Science

Reparo: Synthesizing and Validating Access Control Policies

Abstract

Writing correct access control policies for software applications is difficult because it requires expertise in the authorization language and a thorough understanding of the application's authorization requirements. Existing synthesis and mining approaches assume explicit authorization inputs and a trusted reference policy. However, authorization logic is often distributed across code, comments, and documentation rather than captured in a single artifact, and developer-defined policies in real-world application repositories are often incomplete, outdated, or incorrect. We present Reparo, an LLM-aided pipeline for access control policy synthesis, repair, and validation. Reparo collects repository evidence for authorization intent and uses it to guide an LLM in generating an initial policy. It then uses official policy-language validation tools to identify and automatically repair errors. For semantic validation, a different LLM derives a behavioral oracle from the same repository evidence, consisting of concrete authorization requests with expected allow or deny decisions, which Reparo executes against the generated policy. We manually assess the oracle on a statistically sized sample of 390 test cases. We evaluate Reparo on 228 real-world GitHub repositories that use Cedar, OpenFGA, or Rego. In these repositories, 40.6-55.7% of the repository policies fail their language's validation tool, whereas Reparo produces 99.0-100% valid policies after repair. Agreement with the oracle is 98.2-99.6% for OpenFGA, 82.0-86.5% for Cedar, and 76.3-80.2% for Rego. Manual review confirms 91.5-96.9% of the sampled test cases as correct. Synthesizing and validating the policy for one repository takes about five minutes and costs 0.55−0.55-1.57. These results show that repository evidence can support both access policy synthesis and independent validation, even when no reliable reference policy exists.

CCS Concepts: • Security and privacy → Access control; • Software and its engineering → Software verification and validation.

Introduction

Modern cloud platforms provide specialized policy languages for defining fine-grained access-control rules [16, 45, 48]. Writing correct policies requires expertise in the language’s syntax and authorization model, as well as an accurate understanding of often complex and incompletely documented authorization requirements. Consequently, manual policy writing is tedious and error-prone [50, 70], and even small mistakes can have serious consequences [54]. Overly permissive policies may expose sensitive resources; for example, in 2023, Microsoft researchers accidentally exposed 38 TB of sensitive data by attaching an overly permissive token to a download link, granting full control over an internal storage account instead of a single dataset [44]. Overly restrictive policies, conversely, may deny legitimate users, disrupt functionality, and waste users’ time; in safety-critical domains such as health care, erroneous denials can have serious consequences [6].

Policy mining and reverse-engineering techniques attempts to solve this problem through inferring authorization rules from structured data, such as user–permission assignments [69], access

Authors’ Contact Information: Ayesha Binte Mostofa, [email protected], University of Massachusetts Amherst, Amherst, Massachusetts, USA; Gehao Zhang, [email protected], University of Massachusetts Amherst, Amherst, Massachusetts, USA; Sam Stern, [email protected], University of Massachusetts Amherst, Amherst, Massachusetts, USA; Juan Zhai, [email protected], University of Massachusetts Amherst, Amherst, Massachusetts, USA; Pubali Datta, [email protected], University of Massachusetts Amherst, Amherst, Massachusetts, USA. logs [15], and relationship graphs [9, 10], or from the application itself by analyzing authorization checks in code [21] or observing runtime behavior [30]. However, real-world repositories rarely provide such structured input: authorization information is spread across source code, comments, documentation, and policy files. Large language models (LLMs) make it feasible to integrate such scattered evidence, but their output may contain incorrect rules and must be validated. Existing LLM-based approaches leave three gaps. First, LLM-based policy synthesis translates an explicit specification, such as natural-language requirements or allowed and denied requests, into a policy [13, 22, 27, 29, 34, 47, 58, 59, 61, 62]. Writing a complete specification reintroduces the manual effort that automation seeks to remove. Second, LLM-based mining still requires structured authorization data, such as attributes, granted permissions, or access logs [4, 8]. Third, existing approaches validate against a trusted reference: an input specification [61], a ground-truth policy [4, 8], or a human-reviewed policy [62]. Real repositories rarely offer such a reference. The developer-written policy available in the repository, which we call the repository policy, cannot serve as one, because policy errors are common [6, 50, 70].

We therefore ask two questions. Can an executable policy that captures an application’s authorization intent be synthesized from its repository alone? And can that policy be validated without a trusted reference? The repository policy, which often contains errors, is used neither as input to synthesis nor as ground truth for validation. Our key insight is that the repository evidence used to synthesize a policy can, independently, also serve as the reference for validating it. Achieving this raises three challenges.

Challenge 1: Locating and reconciling scattered authorization logic. Authorization intent is rarely captured in a single artifact. It is scattered across source code, comments, and documentation, most of which concerns other behavior. Comments make up more than 20% of non-blank code lines in popular open-source repositories [23], documentation appears in 98% of sampled GitHub repositories [49], and authorization checks are sparse within millions of lines of code [21]. The challenge is to find the relevant fragments and reconcile incomplete or inconsistent information during policy synthesis.

Challenge 2: Producing valid executable policies across languages. Policy languages differ in both syntax and authorization semantics: Cedar uses entity schemas to express role, relation, and attribute-based rules [16], OpenFGA derives access from relations between objects defined in an authorization model [1], and Rego computes decisions through rules over structured input [37]. Thus, the same authorization requirement can take structurally different forms across languages. A synthesized policy must not only capture the intended authorization behavior but also pass the language’s native validator [1, 40, 43]. The challenge is to synthesize executable policies and automatically correct the errors to enable large-scale policy synthesis.

Challenge 3: Building a trustworthy oracle from the same evidence. A syntactically valid policy may still make incorrect decisions, so its behavior must be checked against an oracle, i.e., test cases pairing access requests with expected decisions. Such an oracle is rarely available in real repositories, and manually constructing one from scattered authorization evidence reintroduces the effort that automation seeks to eliminate. We therefore generate the oracle automatically using an LLM. However, LLM-generated test cases may be incorrect, ambiguous, unsupported by the evidence, or leave parts of the policy unexercised. Moreover, because the oracle and policy use the same evidence, their errors may be correlated, so agreement alone does not establish correctness. The oracle’s correctness and coverage must be measured.

To address these challenges, we present Reparo, an LLM-aided pipeline that synthesizes, repairs, and validates access-control policies from repository evidence. Reparo decouples synthesis from validation: one set of LLMs synthesizes the policy, and a different set derives the oracle used to validate it. For Challenge 1, Reparo retrieves relevant content from source code, comments, documentation, and never reveals the repository policy to the synthesis models. For Challenge 2, it guides generation with the target language’s grammar and examples, and iteratively repairs invalid policies using error messages from the language’s validator. For Challenge 3, the oracle models derive test cases from the same evidence, each pairing a concrete authorization request with an expected allow or deny decision. Reparo runs the synthesized policy on these test cases with the language’s policy engine and compares its decisions with the expected ones. We manually assess the LLM-generated oracle: a statistically sized sample of 390 test cases is reviewed for correctness. Moreover, we measure the extent to which the test cases exercise each policy.

To evaluate Reparo, we need real application repositories that express authorization intent. Existing datasets are often synthetic [26, 63], curated [7, 26], or small [26]. We therefore construct a benchmark of 228 real-world GitHub repositories that use Cedar [16], OpenFGA [1], or Rego [37], three policy languages with distinct authorization models. In this benchmark, 40.6–55.7% of the repository policies that were originally included by the developers fail their language’s validator [11, 40, 43], confirming that they cannot reliably serve as ground truth.

Reparo produces 99.0–100% valid policies after repair in all three languages. We measure correctness as decision agreement: the share of oracle test cases on which the policy returns the expected Allow or Deny decision. Decision agreement is 98.2–99.6% for OpenFGA, 82.0–86.5% for Cedar, and 76.3–80.2% for Rego. Manual review finds 91.5–96.9% of 390 sampled test cases correct. Our case studies further show that, when repositories contain sufficient authorization evidence, synthesized policies recover core authorization behavior and correct defects in the repository policy.

In summary, we make the following contributions:

  • Policy synthesis from repository evidence. We present Reparo, an LLM-aided pipeline that synthesizes access-control policies from code, comments, and documentation, without a separate specification, and repairs invalid policies using feedback from each language’s validator.

  • Validation without ground truth. We introduce a validation approach in which independent LLMs derive behavioral test cases from the same repository evidence, and the language’s policy engine checks the policy’s decisions against them. We also measure the correctness and coverage of these test cases.

  • Benchmark and evaluation. We construct a benchmark of 228 real-world repositories across Cedar, OpenFGA, and Rego, in which 40.6–55.7% of repository policies fail validation. Evaluated with proprietary and open-weight models, Reparo produces 99–100% valid policies, and its synthesized policies can correct defects in repository policies.

Background & Motivation

Access-control Policy & Language. An access-control policy determines whether a principal may perform an action on a resource under a given context. Permissions may be expressed through roles (RBAC), attributes (ABAC), or relationships such as ownership or membership (ReBAC). Modern applications increasingly implement such rules as policy as code, using dedicated policy languages. Cedar [16] defines rules over principals, actions, and resources and provides a schema specifying the entities used by policies. OpenFGA [1] and SpiceDB [3] derive access from relationships between users and objects [45], while Rego [37] uses logic rules over structured input. Unlike Cedar, OpenFGA and Rego do not provide an equivalent schema artifact. These differences make policy synthesis language-dependent, as the same authorization intent must be expressed and evaluated differently across languages. Native validators can detect syntactic and model-level errors [11, 40, 43].

Test oracles. A test oracle specifies the expected outcome against which observed behavior is compared [5]. For access-control policies, a test case pairs an authorization request with an expected Allow or Deny decision [35, 67]. Constructing such an oracle typically requires a specification of intended behavior or a trusted reference policy. Without either, expected decisions must be derived from other sources. LLMs have recently been used to generate tests from software artifacts [17, 60], but generated oracles still require empirical assessment.

Motivating example. Figure 1 shows a bookstore application from a real-world repository in our dataset. No single artifact specifies its full access policy: the README describes some requirements in prose, the schema defines entity types, attributes, and actions, comments record exceptions and explain derived values, and the code shows how the application constructs the entities checked by the policy. Thus, the authorization intent is distributed across multiple artifacts. We illustrate this with three aspects of the application’s authorization behavior: a publisher rule, a loyal-customer rule, and an exception to the publisher rule.

Figure 1. Authorization evidence across repository artifacts and access-control rules. Numbered fragments combine into three rules: Publisher (blue), Loyal-customer (green), and an Exception (red).

Publisher rule. The README (line 19) states that publishers can view their own books, but does not define what “own” means. The schema declares the View action and gives each Book an owner attribute of type User. The code in get_product.py (line 87) sets a book’s owner to the publisher’s username. Only together do these fragments yield the rule: a publisher may view a book when principal == resource.owner.

Loyal-customer rule. The README states that customers with at least two years of membership can view premium offers (line 393), and that users outside the US are denied access (line 308). A comment in shared.py (line 37) explains how the region is set: "UK" for the user Toby, and "US" otherwise. The schema shows that yearsAsMember is optional, while context.region is required. A correct policy must combine both README requirements and check that yearsAsMember is present before comparing it. Without this check, the policy fails validation.

Exception. A comment in get_product.py (line 209) states that the publisher Dante may access a specific book owned by William. This exception overrides the publisher rule.

This motivating example shows the three problems that REPARO must solve. First, the evidence for each rule is spread across four kinds of artifacts, and each fragment is incomplete on its own. The relevant fragments must be found among unrelated code and combined (Challenge 1). Second, the combined rule must be written as a valid policy, which here requires details such as the presence check on an optional attribute (Challenge 2). Third, there is no reference to check the resulting policy against. The expected decision for a request such as “may Dante view William’s book?” must itself be derived from the same fragmented evidence (Challenge 3).

Problem Statement

An authorization request is a tuple π=⟨p,a,r,c⟩\pi= \langle p, a, r, c \rangle of a principal pp, action aa, resource rr, and context cc. Let Π\Pi be the set of well-formed requests. A policy P:Π→{Allow,Deny}P : \Pi\to\{\text{Allow}, \text{Deny}\} maps each request to an access decision. We use PLP_L to denote a policy synthesized in language LL.

REPARO aims to synthesize a policy PLP_L that (i) is valid in language LL and (ii) is consistent with the application’s intended authorization behavior. Let R\mathcal{R} be an application repository and C⊆RC \subseteq\mathcal{R} the evidence used for policy synthesis, including source code, comments, documentation, and, for Cedar, the schema configuration file. Let P⊆R\mathcal{P} \subseteq\mathcal{R} denote the developer-written policy files, which we call the repository policy. We exclude P\mathcal{P} from C\mathcal{C} during policy generation.

We check property (i) using each language’s official validator, which checks syntactic validity as well as language-specific structural, type, or compilation constraints. However, we cannot directly measure property (ii) because the intended authorization behavior is not explicitly available, and the repository policy P\mathcal{P} may contain errors. Instead, Reparo builds a behavioral oracle TLT_L from C\mathcal{C} using models different from those used for policy synthesis. TLT_L consists of test requests paired with expected decisions TL(π)T_L(\pi). Semantic validation compares PL(π)P_L(\pi) with TL(π)T_L(\pi) for each test request, and is measured by decision agreement. Because TLT_L only approximates the intended authorization behavior, its quality is evaluated separately (RQ2).

Dataset Construction

Since no existing dataset provides the needed authorization evidence, Reparo constructs a dataset of real-world GitHub repositories using Cedar, OpenFGA, or Rego for access-control decisions, collected as of June 2026, to evaluate policy generation from repository-level authorization evidence. This proceeds in two stages: (1) repository selection, in which candidate repositories are discovered and filtered, and (2) extraction of the evidence C\mathcal{C} from each selected repository.

Repository Selection. Repositories are identified on GitHub using language-specific files: .cedar for Cedar; .fga, .openfga, and OpenFGA JSON model files for OpenFGA; and .rego for Rego. These files constitute each repository’s policy P\mathcal{P}. We count policy rules, the smallest units of P\mathcal{P}. A Cedar permit or forbid statement, OpenFGA relation definition, and top-level Rego allow or deny rule, including helper rules, counts as one rule. We require at least five policy rules to ensure substantive use of the policy language, and stars+forks ≥5\ge5 at collection time to indicate minimum public interest and reduce toy or example repositories.

Authorization-Relevant Context Extraction. Reparo retrieves scattered authorization evidence using BM25 [53], which ranks repository content against queries representing authorization concepts. We define retrieval files S⊆R\mathcal{S} \subseteq\mathcal{R} whose text provides the application’s authorization vocabulary, including entity types, relations, and actions.

For Cedar, S\mathcal{S} consists of entity schema files defining principals, resources, and actions. Because OpenFGA and Rego lack separate schema files, we use the repository policy files instead, i.e., S=P\mathcal{S} = \mathcal{P}. Even invalid policies provide useful retrieval terms through application-specific identifiers. For Cedar, we identify schema files by the .cedarschema, .cedarschema.json, or .json extensions with ‘schema’ in the filename. JSON schemas are converted to Cedar’s schema format using the Cedar CLI; files that fail conversion are discarded.

Algorithm 1 shows the context extraction process. Source code, README documentation, and comments are split along their natural structure rather than into fixed-size windows (Lines 1–3): code into top-level functions and classes via language-aware AST parsing, documentation by section headings, and comments and docstrings kept with nearby code when needed to preserve their meaning.

Algorithm 1: Authorization-relevant context extraction

Input: Repository R\mathcal{R}; retrieval files S\mathcal{S}; repository policy P\mathcal{P}; threshold τ\tau

Output: Relevant context C\mathcal{C}

  1. Craw←∅\mathcal{C}_{\mathrm{raw}} \gets\varnothing;

  2. for t∈{CODE,README,COMMENT}t \in\{\text{CODE}, \text{README}, \text{COMMENT}\} do Craw←Craw∪SEGMENT⁡(R,t)\mathcal{C}_{\mathrm{raw}} \gets\mathcal{C}_{\mathrm{raw}} \cup\operatorname{SEGMENT}(\mathcal{R},t);

  3. foreach c∈Crawc \in\mathcal{C}_{\mathrm{raw}} do score⁡(c)←SCORE⁡(c,Craw)\operatorname{score}(c) \gets\operatorname{SCORE}(c,\mathcal{C}_{\mathrm{raw}});

  4. C′←DEDUP⁡(Craw)\mathcal{C}' \gets\operatorname{DEDUP}(\mathcal{C}_{\mathrm{raw}});

  5. C′←REMOVEPOLICYLEAKS⁡(C′,P)\mathcal{C}' \gets\operatorname{REMOVEPOLICYLEAKS}(\mathcal{C}',\mathcal{P});

  6. foreach c∈C′c \in\mathcal{C}' do score⁡(c,C′)←SCORE⁡(c,C′)\operatorname{score}(c,\mathcal{C}') \gets\operatorname{SCORE}(c,\mathcal{C}');

  7. C←{c∈C′:score⁡(c)>τ}\mathcal{C} \gets\{c \in\mathcal{C}': \operatorname{score}(c) > \tau\};

  8. return C\mathcal{C};

  9. Function Score⁡(c,D)\operatorname{Score}(c,\mathcal{D}):

  10. return

max⁡sj∈S(BM25⁡D(c,sj)+βt(c)BM25⁡D(Ctx⁡(c),sj))\max_{s_j \in\mathcal{S}} \left(\operatorname{BM25}_{\mathcal{D}}(c,s_j) + \beta_{t(c)}\operatorname{BM25}_{\mathcal{D}}(\operatorname{Ctx}(c),s_j)\right)

Chunks are ranked with the BM25 ranking algorithm. Score⁡(c,D)\operatorname{Score}(c, \mathcal{D}) (Lines 12–13) scores chunk cc relative to a chunk set D\mathcal{D}, using the tokenized full text of each file sj∈Ss_j \in S as a query. The score combines the BM25 score of a chunk with that of its surrounding context. Each chunk takes its highest score across retrieval files, since a chunk may be relevant to one retrieval file but not to others. All chunks are first scored relative to CrawC_{\mathrm{raw}} (Lines 4–5). Duplicate chunks are removed (Line 6), as are chunks that have content of P\mathcal{P} (Line 7). Because BM25 term weights depend on the chunk set, removing these chunks makes the initial scores stale. So, the remaining chunks are rescored relative to C′C' (Lines 8–9), and those scoring above τ\tau form the final context CC (Line 10).

Dataset Characterization. The resulting dataset contains 228 repositories: 53 for Cedar, 75 for OpenFGA, and 100 for Rego. As indicators of practical deployment, we detect each repository’s cloud provider and containerization with a rule-based scanner. For each repository, the README and deployment-related files are examined, prioritizing CI workflows, infrastructure-as-code templates (e.g., Terraform, CDK), platform manifests (e.g., wrangler.toml, vercel.json), and container files. Files are matched against weighted provider-specific patterns (e.g., arn:aws: for AWS), and each repository is assigned the highest-scoring provider. A provider is identified for 124 repositories: AWS (74), GCP (17), Azure (11), and 22 across Cloudflare, Vercel, Netlify, Heroku, DigitalOcean, and Fly.io. Containerization is common, covering 50 of 74 AWS and 12 of 17 GCP repositories, and 42 of the 104 repositories without a provider. In total, 166 of 228 repositories (72.8%) show concrete deployment evidence.

Methodology

Section § 4 extracts the authorization-relevant evidence CC for each repository: code, comments, and documentation ranked by Algorithm 1. This section describes how Reparo uses that evidence to synthesize an access-control policy and to validate it, without requiring a separate specification.

Figure 2 summarizes the workflow. Starting from CC, Reparo runs two separate tracks. The synthesis track (§ 5.1) generates a policy with an LLM, assesses its policy validity using the language’s validation tool, and repairs any reported errors. The validation track (§ 5.2) uses a different model to derive behavioral test cases from the same evidence. Reparo then evaluates the synthesized policy on these test cases using the language’s policy engine and measures decision agreement with the expected outcomes.

Figure 2. Reparo overview: (1) evidence extraction; (2) policy generation with validator-guided repair; (3) independent test-case generation; (4) semantic validation with feedback to refine test cases; Dashed red arrows denote repair feedback.

The validation result is useful beyond a single agreement score. Each mismatch identifies a concrete request on which the policy’s decision differs from the decision the evidence supports, together with the evidence lines behind the expected decision. A developer can use these mismatches to locate and edit a faulty rule, or to discard a test case that misread the repository evidence CC. We use the bookstore repository from § 2 as a running example throughout this section.

Policy Synthesis & Repair

Policy Synthesis

An LLM recovers the repository’s implicit authorization intent as a policy PLP_L, where L∈{Cedar,OpenFGA,Rego}L \in\{\mathrm{Cedar}, \mathrm{OpenFGA}, \mathrm{Rego}\}. The model receives the repository evidence CC together with language-specific guidance; for Cedar, the schema is also provided during generation because it defines the entity types and attributes required to validate PLP_L. The repository policy P\mathcal{P} is never provided.

Prompt variants. We attempted four prompt variants for each language for this synthesis task. The baseline, I, contains the task description, the repository evidence CC, extraction instructions, a self-verification step, and the output format. GI adds the syntax and key rules of the target language, taken from the official Cedar [12], OpenFGA [42], and Rego [38, 39] grammars. FI adds few-shot examples, and GFI combines the grammar and few-shot examples. Each few-shot example shows an incorrect policy, its validator error logs, and the corrected policy. The examples cover most frequent policy generation errors, including incorrect attribute or relation references, invalid expressions, unsafe variables, deprecated features, and violations of the schema or authorization model.

The model is instructed (Figure 3) to identify the principal, action, resource, and conditions that define each authorization behavior. Code is used to identify authorization logic, such as role and permission checks, ownership; comments capture intent, exceptions, and edge cases not evident from the code; and the README conveys the system’s roles, resources, and high-level access model. When sources show conflicting evidence, the source code behavior is prioritized. These examples are generic and do not leak information from the repository being evaluated. Our evaluation shows that the GFI prompt improves policy generation the most, while the I prompt produces substantially more errors (see § 6.1).

Figure 3. High-level structure of the policy-generation prompt.

Figure 4 shows the policy synthesis of the Publisher rule. The README states that publishers can view their own published books, while the code represents ownership through the owner attribute of a Book; the generated policy combines these two pieces of evidence into the Publisher rule of § 2. We show the repository policy P\mathcal{P}, which is valid and correct for this repository, as a reference to demonstrate that the generated policy captures the intended authorization behavior.

Figure 4. The Publisher rule synthesized from schema, code, and README evidence; arrows map each fragment to the policy element it determines. The repository policy is shown for reference.

Policy Validation and Repair

A policy PLP_L is valid (objective (i), § 3) if it passes the language-specific validator for LL without errors: the Cedar policy validator, opa check for Rego, and fga model validate for OpenFGA [11, 40, 43]. These validators check syntactic validity as well as language-specific structural, type, or compilation constraints, but do not establish that the policy captures the repository’s intended authorization behavior. When PLP_L fails validation, an LLM repairs it, modifying only what is necessary to resolve the errors. The repaired PLP_L is checked again, and the loop continues until PLP_L is valid or the attempt limit is reached. The limit is two attempts for OpenFGA and Rego, whose outputs are validated as a single authorization model, and four for Cedar, whose policies contain multiple statements that can fail independently.

Prompt variants. Three repair variants differ only in the supporting information provided. In EL (error log), the model receives the invalid policy and its validator error log. In FS-C (few-shot correct), it receives the invalid policy and three structurally similar valid policies from other repositories, retrieved using BM25. We exclude the target repository’s own policy PP so that the LLM cannot simply copy the target policy, particularly because repository policies may themselves contain errors. In FS-R (few-shot repair), it receives the invalid policy and three similar repair examples, each consisting of an invalid policy, its validator error log, and the corrected policy. All variants share the same instructions and output format. Among these variants, EL performs best and is used in the main repair experiments (see § 6.1). Figure 5 illustrates an EL repair of the Loyal-customer rule of § 2. The generated policy incorrectly accesses the optional attribute principal.yearsAsMember without first checking its presence, which the Cedar validator rejects as unsafe. The LLM adds the required check. Policy validation establishes only that PLP_L is well-formed; whether its decisions match the repository’s intended authorization behavior (objective (ii)) is validated in § 5.2.

Figure 5. Error-log-guided repair: the validator error (red) flags unsafe access to an optional attribute, and the LLM adds the required fix (green). The repository policy is shown for reference.

Semantic Validation

REPARO constructs a behavioral oracle TLT_L from the evidence C\mathcal{C} used for policy synthesis. The oracle provides validation tests that capture the authorization behavior implied by this evidence, allowing us to assess whether the generated policy captures the repository’s intended behavior. This section describes how REPARO constructs TLT_L and uses it for semantic validation.

Oracle Generation

For each repository, the oracle TLT_L consists of test cases containing a request, the entity or relationship data needed to execute it, and an expected ALLOW or DENY decision. Tests are generated from the same evidence as the policy, but using distinct model families to reduce self-preference bias [46], where a model favors outputs similar to its own.

Prompt variants. Two variants are evaluated. The baseline, I, contains the task instructions, the evidence, and the output format. GI adds the grammar and formatting rules of the target language, so that requests use the representation expected by its evaluator. Between the two, GI produces more executable test cases and is therefore used in the main experiments. Since each test case must use the names the policy under test expects, the oracle model receives only the interface of PLP_L: its types and relation names for OpenFGA, and its input variables for Rego. For Cedar, the schema already fixes this interface, so no information from PLP_L is provided. For each authorization scenario supported by CC, the model identifies the principal pp (who is requesting access), action aa (what they want to do), resource rr (what they want to access), and context cc, and constructs a complete test request. When the evidence supports both outcomes, it generates paired Allow and Deny cases by varying a single evidenced condition, principal, resource, or relationship while keeping the rest of the scenario fixed. Each test case records a short rationale, the line numbers of supporting evidence, and any conflicting evidence, making every expected decision traceable to repository evidence CC.

Figure 6 continues the running example with a test case for the Publisher rule of § 2. The code at get_product.py:87 shows that the repository records a book’s publisher in its owner attribute, and line 405 binds a concrete book to the user William. The test therefore instantiates William as a member of Role::"Publisher" and a book whose owner is William, and issues a request in which William views that book. Since the README permits publishers to view their own books, the expected decision is Allow.

Figure 6. An oracle test case derived from code and README evidence, consisting of entity data, a request, and the expected decision (Allow); arrows trace each field to its source.

Semantic Validation & Oracle Refinement

Non-executable test cases are set aside, and the remaining cases are executed against PLP_L. Semantic validation checks whether the policy makes the same Allow or Deny decision as the oracle for each executable test request. Reparo then refines the oracle test suite based on the generated policy and its coverage. We compile a coverage report identifying non-executable test cases, disagreeing test cases with PLP_L, and policy rules that are not exercised by the test suite. For each disagreement, Reparo initially treats the test case as semantically invalid and re-checks it by re-deriving its expected decision from the repository evidence. If the evidence supports the oracle decision, the disagreement indicates incorrect policy behavior.

Prompt. The refinement prompt uses a similar GI prompt structure and repository evidence as oracle generation, together with the coverage report. The report guides which cases to refine, while expected decisions remain based solely on repository evidence CC. The model re-derives expected decisions for flagged cases, corrects invalid requests and their entity data, and adds cases for uncovered rules and under-covered conditions. New test cases are added only when supported by the evidence, and refined cases are returned in the same structured format. Figure 7 shows a refinement from the same bookstore repository. The original test case expected Deny, but the policy returned Allow. Re-derivation showed that a code comment indicates that the requesting user may access the specific book, revealing that the original case had misinterpreted the evidence. Therefore, the expected decision is corrected to Allow.

Figure 7. Test-case refinement: a case that wrongly expected Deny is re-derived from a comment and corrected to Allow.

Experimental Design

Model Selection. Reparo is evaluated with four contemporary models from distinct providers: Claude Sonnet 5 [2], DeepSeek-V4-Pro [18], GPT-5.4 [41], and GLM-5.2 [71]. The models are accessed through their providers’ APIs.

All four are first benchmarked on policy generation with the GFI (Table 1) prompt on a pilot set of 8 repositories per language. Claude Sonnet 5 and DeepSeek-V4-Pro achieve the highest policy validity (§ 5.1.2), with 100% of Cedar policy statements and OpenFGA authorization models passing validation and 87.5% of Rego authorization models. GPT-5.4 achieves 98.3%, 100%, and 75.0%, while GLM-5.2 achieves 97.9%, 87.5%, and 75.0%, for Cedar, OpenFGA, and Rego, respectively. Claude Sonnet 5 and DeepSeek-V4-Pro are therefore used for policy generation and repair, and GPT-5.4 and GLM-5.2 for oracle generation and refinement.

PhaseVariantInformation
Policy generationIEvidence + instructions
Policy generationGII + grammar
Policy generationFII + few-shot examples
Policy generationGFI★I + grammar + few-shot
Policy repairEL★Invalid policy + error log
Policy repairFS-CInvalid policy + 3 valid policies
Policy repairFS-RInvalid policy + 3 repair examples
Oracle generationIEvidence + instructions
Oracle generationGI★I + test-case grammar
Oracle refinementGIGI + coverage report

Table 1. Prompt variants per phase. ★ marks the best-performing variant.

Retrieval Configuration. Supplying the full repository is often infeasible and, even when it fits, undesirable: LLM performance degrades when relevant information is embedded in long contexts [32], while retrieval improves performance across context-window sizes [68], including repository-level code tasks with information scattered across files [72]. Reparo therefore supplies only the evidence CC selected by Algorithm 1.

Since the amount of authorization-relevant evidence varies across repositories, a fixed top-kk cutoff may discard useful evidence or include irrelevant content. We instead use a score threshold τ\tau, selected through a pilot study on six repositories, two per language, with τ∈{0,10,20,30,40,50}\tau\in\{0, 10, 20, 30, 40, 50\}. We manually inspect the retrieved contexts and resulting policies for each value and select τ=20\tau= 20, which removes weakly related chunks. When the selected evidence fits within the context window, we include all of it. Otherwise, chunks are added in decreasing relevance-score order until the context window is reached.

Design-Choice Ablations

The following ablations determine the configuration used in the main experiments. They are conducted with DeepSeek-V4-Pro on 20% of each language’s repositories: 12 Cedar, 15 OpenFGA, and 20 Rego repositories.

Policy Generation Prompt Variants. The four generation variants (I, FI, GI, GFI) are compared in Table 2. GFI, which combines grammar and few-shot guidance, achieves the highest pre-repair policy validity in all three languages: 100% for Cedar, 93.3% for OpenFGA, and 90.0% for Rego. The two components help differently across languages. Grammar

Lang.VariantPre-repairPost-repair
CedarI74/84 (88.1%)84/84 (100%)
CedarFI76/81 (93.8%)81/81 (100%)
CedarGI88/89 (98.9%)89/89 (100%)
CedarGFI86/86 (100%)86/86 (100%)
OpenFGAI11/15 (73.3%)15/15 (100%)
OpenFGAFI12/15 (80.0%)15/15 (100%)
OpenFGAGI13/15 (86.7%)15/15 (100%)
OpenFGAGFI14/15 (93.3%)15/15 (100%)
RegoI12/20 (60.0%)19/20 (95.0%)
RegoFI14/20 (70.0%)19/20 (95.0%)
RegoGI11/20 (55.0%)20/20 (100%)
RegoGFI18/20 (90.0%)20/20 (100%)

Table 2. Policy validity per generation prompt, before and after error-log repair.

guidance (GI) yields the larger gain for Cedar and OpenFGA, whereas few-shot examples (FI) yield the larger gain for Rego, where grammar alone slightly reduces validity relative to I. GFI is used in the main experiments.

Finding 1. Grammar guidance provides the largest gains for Cedar and OpenFGA, and few-shot examples for Rego; combining both (GFI) yields the most reliable generation in all three languages and reduces the repair required.

Policy Repair Prompt Variants. The three repair variants (EL, FS-C, FS-R; see Table 1) are applied to all invalid policies produced across the four generation variants in Table 2: 16 Cedar statements, 10 OpenFGA models, and 25 Rego policies. A repair succeeds if the policy becomes valid within the attempt limit. EL performs best, repairing all Cedar and OpenFGA policies and 92% of Rego policies. The two remaining Rego failures illustrate the limits of validator-guided repair: in one, the policy used a deprecated language feature for which the validator suggested no replacement; in the other, the policy required restructuring to resolve a dependency. FS-C repairs none of the invalid policies.

VariantCedarOpenFGARego
EL16/16 (100%)10/10 (100%)23/25 (92%)
FS-C0/16 (0%)0/10 (0%)0/25 (0%)
FS-R16/16 (100%)9/10 (90%)18/25 (72%)

Table 3. Share of invalid policies repaired by each repair prompt variant.

This result suggests that examples of correct policies alone provide limited guidance for repairing an invalid target policy. Without information about the error, the model may reproduce content from the retrieved examples or return the target unchanged. Correct policies therefore do not indicate what is wrong with the target. FS-R, which provides explicit error-to-repair examples, performs substantially better but remains below EL. We use EL in the main experiments; it also requires no additional example retrieval.

Finding 2. Repair depends on error-specific guidance. Correct-policy examples alone are ineffective, error-to-repair examples help substantially, and the target policy’s own validator feedback is the most effective solution.

Oracle Generation Prompt Variants. The instruction-only (I) and grammar-augmented (GI) oracle variants are compared on the same subset. GI produces a higher proportion of executable test cases and is used in the main experiments.

Evidence sources. To assess whether combining different evidence sources is necessary, we either remove each source from CC or use it alone. This ablation is run on the 12 Cedar repositories using DeepSeek-V4-Pro and evaluated against a generated test oracle containing 442 test cases derived from the same evidence. We also provide the schema during generation because it is required by the policy validation tool. Table 4 shows that removing any single source reduces decision agreement, because each source provides complementary authorization information. Removing a source also reduces the number of generated policies, from 86 with all sources to 64 without code, 53 without comments, and 40 without documentation. The

SettingValid PolicyDecision Agreement
All sources (Reparo)86/8691.9%
Leave one source out
− Code64/6458.4%
− Comments53/5355.9%
− Docs40/4147.7%
Single source
Code onlya^{a}47/4763.8%
Docs onlyb^{b}54/5557.9%
Comments only52/5252.0%

Table 4. Policy validity and decision agreement when evidence sources are removed or used alone (12 Cedar repositories).

a^{a}Input setting of code-based extraction [19, 21, 31]; b^{b}input setting of NL-to-policy generation [22, 61, 64]. single-source settings serve as input-setting baselines: they reproduce the inputs available to prior code-based [19, 21, 31] and NL-to-policy [22, 61, 64] approaches within the same pipeline, isolating the effect of combining evidence sources. Decision agreement reaches 63.8% with code only and 57.9% with documentation only, compared with 91.9% with all sources.

Finding 3. Combining heterogeneous evidence sources is necessary for faithful policy generation. Removing any single source reduces agreement, mainly by omitting authorization rules, and the single-source settings corresponding to code-based extraction and NL-to-policy generation reach only 63.8% and 57.9%, compared with 91.9% for Reparo.

Evaluation

We evaluate Reparo through the following research questions:

RQ1: To what extent can LLMs generate valid access-control policies from repository evidence CC, and how well do their authorization decisions agree with independently generated oracles TLT_L?

RQ2: How reliable and comprehensive are the generated behavioral test oracles TLT_L?

RQ3: How and why do generated policies PLP_L differ from the repository policies PP?

We additionally report the per-repository cost of Reparo, including token consumption, API cost, and execution time for policy generation, repair, oracle generation, and refinement.

RQ1- Policy Synthesis: RQ1 assesses the generated policy PLP_L through policy validation and semantic validation. Policy validity is the proportion of generated policies accepted by the corresponding language-specific validator. Semantic validation uses the behavioral oracle TLT_L, which consists of test requests paired with expected authorization decisions: each test request is executed against PLP_L, and the returned decision is compared with the oracle’s expected decision. Semantic validation is measured by decision agreement, the fraction of executable test cases for which the Allow/Deny decision returned by PLP_L matches the oracle’s expected decision.

Policy Validity. Table 5 reports policy validity before and after repair. After repair, Claude Sonnet 5 reaches 100% validity in all three languages, and DeepSeek-V4-Pro reaches 99.1% for Cedar, 100% for OpenFGA, and 99.0% for Rego. Repair contributes most for the weaker starting points, e.g., raising DeepSeek-V4-Pro from 89.3% to 100% on OpenFGA and Claude Sonnet 5 from 89.0% to 100% on Rego.

ModelLang.Pre-repair (GFI)Post-repair (EL)
Claude S5Cedar880/887 (99.2%)887/887 (100%)
Claude S5OpenFGA73/75 (97.3%)75/75 (100%)
Claude S5Rego89/100 (89.0%)100/100 (100%)
DeepSeek V4Cedar816/862 (94.7%)854/862 (99.1%)
DeepSeek V4OpenFGA67/75 (89.3%)75/75 (100%)
DeepSeek V4Rego93/100 (93.0%)99/100 (99.0%)

Table 5. Policy validity (valid/total) on all 228 repositories, before and after repair.

All eight invalid Cedar policy statements generated by DeepSeek-V4-Pro after repair come from a single repository and involve language- and schema-level errors, such as comparisons between incompatible types and invalid use of language constructs; the validator flags them, but its error log does not indicate the correct repair. The invalid Rego policy after the repair

stage depends on TFLint-specific built-ins that the repository’s repository policy also uses; since the validator error log does not describe such library dependencies, the repair model cannot infer the required execution environment.

Semantic validation. Table 6 reports how often the synthesized policies agree with the oracles. Decision agreement differs little across model pairs, but strongly across languages: 98.2–99.6% for OpenFGA, 82.0–86.5% for Cedar, and 76.3–80.2% for Rego. This pattern is explained by how many conditions a decision depends on (see test-case complexity in RQ2). Most OpenFGA test cases depend on zero or one condition, while more than a third of Cedar and Rego cases depend on six or more. Thus, repair makes nearly every policy valid, but agreement still drops as actual authorization decisions combine more conditions.

Lang.PolicyOracleDecision Agreement
CedarClaude S5GPT-5.486.5% (n=1213n=1213)
CedarDeepSeek V4GPT-5.485.0% (n=1130n=1130)
CedarClaude S5GLM-5.282.9% (n=1063n=1063)
CedarDeepSeek V4GLM-5.282.0% (n=1060n=1060)
OpenFGAClaude S5GPT-5.498.3% (n=4224n=4224)
OpenFGADeepSeek V4GPT-5.499.6% (n=4135n=4135)
OpenFGAClaude S5GLM-5.298.7% (n=2811n=2811)
OpenFGADeepSeek V4GLM-5.298.2% (n=2510n=2510)
RegoClaude S5GPT-5.476.3% (n=2473n=2473)
RegoDeepSeek V4GPT-5.477.1% (n=1461n=1461)
RegoClaude S5GLM-5.278.8% (n=1718n=1718)
RegoDeepSeek V4GLM-5.280.2% (n=916n=916)

Table 6. Decision agreement between generated policies and oracles per model pair; n is the number of executed test requests.

RQ1 Answer. With validator-guided repair, Reparo produces valid policies in 99–100% of cases. Decision agreement is language-dependent: 98.2–99.6% for OpenFGA, 82.0–86.5% for Cedar, and 76.3–80.2% for Rego, with lower agreement for languages whose decisions depend on more conditions.

Smaller open-weight models. We additionally evaluate two smaller open weight models for policy generation and repair, Qwen3.5-27B [51] and Gemma-4-12B-IT [20]. Gemma-4-31B [20] and Qwen3.5-9B [52] were also explored for oracle generation but produced too few usable test cases for quantitative evaluation and are therefore excluded from the oracle analysis. These models were hosted on a high-performance computing (HPC) cluster. Table 7 reports policy validity for the two smaller models. Repair improves policy validity for both, but the gains are smaller and less uniform than for the larger models: Qwen3.5-27B reaches 88.1–92.1% after repair, while Gemma-4-12B reaches 92.2% for Cedar but only 39.7% for OpenFGA and 68.7% for Rego.

ModelLang.Pre-repairPost-repair
Qwen3.5-27BCedar128/159 (80.5%)140/159 (88.1%)
Qwen3.5-27BOpenFGA30/38 (78.9%)35/38 (92.1%)
Qwen3.5-27BRego55/71 (77.5%)63/71 (88.7%)
Gemma-4-12BCedar669/1025 (65.3%)945/1025 (92.2%)
Gemma-4-12BOpenFGA19/63 (30.2%)25/63 (39.7%)
Gemma-4-12BRego50/83 (60.2%)57/83 (68.7%)

Table 7. Policy validity of smaller open-weight models, before and after repair.

The main limitation arises before generation. Although both models advertise long context windows, the effective input limit varied across requests in our deployment: some requests failed at approximately 81K tokens, while others accepted substantially larger inputs. The error did not report the cause; the most likely explanation is that the capacity of the serving framework (SGLang [73]), configured with a static memory fraction of 0.78, depended on the GPU memory available to each job on the HPC cluster. Prior work has further shown that the usable context of long-context models is often substantially shorter than advertised [25, 32]. This affects 12 Cedar, 27 OpenFGA, and 21 Rego repositories for Qwen3.5-27B, and 14, 12, and 17 repositories for Gemma-4-12B with no output. These cases reflect context limitations rather than generation failures and are therefore excluded from Table 7. We also exclude 19 refusals and 21 incomplete or unparseable outputs for Qwen3.5-27B; Gemma-4-12B has no such additional failures.

Finding 4. Smaller open-weight models can generate and repair valid policies when the relevant repository evidence fits within their effective context window, but their validity is less consistent across languages.

RQ2- Oracle Quality and Coverage: RQ2 evaluates the generated oracles in terms of executability, decision distribution, coverage, and correctness. Executability is the proportion of test cases that run successfully in the corresponding policy engine. Decision distribution reports the proportions of expected Allow and Deny decisions. Test-case correctness is assessed through manual validation.

We measure two types of coverage: structural coverage and condition/path coverage. Structural coverage measures how much of a policy is exercised by the test cases, with the coverage unit depending on the policy language. For Cedar, the coverage unit is a top-level permit/forbid rule; for OpenFGA, it is a declared (type, relation) pair; and for Rego, it is an executable source line. We use line-level coverage for Rego because authorization behavior can be distributed across multiple rules and helper definitions, making individual rules difficult to treat as independent policy units. A Cedar rule or OpenFGA relation is considered covered if at least one test evaluates it. Rego line coverage is obtained using the Open Policy Agent (OPA)’s built-in coverage analysis.

For condition/path coverage, we measure condition coverage for Cedar and Rego and path coverage for OpenFGA. For Cedar, we consider only rules with a when or unless clause (e.g., when { principal == resource.owner }), and a condition is covered when at least one test evaluates it. For Rego, condition coverage measures the conditions executed by the test cases. For OpenFGA, we define path coverage per relation over its two decision outcomes, Allow and Deny: a relation is fully covered when test cases observe both outcomes.

Manual validation. Because test oracle TLT_L is LLM-generated, its expected decisions are not assumed to match repository authorization behavior without human validation. We determine the number of test cases to review using Cochran’s formula [14] at 95% confidence (z=1.96z = 1.96), a margin of error e=0.05e = 0.05, and the conservative choice p=0.5p = 0.5, giving n0=384.16n_0 = 384.16. We therefore randomly sample 390 test cases from the generated oracles, with 130 cases from each language. The margin of error applies to the pooled sample. Each case takes approximately 30–60 seconds to review, for a total manual effort of approximately 3.25–6.5 hours.

Two annotators independently review each test case together with the supporting evidence in CC and the generated policy PLP_L, assessing evidence support (whether test cases and the expected decision are supported by the evidence), policy–test alignment (whether the test exercises the intended authorization behavior), completeness (whether all information needed to execute the scenario is present), and test-case quality (e.g., malformed requests, ambiguous evidence, or unsupported values). A test case is considered correct only if it satisfies all four criteria. Inter-annotator agreement is substantial to almost perfect, with Cohen’s κ\kappa of 0.762 for Cedar, 0.867 for OpenFGA, and 0.645 for Rego; disagreements are resolved through discussion until consensus is reached. Of the reviewed cases, 93.1% for Cedar, 96.9% for OpenFGA, and 91.5% for Rego are correct. Oracle generation is thus not error-free, but the majority of test cases are supported by repository evidence and correct.

Test-case complexity. Complexity is measured as the number of co-occurring conditions required to determine an authorization decision. Cedar and Rego have similar distributions at the upper end, with 36.6% and 35.8% of cases requiring six or more conditions. Below that threshold, Cedar cases are spread roughly evenly across zero to five conditions (about 9–16% each), whereas Rego cases concentrate at two to four conditions, with fewer than 10% requiring zero or one. In contrast, 81.9% of OpenFGA cases require zero or one condition, about 12% require two, and fewer than 3% require more than three. Many OpenFGA decisions can therefore be determined by individual relationships or shallow relationship graphs, whereas Cedar and Rego decisions more often depend on multiple conditions, which is consistent with the agreement differences in RQ1.

Executability and coverage. Table 8 reports executability, decision distribution, and coverage for each oracle–policy model combination. Executability ranges from 86.4% to 99.2%. Both decisions are also well represented: Allow cases account for 41.0–56.3% of executable test cases, so neither decision dominates the generated test cases. Coverage varies across languages and oracle models. For Cedar, rule coverage ranges from 56.3% to 70.2%, while condition coverage ranges from 68.8% to 78.0%. For OpenFGA, relation coverage ranges from 51.3% to 78.1%, and path coverage ranges from 48.7% to 77.3%. For Rego, line coverage ranges from 60.0% to 68.1%, while condition coverage ranges from 53.0% to 65.8%. These differences indicate that the two oracle models exercise different parts of the policies.

OraclePolicyExec.AllowStruct.Cond.
Cedar
GPT-5.4Claude S587.653.462.372.7
DeepSeek V486.455.856.368.8
GLM-5.2Claude S587.952.970.272.5
DeepSeek V487.755.162.778.0
OpenFGA
GPT-5.4Claude S597.648.767.665.1
DeepSeek V499.249.078.177.3
GLM-5.2Claude S597.949.251.350.4
DeepSeek V493.746.352.748.7
Rego
GPT-5.4Claude S592.055.268.165.8
DeepSeek V487.856.365.859.8
GLM-5.2Claude S592.752.062.555.3
DeepSeek V486.741.060.053.0

Table 8. Test-case executability, share of Allow decisions, and policy coverage (all in %) per oracle and policy model pair. Deny is the complement of Allow. Structural coverage is rule coverage for Cedar, relation coverage for OpenFGA, and line coverage for Rego; condition coverage is reported for Cedar and Rego, and path coverage for OpenFGA.

Lang.PolicyStruct.Cond./Path
CedarClaude S575.3%76.7%
DeepSeek V470.6%85.0%
OpenFGAClaude S575.0%73.2%
DeepSeek V482.7%81.4%
RegoClaude S582.1%72.7%
DeepSeek V476.5%65.9%

Table 9. Policy coverage when test cases from both oracle models are combined.

The two oracle models provide complementary coverage. Combining their test cases increases both structural and condition/path coverage for every policy model. For Cedar, combined rule coverage reaches 75.3% for Claude Sonnet 5 and 70.6% for DeepSeek-V4-Pro, while condition coverage reaches 76.7% and 85.0%, respectively. For OpenFGA, combined relation coverage reaches 75.0% and 82.7%, and combined path coverage reaches 73.2% and 81.4%. For Rego, combined line coverage reaches 82.1% and 76.5%, and combined condition coverage reaches 72.7% and 65.9%. Thus, although the two oracle models differ in which parts of a policy they exercise, their test cases collectively provide broader coverage than either oracle alone.

RQ2 Answer. The oracle is reliable and balanced: 91.5–96.9% of manually reviewed test cases meet all review criteria, 86.4–99.2% execute successfully, and both decisions are well represented. GPT-5.4 and GLM-5.2 cover different parts of the authorization behavior, and combining their test cases yields higher coverage than either model alone.

RQ3- Generated vs repository Policies: RQ3 compares the synthesized policies with the repository policies P\mathcal{P} both quantitatively and through case studies. We first check whether P\mathcal{P} passes its language’s validation tool to assess its suitability as a baseline. For Cedar, we then run the synthesized and valid repository policies on the same oracle test cases and measure decision agreement. Finally, we examine six repositories, two per language, in detail. We compare policies by their behavior, since structurally different policies can encode the same authorization behavior. The case studies examine whether a synthesized policy corrects defects, generalizes rules, omits behavior due to missing evidence, or differs because of repository-specific execution dependencies.

Validation of Repository Policies. We assess repository policy validity using the same procedure as for generated policies, with language-specific validation tools. Table 10 shows that 55.7% of Cedar policy statements, 52.7% of Rego policies, and 40.6% of OpenFGA models are invalid. Therefore, repository policies are not reliable ground truth.

LanguageTotalValidInvalid (%)
Cedar3,8901,7232,167 (55.7%)
Rego15,1317,1647,967 (52.7%)
OpenFGA360214146 (40.6%)

Table 10. Repository policies that pass or fail each language’s native validator.

Decision Agreement with Repository Policies. We compare generated and repository policies using the same oracle requests. We perform this comparison only for Cedar because its schema defines entity types, attributes, and actions, allowing each request to be evaluated directly against both policies. For OpenFGA and Rego, generated policies may use different entity, relation, or input names from the repository policies, making direct request-level comparison difficult. We first compare complete repository policies. We identify 20 Cedar repositories in which all repository policies P\mathcal{P} are valid, and every oracle request produces a decision from the repository policy. This allows us to evaluate the complete authorization behavior encoded by each repository’s policies P\mathcal{P} as a whole. We then perform a broader comparison using individually valid statements across all 53 Cedar repositories. This includes 1,723 valid statements, with 36 repositories providing at least one valid repository policy for comparison. The complete-policy comparison achieves 86.5% agreement between generated and repository policy decisions for Claude Sonnet 5 and 83.9% for DeepSeek-V4-Pro, based on 1,450 requests. The broader comparison achieves 76.2% and 76.0% agreement, respectively, based on 3,120 requests. We use the complete-policy comparison as the primary measure because it evaluates each repository policy as a whole. The broader comparison removes invalid statements before comparison, which can change the policy’s overall authorization behavior because multiple statements may work together to determine authorization decisions.

Case studies. Decision agreement does not show why generated and repository policies differ. We therefore conduct case studies on two repositories per language: Cedar (C1, C2), OpenFGA (O1, O2), and Rego (R1, R2). The cases cover invalid repository policies, hard-coded rules, and fragmented authorization models. For each repository, we compare the generated and repository policies in terms of validity, authorization behavior, and structure, and report decision agreement.

Correcting and generalizing repository policies. In C1, all the repository policies are invalid. On the other hand, both generation models produce valid policies that preserve the repository authorization intent (Figure 8); however, in a more compact form: where the repository states each case as a separate statement, the generated policies combine alternative conditions into a single rule using disjunction (∣∣||), and therefore contain fewer statements than the repository’s 11: 10 for Claude Sonnet 5 and 6 for DeepSeek-V4-Pro. For one rule, however, the repository evidence lacks the information needed to recover the intended logic, and neither model produces it. The generated policies achieve full rule and condition coverage, with agreement of 26/26 against GPT-5.4 and 24/26 against GLM-5.2 for both models.

Figure 8. Case C1: the invalid repository policy (left) leaves its entities unscoped and accesses attributes unguarded (red). The generated policy (right) adds type scoping and has checks (green).

DomainStarsPolicy UnitsPolicy Validity
C1 Document management911Invalid
C2 Photo-sharing web app177Valid
O1 Monitoring platform75K4Invalid
O2 Authorization testbed24Invalid
R1 Access management layer341Valid
R2 GDPR compliance61Valid

Table 11. Characteristics of the six case-study repositories (C: Cedar, O: OpenFGA, R: Rego). O1, R1, and R2 are Production grade meaning that these are deployed in production.

In C2, the repository policies are valid but rely on hardcoded principals and narrow conditions: several inactive policies grant the same viewPhoto action to individually named users, encoding separate exceptions rather than reusable logic. Because these principal names are not available during generation, both models generalize the evidence into role-, attribute-, and context-based policies. The generated policies achieve full agreement with both oracles (11/11 with GLM-5.2 and 5/5 with GPT-5.4) and full rule and condition coverage. Figure 9 illustrates this generalization: the repository policy grants viewPhoto on DoePublicPhotos to the single user JoePublic, whereas the generated policy generalizes the principal to any PhotoApp::User while allowing the exact album DoePublicPhotos. It also requires an authenticated session, guarded by a has check, thereby extending access to the intended population without expanding the set of protected resources.

Figure 9. Case C2: the repository policy grants access to one hardcoded user. The generated policy generalizes this to any authenticated user.

Equivalent intent, different structure. R1 is a valid production Rego policy for identity and access management. Both models recover its core authorization logic but use different structures. Claude S5 introduces an explicit default-deny rule, more detailed administrator checks, and action categories, while DeepSeek-V4-Pro produces a more compact policy. Agreement varies across the two oracles: Claude S5 achieves 8/8 with GLM-5.2 and 38/51 with GPT-5.4, while DeepSeek-V4-Pro achieves 22/23 and 19/26, respectively. R2 implements GDPR-related role-based access control with a default-deny policy. Both models recover the core structure, using role-based authorization for operations with a default-deny rule, but express it differently from the repository policy. Claude S5 achieves 12/15 agreement with GPT-5.4 and 8/8 with GLM-5.2, while DeepSeek-V4-Pro achieves 6/10 and 10/13, respectively.

Configuration and fragmentation. In O1, the repository policy consists of four .fga files that fail validation; adding a minimal fga.mod file restores validity without modifying them, so the failure stems from configuration rather than authorization logic. The generated policies recover the relationships of one module, whose structure is well represented in the retrieved evidence, but not of the remaining modules, whose evidence falls outside the retrieved context. Agreement is high (Claude Sonnet 5: 34/34 with GPT-5.4 and 23/24 with GLM-5.2; DeepSeek-V4-Pro: 32/32 and 26/26), but relation coverage is 9/14 and 11/14, respectively. O2 also contains four OpenFGA files. The fga.mod fix from O1 is insufficient here: one file is repaired with minor syntax fixes, while the other three depend on type information missing from the repository and are left unrepaired rather than completed with unsupported logic. These files still describe the application’s entities and relationships, and the generated policy covers all these information from the evidence. Agreement is complete for all model-oracle pairs (Claude Sonnet 5: 56/56 and 29/29; DeepSeek-V4-Pro: 33/33 and 31/31), as is structural coverage (26/26 relations and 52/52 paths, and 28/28 and 56/56, respectively). Generated policies can therefore recover a more complete authorization model than any single fragmented repository file when the intent is distributed across the repository.

RQ3 Answer. Generated policies match the decisions of completely valid repository Cedar policies on 83.9–86.5% of oracle requests. The case studies further show that Reparo can generate authorization behavior when repository policies are invalid, fragmented, or structured differently, and can correct defects and generalize hardcoded rules when sufficient evidence is available.

Computational Cost: Table 12 reports average token consumption, API cost, and execution time per repository over the 228 repositories. API costs use the providers’ published prices from August 2026. A complete policy generation and oracle assessment takes about five minutes and costs 0.55−0.55-1.57, depending on the model pair. The smaller open-weight models run on a university HPC cluster without API charges; Qwen3.5-27B and Gemma-4-12B take around 12 and 3 minutes per repository, respectively.

StageModelTokensCostTime
PolicyClaude S5232.5K$0.58 | 1.02 min
DeepSeek V4158.5K$0.08 | 1.05 min
OracleGPT-5.4308.5K$0.99 | 3.75 min
GLM-5.2387.7K$0.47 | 4.43 min

Table 12. Average tokens, API cost, and time per repository for policy and oracle generation.

Related Work

Policy Synthesis from Requirements. A substantial body of work derives access-control policies from artifacts that explicitly state authorization intent. Prior studies [36, 56, 57, 64] extract authorization statements from natural-language software documents and translate them into formal policies, while related work starts from user stories [24]. Recent LLM-based approaches perform policy identification, attribute extraction, and generation from natural-language specifications, access requirements, and unstructured text [13, 22, 27, 28, 29, 34, 47, 55, 58, 59, 61, 62], including retrieval-augmented generation [26]. These approaches assume that authorization intent is explicitly specified in the input, whereas Reparo does not depend on such specification.

Policy Mining and Reverse Engineering. Policy mining infers RBAC, ABAC, or ReBAC policies from structured authorization data, access logs, or relationship graphs [9, 10, 15, 69]. Recent LLM-based approaches mine policies from attribute data or access logs [4, 8]. Reverse-engineering systems instead recover authorization behavior from applications, including Android middleware, running web applications, and microservice interactions [21, 30, 31]. Program specification systems such as SpecGen infer formal specifications from code [33]. Unlike these approaches, which primarily rely on a single artifact and often evaluate against a reference policy, Reparo combines code, comments, and documentation and evaluates generated policies independently using oracles.

Policy Testing. Access-control testing has used policy-specific coverage criteria and model-based test generation [35, 65, 66, 67], typically deriving tests from the policy or an explicit access-control model. LLMs have also been applied to test generation [17, 60], or validate generated policies against requirements-derived references [62]. These approaches assume a policy or specification that can serve as a trusted reference, whereas Reparo derives its test oracle from repository evidence.

Limitations

Dataset and generalizability. Our dataset contains 228 public repositories and may not represent private codebases or other application domains. Reparo also depends on language-specific artifacts: a schema for Cedar and repository policy files for retrieving evidence in OpenFGA and Rego. The evaluated models may have seen some of these public policies during training.

Evaluation scope. Agreement with the generated oracle does not necessarily reflect the application’s true intended policy. The oracle uses a finite set of generated requests and may miss some behaviors. For OpenFGA and Rego, requests are created from the generated policy interface, so behavior missing from that interface cannot be tested. Retrieval may also miss relevant evidence, especially when authorization logic is implicit in the code. The retrieval threshold τ\tau was selected using a six-repository pilot, and manual validation may introduce evaluator subjectivity.

The oracles are generated by LLMs and may contain incorrect decisions. We reduce this risk by using different models, requiring supporting evidence for each decision, and manually checking the generated tests. Because LLM outputs can vary across runs, the results may also vary.

Conclusion

Reparo synthesizes access-control policies from code, comments, and documentation, repairs them with native validator feedback, and validates their behavior against a behavioral oracle derived independently from the same evidence. On 228 real-world repositories spanning Cedar, OpenFGA, and Rego, Reparo produces 99–100% valid policies, and 91.5–96.9% of manually reviewed oracle test cases are correct. Decision agreement is highest for OpenFGA and lower for Cedar and Rego, whose decisions combine more conditions. Our case studies show that, when repository evidence is sufficient, Reparo can correct defects, generalize hardcoded rules, and recover authorization behavior that invalid or incomplete repository policies fail to capture.

References

  1. [1]Andrés Aguiar. 2022. Announcing OpenFGA: Auth0’s Open Source Fine-Grained Authorization System. Auth0 Blog. https://auth0.com/blog/auth0s-openfga-open-source-fine-grained-authorization-system/
  2. [2]Anthropic. 2026. Claude Sonnet 5. https://www.anthropic.com/claude. Accessed: 2026-08-23.
  3. [3]AuthZed. 2026. SpiceDB: Open Source, Google Zanzibar-Inspired Permissions Database. https://github.com/authzed/spicedb. Accessed: 2026-10-03.
  4. [4]More Aayush Babasaheb and Shamik Sural. 2025. Towards Harnessing the Power of LLMs for ABAC Policy Mining. arXiv preprint arXiv:2511.18098 (2025).
  5. [5]Earl T Barr, Mark Harman, Phil McMinn, Muzzammil Shahbaz, and Shin Yoo. 2014. The oracle problem in software testing: A survey. IEEE transactions on software engineering 41, 5 (2014), 507–525.DOI
  6. [6]Lujo Bauer, Scott Garriss, and Michael K Reiter. 2011. Detecting and resolving policy misconfigurations in access-control systems. ACM Transactions on Information and System Security (TISSEC) 14, 1 (2011), 1–28.
  7. [7]Thang Bui, Anthony Matricia, Emily Contreras, Ryan Mauvais, Luis Medina, and Israel Serrano. 2025. ABAC lab: an interactive platform for attribute-based access control policy analysis, tools, and datasets [Dataset/Tool Paper]. In Proceedings of the 30th ACM Symposium on Access Control Models and Technologies. 111–116.arxiv.org/abs/2505.08209
  8. [8]Thang Bui and Esteban Martinez Mota. 2026. Mining Attribute-Based Access Control Policies with Large Language Models [Work in Progress Paper]. In Proceedings of the 31st ACM Symposium on Access Control Models and Technologies. 45–51.DOI
  9. [9]Thang Bui and Scott D Stoller. 2020. A decision tree learning approach for mining relationship-based access control policies. In Proceedings of the 25th ACM Symposium on Access Control Models and Technologies. 167–178.arxiv.org/abs/1909.12095
  10. [10]Thang Bui, Scott D. Stoller, and Jiajie Li. 2019. Greedy and evolutionary algorithms for mining relationship-based access control policies. Computers & Security 80 (2019), 317–333. doi:10.1016/j.cose.2018.09.011DOI
  11. [11]Cedar Contributors. 2026. Policy validation. https://docs.cedarpolicy.com/policies/validation.html.
  12. [12]Cedar Policy. 2026. Cedar Policy Syntax Grammar. https://docs.cedarpolicy.com/policies/syntax-grammar.html. Accessed: 2026-08-23.
  13. [13]Ye Cheng, Minghui Xu, Yue Zhang, Kun Li, Hao Wu, Yechao Zhang, Shaoyong Guo, Wangjie Qiu, Dongxiao Yu, and Xiuzhen Cheng. 2025. Say what you mean: Natural language access control with large language models. arXiv preprint arXiv:2505.23835 (2025).arxiv.org/abs/2505.23835
  14. [14]William G. Cochran. 1977. Sampling Techniques (3rd ed.). John Wiley & Sons, New York, NY.
  15. [15]Carlos Cotrini, Thilo Weghorn, and David A. Basin. 2018. Mining ABAC Rules from Sparse Logs. In 2018 IEEE European Symposium on Security and Privacy, EuroS&P 2018, London, United Kingdom, April 24-26, 2018. 31–46. doi:10.1109/EuroSP.2018.00011DOI
  16. [16]Joseph W Cutler, Craig Disselkoen, Aaron Eline, Shaobo He, Kyle Headley, Michael Hicks, Kesha Hietala, Eleftherios Ioannidis, John Kastner, Anwar Mamat, et al. 2024. Cedar: A new language for expressive, fast, safe, and analyzable authorization. Proceedings of the ACM on Programming Languages 8, OOPSLA1 (2024), 670–697.DOI
  17. [17]Arghavan Moradi Dakhel, Amin Nikanjam, Vahid Majdinasab, Foutse Khomh, and Michel C. Desmarais. 2024. Effective test generation using pre-trained Large Language Models and mutation testing. Inf. Softw. Technol. 171, C (July 2024), 17 pages. doi:10.1016/j.infsof.2024.107468DOI
  18. [18]DeepSeek-AI. 2026. DeepSeek-V4-Pro. https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro. Hugging Face model repository.
  19. [19]EnforceAuth. 2026. zift: Sift through Code for Embedded Authorization Logic and Extract It into Policy as Code. https://github.com/EnforceAuth/zift. Accessed: 2026-09-26.
  20. [20]Gemma Team. 2026. Gemma 4 Technical Report. arXiv:2607.02770 [cs.CL]
  21. [21]Sigmund Albert Gorski, Benjamin Andow, Adwait Nadkarni, Sunil Manandhar, William Enck, Eric Bodden, and Alexandre Bartel. 2019. Acminer: Extraction and analysis of authorization checks in android’s middleware. Proceedings of the Ninth ACM Conference on Data and Application Security and Privacy. 25–36.
  22. [22]Vatsal Gupta and Darshan Sreenivasamurthy. 2026. Prose2Policy (P2P): A Practical LLM Pipeline for Translating Natural-Language Access Policies into Executable Rego. arXiv preprint arXiv:2603.15799 (2026).arxiv.org/abs/2603.15799
  23. [23]Hao He. 2019. Understanding source code comments at large-scale. In Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. 1217–1219.DOI
  24. [24]John Heaps, Ram Krishnan, Yufei Huang, Jianwei Niu, and Ravi Sandhu. 2021. Access control policy generation from user stories using machine learning. In IFIP Annual conference on data and applications security and privacy. Springer, 171–188.DOI
  25. [25]Cheng-Ping Hsieh, Simeng Sun, Samuel Kriman, Shantanu Acharya, Dima Rekesh, Fei Jia, Yang Zhang, and Boris Ginsburg. 2024. RULER: What’s the real context size of your long-context language models? arXiv preprint arXiv:2404.06654 (2024).arxiv.org/abs/2404.06654
  26. [26]Sakuna Harinda Jayasundara, Nalin Asanka Gamagedara Arachchilage, and Giovanni Russello. 2024. Ragent: Retrieval-based access control policy generation. arXiv preprint arXiv:2409.07489 (2024).arxiv.org/abs/2409.07489
  27. [27]Sakuna Harinda Jayasundara, Nalin Asanka Gamagedara Arachchilage, and Giovanni Russello. 2026. AGentVLM: Access control policy generation and verification framework with language models. Journal of Information Security and Applications 98 (2026), 104379. doi:10.1016/j.jisa.2026.104379DOI
  28. [28]Sakuna Harinda Jayasundara, Nalin Asanka Gamagedara Arachchilage, and Giovanni Russello. 2024. SoK: Access control policy generation from high-level natural language requirements. Comput. Surveys 57, 4 (2024), 1–37.arxiv.org/abs/2310.03292
  29. [29]Sherifdeen Lawal, Xingmeng Zhao, Anthony Rios, Ram Krishnan, and David Ferriao. 2024. Translating natural language specifications into access control policies by leveraging large language models. In 2024 IEEE 6th International Conference on Trust, Privacy and Security in Intelligent Systems, and Applications (TPS-ISA). IEEE, 361–370.DOI
  30. [30]Ha Thanh Le, Lwin Khin Shar, Domenico Bianchulli, Lionel Claude Briand, and Cu Duy Nguyen. 2022. Automated reverse engineering of role-based access control policies of web applications. Journal of Systems and Software 184 (2022), 111109.DOI
  31. [31]Xing Li, Yan Chen, Zhiqiang Lin, Xiao Wang, and Jim Hao Chen. 2021. Automatic policy generation for {Inter-Service} access control of microservices. In 30th USENIX Security Symposium (USENIX Security 21). 3971–3988.
  32. [32]Nelson E Liu, Kevin Lin, John Hewitt, Ashwin Paranjape, Michele Bevilacqua, Fabio Petroni, and Percy Liang. 2024. Lost in the middle: How language models use long contexts. Transactions of the association for computational linguistics 12 (2024), 157–173.arxiv.org/abs/2307.03172
  33. [33]Lezhi Ma, Shangqiu Liu, Yi Li, Xiaofei Xie, and Lei Bu. 2025. Specgen: Automated generation of formal program specifications via large language models. In 2025 IEEE/ACM 47th International Conference on Software Engineering (ICSE). IEEE, 16–28.arxiv.org/abs/2401.08807
  34. [34]Khang Mai, Naikula Guhate, Jongmin Lee, and Razvan Beuran. 2025. LLM-Based Fine-Grained ABAC Policy Generation.. In ICISSP (2). 204–212.
  35. [35]Evan Martin, Tao Xie, and Ting Yu. 2006. Defining and measuring policy coverage in testing access control policies. In International Conference on Information and Communications Security. Springer, 139–158.
  36. [36]Masoud Narouei, Hassan Takabi, and Rodney Nielsen. 2018. Automatic extraction of access control policies from natural language documents. IEEE Transactions on Dependable and Secure Computing 17, 3 (2018), 506–517.DOI
  37. [37]Open Policy Agent. 2026. Policy Language. Open Policy Agent Documentation. https://www.openpolicyagent.org/docs/policy-language
  38. [38]Open Policy Agent. 2026. Policy Reference: Grammar. https://www.openpolicyagent.org/docs/policy-reference#grammar. Accessed: 2026-08-23.
  39. [39]Open Policy Agent. 2026. Rego Grammar (BNF). https://github.com/open-policy-agent/opa-idea-plugin/blob/master/src/main/grammar/Rego.bnf. Accessed: 2026-08-23.
  40. [40]Open Policy Agent Contributors. 2026. CLI Reference. https://www.openpolicyagent.org/docs/cli.
  41. [41]OpenAI. 2026. Introducing GPT-5.4. https://openai.com/index/introducing-gpt-5-4/. Accessed: 2026-08-23.
  42. [42]OpenFGA. 2026. OpenFGA Language Grammar. https://github.com/openfga/language/blob/main/OpenFGALexer.g4. Accessed: 2026-08-23.
  43. [43]OpenFGA Contributors. 2026. OpenFGA CLI. https://openfga.dev/docs/getting-started/cli.
  44. [44]Carly Page. 2023. Microsoft AI Researchers Accidentally Exposed Terabytes of Internal Sensitive Data. TechCrunch. https://techcrunch.com/2023/09/18/microsoft-ai-researchers-accidentally-exposed-terabytes-of-internal-sensitive-data/
  45. [45]Ruoming Pang, Ramon Caceres, Mike Burrows, Zhifeng Chen, Pratik Dave, Nathan Germer, Alexander Golynski, Kevin Greevy, Nina Kang, Lea Kissner, et al. 2019. Zanzibar: {Google’s} consistent, global authorization system. In 2019 USENIX Annual Technical Conference (USENIX ATC 19). 33–46.
  46. [46]Arjun Panickssery, Samuel R Bowman, and Shi Feng. 2024. Llm evaluators recognize and favor their own generations. Advances in Neural Information Processing Systems 37 (2024), 68772–68802.arxiv.org/abs/2404.13076
  47. [47]Maria Teresa Paratore, Eda Marchetti, and Antonello Calabro. 2025. From Plain English to XACML Policies: An AI-Based Policy Approach. In MODELSWARD. 85–96.DOI
  48. [48]Alen Paul, Rishi Manoj, et al. 2024. Amazon web services cloud compliance automation with open policy agent. In 2024 International Conference on Expert Clouds and Applications (ICOECA). IEEE, 313–317.DOI
  49. [49]Rolf-Helge Pfeiffer. 2020. What constitutes software? An empirical, descriptive study of artifacts. In Proceedings of the 17th International Conference on Mining Software Repositories. 481–491.
  50. [50]Isaac Polinsky, Pubali Datta, Adam Bates, and William Enck. 2024. GRASP: Hardening Serverless Applications through Graph Reachability Analysis of Security Policies. In Proceedings of the ACM Web Conference 2024 (Singapore, Singapore) (WWW ’24). Association for Computing Machinery, New York, NY, USA, 1644–1655. doi:10.1145/3589334.3645436DOI
  51. [51]Qwen Team. 2026. Qwen3.5-27B. https://huggingface.co/Qwen/Qwen3.5-27B. Hugging Face model card.
  52. [52]Qwen Team. 2026. Qwen3.5 Model Series. https://huggingface.co/Qwen. Official Qwen model repository.
  53. [53]Stephen Robertson and Hugo Zaragoza. 2009. The probabilistic relevance framework: BM25 and beyond. Foundations and trends® in information retrieval 3, 1–2 (2009), 1–174.
  54. [54]J.H. Saltzer and M.D. Schroeder. 1975. The protection of information in computer systems. Proc. IEEE 63, 9 (1975), 1278–1308. doi:10.1109/PROC.1975.9939DOI
  55. [55]Fangfang Shan, Zhenyu Wang, Mengyao Liu, and Menghan Zhang. 2024. Automatic Generation of Attribute-Based Access Control Policies from Natural Language Documents. Computers, Materials and Continua 80, 3 (2024), 3881–3902. doi:10.32604/cmc.2024.055167DOI
  56. [56]John Sklanskas and Laurie Williams. 2013. Access control policy extraction from unconstrained natural language text. In 2013 International Conference on Social Computing. IEEE, 435–440.
  57. [57]John Slankas, Xusheng Xiao, Laurie Williams, and Tao Xie. 2014. Relation extraction for inferring access control rules from natural language artifacts. In Proceedings of the 30th annual computer security applications conference. 366–375.DOI
  58. [58]Pratik Sonune, Ritwik Rai, and Shamik Suraj. 2026. LAPS: LLM-based ABAC Policy Synthesis from Unstructured Text. In Proceedings of the 12th ACM International Workshop on Security and Privacy Analytics. 40–50.DOI
  59. [59]Pratik Sonune, Ritwik Rai, Shamik Suraj, Vijayalakshmi Atluri, and Ashish Kundu. 2025. MLM: A tool for generating machine enforceable policies from natural language access control rules using LLMs. arXiv preprint arXiv:2502.12460 (2025).arxiv.org/abs/2502.12460
  60. [60]Yunian Tang, Zhijie Liu, Zhichao Zhou, and Xiapu Luo. 2024. ChatGPT vs SBST: A Comparative Assessment of Unit Test Suite Generation . IEEE Transactions on Software Engineering 50, 06 (June 2024), 1340–1359. doi:10.1109/TSE.2024.3382365DOI
  61. [61]Adarsh Vatsa, Pratyush Patel, and William Eiers. 2025. Synthesizing access control policies using large language models. In 2025 IEEE/ACM International Workshop on Natural Language-Based Software Engineering (NLBSE). IEEE, 13–16.arxiv.org/abs/2503.11573
  62. [62]Adarsh Vatsa, Sachi Shome, Yingming Zhou, and William Eiers. 2026. AutoCedar: An Agentic Framework for Verifier-Guided Access Control Policy Synthesis. arXiv preprint arXiv:2607.03656 (2026).arxiv.org/abs/2607.03656
  63. [63]Jonas Wessner, Tobias Meuser, Janek Schott, Dennis Eisermann, Johannes Degger, Björn Scheuermann, and Frank Kargl. 2026. Natural Language Access Control (NLAC): From Help Desk Requests to Structured Policies. arXiv preprint arXiv:2606.06726 (2026).arxiv.org/abs/2606.06726
  64. [64]Xunsheng Xiao, Amit Paradkar, Suresh Thummalapenta, and Tao Xie. 2012. Automated extraction of security policies from natural-language software documents. In Proceedings of the ACM SIGSOFT 20th International Symposium on the Foundations of Software Engineering. 1–11.
  65. [65]Dianxiang Xu, Roshan Shrestha, and Ning Shen. 2018. Automated coverage-based testing of XACML policies. In Proceedings of the 23nd ACM on Symposium on Access Control Models and Technologies. 3–14.DOI
  66. [66]Dianxiang Xu, Roshan Shrestha, and Ning Shen. 2020. Automated strong mutation testing of XACML policies. In Proceedings of the 25th ACM Symposium on Access Control Models and Technologies. 105–116.DOI
  67. [67]Dianxiang Xu, Lijo Thomas, Michael Kent, Tejeddine Mouelhi, and Yves Le Traon. 2012. A model-based approach to automated testing of access control policies. In Proceedings of the 17th ACM symposium on Access Control Models and Technologies. 209–218.DOI
  68. [68]Peng Xu, Wei Ping, Xianchao Wu, Lawrence McAfee, Chen Zhu, Zihan Liu, Sandeep Subramanian, Evelina Bakhturina, Mohammad Shoeybi, and Bryan Catanzaro. 2024. Retrieval meets long context large language models. In International Conference on Learning Representations, Vol. 2024. 49569–49584.arxiv.org/abs/2310.03025
  69. [69]Zhongyuan Xu and Scott D. Stoller. 2014. Mining attribute-based access control policies. IEEE Transactions on Dependable and Secure Computing 12, 5 (2014), 533–545.arxiv.org/abs/1306.2401
  70. [70]Elvis Yeboah-Duako and Pubali Datta. 2026. Permissions on the Loose: Measuring Overprivilege in Real-World Serverless Applications. arXiv:2607.02875 [cs.CR]. https://arxiv.org/abs/2607.02875
  71. [71]Z.ai. 2026. GLM-5.2. https://z.ai/blog/glm-5.2. Accessed: 2026-08-23.
  72. [72]Fengji Zhang, Bei Chen, Yue Zhang, Jacky Keung, Jin Liu, Daoguang Zan, Yi Mao, Jian-Guang Lou, and Weizhu Chen. 2023. Repocoder: Repository-level code completion through iterative retrieval and generation. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing. 2471–2484.arxiv.org/abs/2303.12570
  73. [73]Lianmin Zheng, Liangsheng Xie, Zhiqiang Xie, Chuyue Sun, Jeff Huang, Cody H Yu, Shiyi Cao, Christos Kozyrakis, Ion Stoica, Joseph E Gonzalez, et al. 2024. Sglang: Efficient execution of structured language model programs. Advances in neural information processing systems 37 (2024), 62557–62583.arxiv.org/abs/2312.07104

Paper details

vlnc:W_hgzy7fx4
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 7

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents