Automated Resolution of Security Policy Conflicts

82 concepts65 papers1 proposal

As modern computing environments scale from simple local networks to massive containerized microservices, cloud platforms, and interconnected Internet of Things (IoT) devices, the rules governing their security grow exponentially. Security policies—whether they dictate firewall rules, cloud access permissions, or smart-home automations—are rarely written all at once. Instead, they are authored incrementally by different administrators, applications, or users over long periods.

This organic growth creates a fundamental challenge: policy conflict. When multiple independent rules overlap, they frequently contradict one another, leading to "policy bloat," security vulnerabilities, or accidental operational shutdowns. To build reliable systems, researchers have developed formal methods to automatically detect, model, and resolve these logical contradictions.

The Root of Policy Bloat and Contradiction

To understand why policies conflict, consider how security rules are traditionally maintained. When a new application or user requires access, administrators typically append a new rule to the existing configuration rather than refactoring the entire system.

As Yi Zhang 0016 and Yong Zhang observe in their work on Optimization of Firewall Filtering Rules by a Thorough Rewriting, this incremental patching causes rules to accumulate over time, creating hidden anomalies where some rules are "shadowed" or rendered completely redundant by others. The authors argue in a parallel paper, Policy Engineering for Security Management of Organization Information Systems, that the absence of a structured lifecycle for policy maintenance obscures vulnerabilities and severely complicates system administration.

This complexity compounds rapidly in modern infrastructure:

Mapping the Conflict Space Geometrically and Semantically

Before a system can resolve a conflict, it must precisely locate where rules intersect. Researchers achieve this by translating abstract text-based rules into formal mathematical spaces.

Geometric Hyperspaces

One intuitive approach is to treat security rules as geometric coordinates. In Optimization of Firewall Filtering Rules by a Thorough Rewriting, the authors map firewall rules (which filter based on source IP, destination IP, and port) into a multi-dimensional hyperspace. When two rules claim authority over the same coordinate but dictate different actions (such as Allow vs. Deny), the geometric intersection immediately flags the conflict, allowing the system to thoroughly rewrite the rule-base into a minimal, non-overlapping set.

Semantic Ontologies

When policies originate from entirely different domains—such as a corporate security policy clashing with a local database access rule—geometric mapping falls short because the systems speak different languages. To bridge this gap, Gail-Joon Ahn et al. introduce a framework in Ontology-based policy anomaly management for autonomic computing that uses semantic ontologies combined with Binary Decision Diagrams (BDDs). By translating disparate rules into a unified, standardized semantic model, their system can identify cross-domain permission clashes in less than a second. Similarly, Lalana Kagal et al. demonstrate in Using Semantic Web Technologies for Policy Management on the Web that decentralized systems can use mathematical reasoning engines to parse and link heterogeneous policies across the web without forcing every entity to adopt an identical policy language.

Arbitration Strategies: How Conflicts are Resolved

Once an automated system detects an overlap, it must apply an arbitration strategy to determine which rule takes precedence.

Deterministic Overrides

The simplest strategy is a structural meta-policy, such as "negative authorization overrides positive authorization." In A Model-driven Approach to enable Access Control for Ontologies, Willy Chen et al. employ this strict precedence rule to ensure that if a user inherits conflicting permissions from multiple roles, the most restrictive policy wins, preventing accidental data leaks. However, Seungsoo Lee notes in Kunerva that purely allow-based policy generators face severe logical hurdles when forced to operate in environments governed by these heavy-handed, overlapping deny rules.

Three-Valued Logic and Well-Founded Semantics

In complex systems, rules can be circular or recursive—for example, User A delegates rights to User B, who delegates to User C, who then attempts to revoke User A's rights. In these scenarios, standard binary logic (True/False) causes the evaluation engine to loop infinitely or crash.

To solve this, Pieter Van Hertum et al. introduce a framework based on Distributed Autoepistemic Logic in Distributed Autoepistemic Logic and its Application to Access Control. By utilizing a three-valued logic that includes an unknown or undecidable state alongside true and false, the system can cautiously isolate circular contradictions rather than generating unstable authorization states.

Argumentation Logic

Instead of relying on rigid, pre-ordered rule hierarchies, Arosha K. Bandara et al. propose treating policies as competing arguments. In Using Argumentation Logic for Firewall Policy Specification and Analysis, the authors present a declarative framework where rules act as assertions. When conflicts occur, the system uses formal argumentation mathematics to compute the most logically sound "winning" argument, providing the added benefit of generating human-readable explanations for why a specific action was allowed or blocked.

The Limits of Multi-Party Reconciliation

While resolving conflicts within a single firewall or application is a well-understood mathematical problem, scaling this to multi-party environments introduces hard theoretical limits.

In their foundational paper, Methods and limitations of security policy reconciliation, Patrick D. McDaniel et al. prove that while automatically harmonizing the security policies of two distinct entities is highly efficient, reconciling policies among three or more independent participants is generally intractable (NP-hard). This reality forces distributed systems to rely on heuristic approximations or sequential, pairwise reconciliations. Furthermore, the authors demonstrate that standard conjunction-based reconciliation (simply intersecting the allowed actions of all parties) often yields an overly restrictive policy that inadvertently halts legitimate session progress.

This tension between security constraints and operational necessity represents the frontier of conflict resolution research. As Ruixuan Li et al. point out in Consistency Checking of Safety and Availability in Access Control, security policies (safety) and operational workflows (availability) are frequently developed in isolation. Without automated consistency checkers capable of suggesting which specific constraints to weaken, deployed policies can easily paralyze an organization.

In cyber-physical and IoT environments, this trade-off can become dangerous. As Z. Berkay Celik et al. demonstrate in IoTGuard: Dynamic Enforcement of Security and Safety Policy in Commodity IoT, an automated policy engine that strictly enforces a digital security rule might create a physical safety hazard—such as blocking an emergency command to unlock a smart door during a house fire. Resolving these high-stakes, real-time contradictions remains one of the most critical challenges in modern policy engineering.

Key Foundational Work

Being Suspicious: Critiquing Problem Specifications (1988) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_policy_conflict_resolution_f2d425c0,
  title = {policy conflict resolution},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/policy-conflict-resolution/rdr_f2d425c0922a46e1aeea406b86a0d63c},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 1, frozen text):

@misc{lacuna_policy_conflict_resolution_f2d425c0_v1,
  title = {policy conflict resolution},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/policy-conflict-resolution/rdr_f2d425c0922a46e1aeea406b86a0d63c/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake