Pith. Sign in

REVIEW

Safety Analysis in the NGAC Model

Computational Complexity · Submitted 9 May 2025 · 29 references

Pith's verdict: The coNP-completeness proof for NGAC safety has a missing-create-commands bug in the key reduction, but the DACC abstraction and algorithm are solid and worth a careful revision.

T0 · AI review

How this review was made: An AI referee (deepseek-v4-flash) read the paper on August 15, 2026 and answered a fixed list of questions about it. T0 is the starting level every paper gets. The levels describe how deeply Pith has checked the paper, never the authors.

  1. T0 AI review An AI read the paper and answered a fixed list of questions.
  2. T1 Audit Automatic checks that the references and files the paper relies on exist and match.
  3. T2 Compute The paper's code or calculations re-run with the same results.
  4. T3 Formal statement The claims written out in a formal math language a computer can read.
  5. T4 Proof Those claims proved, and the proof checked by computer.

How Pith checks papers →

· 3 major objections · 5 minor · Ask about this paper · The compiled record · Read the full review →
Challenge this review Comment (0) Read on arXiv ↗
Cite ▾
arXiv ID2505.06406 (version 1)
Pith IDLVISTTV2, Pith's permanent record of this paper and its review
CitationBrian Tan, Ewan S. D. Davies, Indrakshi Ray, Mahmoud A. Abdelgawad. "Safety Analysis in the NGAC Model." arXiv:2505.06406 (2025). https://pith.science/paper/LVISTTV2
Cite this reviewBibTeX for Pith's review of this paper
Claim paper

Why Pith says this

Highlight any text to comment on it.

Referee report
The paper

The paper claims

The paper proves that safety analysis for NGAC access-control models is coNP-complete under mono-operational commands, so no polynomial-time checker can exist unless P=NP.

The reading

This paper tries to pin down the computational difficulty of checking whether an NGAC access-control policy can ever grant a new access. It defines the co-safety problem—does some command sequence create a new path from a user to a resource—and claims that for mono-operational commands under three mild assumptions, co-safety is NP-complete, hence safety is coNP-complete. The argument goes through a graph abstraction called directed acyclic constrained connectivity (DACC), which asks whether a directed acyclic graph has an s-t path in a subgraph that respects mutual-exclusion constraints on edges; the paper reduces 3-coloring to DACC and DACC to co-safety. If this is right, general NGAC safety cannot be checked in polynomial time unless P=NP. The paper also gives an exponential algorithm based on enumerating maximal independent sets and shows that mutually exclusive attributes, common in separation of duty, make its running time close to worst case.

What carries the argument

The central object is DACC: a directed acyclic graph $\Gamma$ with a constraint graph $C$ whose vertices are edges of $\Gamma$ and whose edges forbid pairs of $\Gamma$-edges from coexisting; a valid subgraph is one whose edge set is an independent set in $C$. The argument runs on the claimed bijection between valid subgraphs of $\Gamma$ and reachable states of the NGAC model, which turns command sequences into static path-finding. On the algorithmic side, the load-bearing mechanism is enumeration of maximal independent sets of $C$: every maximal valid subgraph is obtained this way, and the extremal bound $3^{n/3}<1.45^n$ on the number of maximal independent sets gives the worst-case runtime.

Extended reading notes

Core claim

The paper's central discovery, on its own terms, is Theorem 3.5: the co-safety problem for NGAC models is NP-complete in the mono-operational setting with assumptions 1–3, which makes the safety problem coNP-complete. The proof is a reduction chain from 3-coloring to DACC, and from DACC to co-safety by embedding the DAG inside the user-attribute subgraph of an NGAC state, with commands that add or remove edges according to the constraints. The paper further claims that reachable NGAC states correspond exactly to valid subgraphs of that DAG, so searching for an unsafe command sequence reduces to finding a path in a valid subgraph. If this correspondence holds, no polynomial-time safety-checking algorithm exists for general NGAC models unless P=NP.

Load-bearing premise

The whole reduction assumes that every edge of the embedded graph $\Gamma$ that can lie on an $s$-$t$ path has a command that can create it, but the construction only adds create commands for edges appearing in the constraint graph; edges outside the constraints have only destroy commands, so the claimed reachable-state correspondence is not established.

Editorial extensions

If this is right

  • If the main theorem holds, no polynomial-time algorithm can decide whether a general NGAC policy is safe under mono-operational commands, unless P=NP.
  • Any future safety checker must either restrict the model further or accept exponential worst-case time; the certificate for an unsafe answer is a user-resource-right triple plus a command sequence.
  • For NGAC instances whose constraint graph has polynomially many maximal independent sets, the paper's algorithm decides safety in polynomial time.
  • Mutually exclusive attribute groups, common in separation-of-duty policies, produce disjoint cliques in the constraint graph, putting realistic models near the worst case for the algorithm.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • If the missing create commands for constraint-free connector edges are added, the NP-completeness proof likely goes through; as written, the constructed model cannot produce the very $s$-$t$ path it relies on, so the reduction needs repair.
  • The same DACC abstraction could be applied to other attribute-based access-control languages whose commands guard edge creation, suggesting a general route from policy languages to constrained path-finding.
  • The near-worst-case behavior on disjoint cliques suggests that parameterizing by the number and size of mutually exclusive attribute groups, rather than by total graph size, may yield fixed-parameter tractable safety analysis.
Original abstract

We study the safety problem for the next-generation access control (NGAC) model. We show that under mild assumptions it is coNP-complete, and under further realistic assumptions we give an algorithm for the safety problem that significantly outperforms naive brute force search. We also show that real-world examples of mutually exclusive attributes lead to nearly worst-case behavior of our algorithm.

The compiled record

The paper's own sentences, arranged, kept beside the review and separate from it. Each label is drawn from a closed vocabulary; the number beside it is the probability the classifier gave that label. Numbers in the tables are the authors', checked by code. No sentence in this record was written by a model.

Compiled by classifier-1.13.0 via TypeSafe API, question bank abstract-p1-20260923, 2026-09-23: 1 request, 2,872 input tokens.

What the abstract itself states, as probabilities: claims first 0.04 · states limitation 0.93 · human participants 0.03 · controlled comparison 0.14 · randomized assignment 0.01 · states quantitative result 0.42 · compares with prior results 0.80 · mentions code or data availability 0.03.

The abstract, sentence by sentence

arXiv listing abstract v1. Results and the main claim are underlined; .

We study the safety problem for the next-generation access control (NGAC) model. We show that under mild assumptions it is coNP-complete, and under further realistic assumptions we give an algorithm for the safety problem that significantly outperforms naive brute force search. We also show that real-world examples of mutually exclusive attributes lead to nearly worst-case behavior of our algorithm.

background contribution method result interpretation main claim

What the classifier reports for each sentence. The number is the probability it gave the label.
#sentencerolethe authors' own workstates the main conclusionstrength
s0 We study the safety problem for the next-generation access control (NGAC) model. contribution 0.60 0.86 0.05 asserted 0.76
s1 We show that under mild assumptions it is coNP-complete, and under further realistic assumptions we give an algorithm for the safety problem that significantly outperforms naive brute force search. result 0.78 0.96 0.79 asserted 1.00
s2 We also show that real-world examples of mutually exclusive attributes lead to nearly worst-case behavior of our algorithm. result 0.67 0.92 0.08 asserted 1.00

What kind of paper the classifier reports this is: theoretical result 0.92 · evidence from proof or derivation 0.99.

What was examined, and what was not

sources read
  • arXiv listing abstract v1
not examined
  • full text
  • figures and tables
  • references and citing sentences
  • relations to other papers
levels run
  • P abstract
not run
  • S sections
  • T body sentences
  • C citations
  • R cross-paper relations

Every quoted sentence on this record is the authors'. Every label is from Pith's closed vocabulary, with the probability shown beside it. Every number in the measurements table is the authors', checked by code. Record as JSON

Figures
Figure 1. Reduction from DACC to coSP. 4 ALGORITHM In this section, we will introduce an algorithm that solves the safety problem for the NGAC model significantly faster than naive brute￾force search. We will first give an algorithm to solve DACC, and then explain how we can transform a safety problem input to an input for DACC to use the algorithm. 4.1 Solving DACC Let (𝐺,𝐶, 𝑠, 𝑡) be an input to DACC. Since we are trying to find a path in a valid subgraph of 𝐺, it suffices to enumerate maximal valid subgraphs of 𝐺. This is because adding edges to a valid sub￾graph cannot destroy the path we a

Figures reproduced from arXiv:2505.06406 by the authors.

References

Discussion

Disagree with the review, or know something it missed? Leave a comment, highlight any passage above to comment on it, or challenge this review formally.