AccessGate 0.2.0a1__tar.gz

accessgate-0.2.0a1/CHANGELOG.md

@@ -0,0 +1,82 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+- Deterministic policy and ordered policy-set fingerprints, externally supplied
+  signed-policy verification, and engine-owned policy-set decision identifiers.
+- Property/differential tests, parser fuzz targets, scheduled mutation testing,
+  authorization performance budgets, and golden policy-format fixtures.
+- Threat model, assurance case, immutable audit scope, secure-development,
+  strict policy migration, and evidence-preserving release procedures.
+- Reproducible release verification, hash-locked build tools, SPDX artifact SBOM,
+  checksums, GitHub artifact attestations, and OpenSSF Scorecard analysis.
+- Native async Django view support, including awaitable adapter resolvers and
+  denial handlers.
+- Bounded policy documents, condition depth, condition count, MCP messages, and
+  collection evaluation workloads.
+- Fail-closed decision-strategy error handling with an explicit
+  `strategy_error_mode`.
+
+### Changed
+
+- Authorization inputs, literal values, and decision metadata are recursively
+  snapshotted into immutable containers.
+- Operator registries attached to policies are frozen against later mutation.
+- Collection operators now classify invalid operand shapes as indeterminate.
+- Primitive collection intersection and subset checks use linear-time set
+  comparisons, and decisive condition branches short-circuit safely.
+- Policies declaring immutable action targets are indexed by action while
+  preserving configured evaluation order; `decide_many()` provides ordered
+  batch evaluation with per-request auditing.
+- GitHub Actions are commit-pinned, vulnerability auditing is blocking, and
+  package building is isolated from the PyPI publishing identity.
+
+### Security
+
+- Policy literals are excluded from decision metadata by default; diagnostic
+  inclusion is an explicit opt-in.
+- Signed envelopes reject tampering, unknown fields, unsupported versions,
+  non-canonical signatures, invalid verifier returns, and verifier failures.
+- Empty role requirements and malformed policy names/actions are rejected at
+  construction time.
+- Invalid policy results, invalid error-mode configuration, and strategy
+  exceptions can no longer create ambiguous authorization behavior.
+- Invalid or oversized JSON-RPC messages no longer terminate the MCP server.
+
+## [0.2.0a1] - 2026-08-11
+
+### Added
+
+- First-class ABAC across subject, resource, action, and context namespaces.
+- Tri-state conditions with fail-closed missing-data and operator-error handling.
+- Exact equality, membership, set-relation, numeric, and existence operators.
+- Nested `AllOf`, `AnyOf`, and indeterminate-preserving `Not` conditions.
+- Policy-local custom operator registries and custom operand protocol support.
+- Versioned `access_gate.policy.v1` serialization and packaged JSON Schema.
+- Strict serialized-policy parsing with unknown-field and duplicate-action rejection.
+- Django action-attribute resolver support.
+- Dependency-free MCP server with resources, prompts, operator discovery, schema
+  discovery, and real read-only policy validation.
+
+### Changed
+
+- Package version advanced to `0.2.0a1`.
+
+## [0.1.0a1] - 2026-08-11
+
+### Added
+
+- Framework-neutral subject, resource, request, and decision value objects.
+- Default-deny, deny-overrides authorization engine.
+- Configurable fail-closed policy and audit error handling.
+- Policy, decision strategy, resolver, and audit sink extension protocols.
+- Built-in authentication, role, ownership, and tenant-boundary policies.
+- Optional Django view decorator adapter with replaceable resolvers and denial handler.
+- Test, security, and trusted-publishing workflows.

accessgate-0.2.0a1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tunet Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

accessgate-0.2.0a1/MANIFEST.in

@@ -0,0 +1,10 @@
+include CHANGELOG.md
+include LICENSE
+include README.md
+include SECURITY.md
+recursive-include docs *.md
+recursive-include fuzz *.json *.py
+recursive-include mcp *.json *.md *.py
+recursive-include requirements *.in *.txt
+recursive-include tests *.json *.py
+recursive-include tools *.py

accessgate-0.2.0a1/PKG-INFO

@@ -0,0 +1,287 @@
+Metadata-Version: 2.4
+Name: AccessGate
+Version: 0.2.0a1
+Summary: Composable, default-deny authorization for Python applications.
+Author-email: Tunet Ltd <alex@tunet.xyz>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Tunet-xyz/access_gate
+Project-URL: Documentation, https://github.com/Tunet-xyz/access_gate#readme
+Project-URL: Repository, https://github.com/Tunet-xyz/access_gate
+Project-URL: Issues, https://github.com/Tunet-xyz/access_gate/issues
+Project-URL: Changelog, https://github.com/Tunet-xyz/access_gate/blob/main/CHANGELOG.md
+Keywords: authorization,access-control,rbac,abac,security,policy
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: django
+Requires-Dist: Django>=4.2; extra == "django"
+Provides-Extra: dev
+Requires-Dist: Django>=4.2; extra == "dev"
+Requires-Dist: bandit>=1.7; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: django-stubs>=4.2; extra == "dev"
+Requires-Dist: hypothesis<7,>=6.112; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Requires-Dist: pip-audit>=2.7; extra == "dev"
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+Requires-Dist: setuptools>=68; extra == "dev"
+Requires-Dist: tomli>=2; python_version < "3.11" and extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+Provides-Extra: assurance
+Requires-Dist: hypothesis<7,>=6.112; extra == "assurance"
+Requires-Dist: mutmut==3.7.0; extra == "assurance"
+Requires-Dist: pytest>=8.0; extra == "assurance"
+Provides-Extra: fuzz
+Requires-Dist: atheris==3.0.0; extra == "fuzz"
+Dynamic: license-file
+
+# AccessGate
+
+Composable, default-deny RBAC, ABAC, and relationship-aware authorization for
+Python applications.
+
+AccessGate answers one question: **may this subject perform this action on
+this resource in this context?** It provides a small framework-neutral kernel,
+secure decision defaults, and extension interfaces for application-specific
+identity, policy, audit, and framework integration.
+
+It is complementary to authentication and session-security packages such as
+SessionArmor. Those establish who the caller is and whether the session can be
+trusted; AccessGate decides what that caller is allowed to do.
+
+> **Status:** early alpha. Security controls and assurance evidence are being
+> developed rigorously, but the public API may evolve before 1.0. This package
+> has not received an independent audit or any government/NATO accreditation.
+
+## Design guarantees
+
+- **Default deny:** abstention never grants access.
+- **Deny overrides:** any explicit denial wins over grants by default.
+- **Fail closed:** policy and audit failures deny access by default.
+- **Exact matching:** built-in role, action, owner, and tenant comparisons never
+  use substring matching.
+- **Safe ABAC:** missing attributes and operator failures are indeterminate,
+  cannot be negated into access, and deny by default.
+- **Immutable inputs:** request attributes, literal values, and decision metadata
+  are recursively snapshotted before evaluation or audit.
+- **Bounded evaluation:** serialized policies, condition trees, MCP messages, and
+  collection workloads have explicit denial-of-service limits.
+- **Verifiable policy identity:** canonical fingerprints, ordered policy-set
+  fingerprints, externally verified signed envelopes, and engine-owned policy
+  deployment identifiers support change control without embedding key custody.
+- **No expression evaluation:** declarative policies use registered operators
+  and mapping-only attribute traversal—never Python `eval` or object traversal.
+- **Framework-neutral core:** no runtime dependencies and no ORM, token, or user
+  model assumptions.
+- **Custom from day one:** policies, decision strategies, identity/resource
+  resolvers, audit sinks, and framework adapters are public extension points.
+
+`Subject`, `Resource`, `AuthorizationRequest`, and `Decision` expose `to_dict()`
+for JSON-friendly snapshots of their otherwise immutable data.
+
+## Installation
+
+```bash
+pip install AccessGate
+```
+
+For the optional Django adapter:
+
+```bash
+pip install "AccessGate[django]"
+```
+
+## Quick start
+
+```python
+from access_gate import (
+    AuthorizationEngine,
+    Resource,
+    RolePolicy,
+    Subject,
+    TenantBoundaryPolicy,
+)
+
+engine = AuthorizationEngine(
+    [
+        TenantBoundaryPolicy(actions={"incident.read"}),
+        RolePolicy({"incident_manager"}, actions={"incident.read"}),
+    ]
+)
+
+decision = engine.authorize(
+    Subject(
+        "user-42",
+        roles=frozenset({"incident_manager"}),
+        attributes={"tenant_id": "acme"},
+    ),
+    "incident.read",
+    Resource("incident", "INC-123", {"tenant_id": "acme"}),
+)
+
+assert decision.allowed
+```
+
+Tenant boundaries deliberately do not grant access. They abstain when the
+tenant matches and deny when it is missing or different; another policy must
+positively allow the action.
+
+## Attribute-based access control
+
+ABAC policies can compare subject, resource, action, and context attributes:
+
+```python
+from access_gate import (
+    ActionAttribute,
+    AllOf,
+    AttributePolicy,
+    ContextAttribute,
+    ResourceAttribute,
+    SubjectAttribute,
+)
+
+document_access = AttributePolicy(
+    AllOf(
+        SubjectAttribute("department").equals(ResourceAttribute("department")),
+        SubjectAttribute("clearance").greater_than_or_equal(
+            ResourceAttribute("classification")
+        ),
+        ActionAttribute("risk").less_than_or_equal(3),
+        ContextAttribute("device.trusted").equals(True),
+    ),
+    actions={"document.read"},
+    name="document_access",
+)
+```
+
+Conditions support `AllOf`, `AnyOf`, and `Not`, multi-valued attributes, exact
+membership and set relations, numeric comparisons, and explicit existence
+checks. `Not` preserves indeterminate outcomes, so a missing attribute never
+becomes a grant merely because a condition was negated.
+
+Policies serialize to the versioned `access_gate.policy.v1` format:
+
+```python
+from access_gate import dumps_policy, loads_policy
+
+document = dumps_policy(document_access)
+restored = loads_policy(document)
+```
+
+For controlled deployments, identify the exact ordered policy set and pass that
+identifier into the engine so every final and audited decision is attributable:
+
+```python
+from access_gate import AuthorizationEngine, policy_set_fingerprint
+
+policy_set_id = policy_set_fingerprint([document_access])
+engine = AuthorizationEngine([document_access], policy_set_id=policy_set_id)
+```
+
+`dumps_signed_policy()` and `loads_signed_policy()` accept application-supplied
+signer/verifier protocols. AccessGate deliberately does not choose algorithms,
+store keys, or implement a trust store. See
+[`docs/POLICY_FORMAT.md`](docs/POLICY_FORMAT.md).
+
+See [`docs/abac.md`](docs/abac.md) for the full data model, operator semantics,
+customization rules, JSON format, and rollout guidance.
+
+## Application-defined policies
+
+Implement the `Policy` protocol directly or wrap a function:
+
+```python
+from access_gate import Decision, FunctionPolicy
+
+def published_incidents(request):
+    resource = request.resource
+    if resource and resource.attributes.get("published") is True:
+        return Decision.allow("The incident is public.", policy="published")
+    return None
+
+policy = FunctionPolicy("published", published_incidents)
+```
+
+A policy returns an allow/deny `Decision`, or `None` to abstain. Custom decision
+strategies can replace deny-overrides where a domain needs different semantics.
+Policies exposing a validated `frozenset` in an `actions` attribute are indexed
+by the engine and skipped for unrelated actions. `FunctionPolicy` supports this
+directly through its `actions` argument. Use `decide_many()` for ordered batch
+evaluation; every request still receives its own decision and audit event.
+
+For mixed RBAC/ABAC grants, configure alternative grant policies to abstain on
+a miss. Explicit boundary denials still override every grant.
+
+## Django adapter
+
+```python
+from access_gate import AuthorizationEngine, RolePolicy
+from access_gate.adapters.django import DjangoAuthorizer
+
+authorizer = DjangoAuthorizer(
+    AuthorizationEngine([RolePolicy({"admin"}, actions={"users.list"})])
+)
+
+@authorizer.require("users.list")
+def user_list(request):
+    ...
+```
+
+The default Django subject resolver only reads `pk`, `is_authenticated`,
+`access_gate_roles`, and `access_gate_attributes`. Real applications should
+normally provide a resolver that validates and maps their exact identity claims.
+The adapter also accepts custom context and action-attribute resolvers for ABAC.
+Synchronous and asynchronous Django views are supported. Async views may use
+awaitable subject, resource, context, action-attribute, and denial resolvers.
+
+## MCP server
+
+AccessGate includes a dependency-free stdio MCP server:
+
+```bash
+accessgate-mcp
+```
+
+From a source checkout, run `python mcp/server.py`. The server exposes package
+capabilities, authorization-model guidance, the ABAC JSON Schema, exact built-in
+operator discovery, and read-only policy validation. It does not authenticate
+users, evaluate production identity data, or change application policy.
+
+## Project boundary
+
+AccessGate does not authenticate users, validate JWTs, secure sessions, query
+application permissions, or decide how tenants and resources are represented.
+Those are application and adapter responsibilities. See
+[`docs/architecture.md`](docs/architecture.md) and
+[`docs/customization.md`](docs/customization.md). AccessGate provides its own
+policy format but does not claim wire compatibility with XACML, Cedar, Rego, or
+other policy languages.
+
+## Development
+
+```bash
+python -m pip install -e ".[dev]"
+ruff check src tests
+mypy src/access_gate
+pytest --cov=access_gate --cov-report=term-missing
+```
+
+Security reviewers should begin with the
+[`threat model`](docs/THREAT_MODEL.md),
+[`assurance case`](docs/SECURITY_ASSURANCE.md), and
+[`audit scope`](docs/AUDIT_SCOPE.md).
+
+## License
+
+MIT (c) Tunet Ltd.

accessgate-0.2.0a1/README.md

@@ -0,0 +1,239 @@
+# AccessGate
+
+Composable, default-deny RBAC, ABAC, and relationship-aware authorization for
+Python applications.
+
+AccessGate answers one question: **may this subject perform this action on
+this resource in this context?** It provides a small framework-neutral kernel,
+secure decision defaults, and extension interfaces for application-specific
+identity, policy, audit, and framework integration.
+
+It is complementary to authentication and session-security packages such as
+SessionArmor. Those establish who the caller is and whether the session can be
+trusted; AccessGate decides what that caller is allowed to do.
+
+> **Status:** early alpha. Security controls and assurance evidence are being
+> developed rigorously, but the public API may evolve before 1.0. This package
+> has not received an independent audit or any government/NATO accreditation.
+
+## Design guarantees
+
+- **Default deny:** abstention never grants access.
+- **Deny overrides:** any explicit denial wins over grants by default.
+- **Fail closed:** policy and audit failures deny access by default.
+- **Exact matching:** built-in role, action, owner, and tenant comparisons never
+  use substring matching.
+- **Safe ABAC:** missing attributes and operator failures are indeterminate,
+  cannot be negated into access, and deny by default.
+- **Immutable inputs:** request attributes, literal values, and decision metadata
+  are recursively snapshotted before evaluation or audit.
+- **Bounded evaluation:** serialized policies, condition trees, MCP messages, and
+  collection workloads have explicit denial-of-service limits.
+- **Verifiable policy identity:** canonical fingerprints, ordered policy-set
+  fingerprints, externally verified signed envelopes, and engine-owned policy
+  deployment identifiers support change control without embedding key custody.
+- **No expression evaluation:** declarative policies use registered operators
+  and mapping-only attribute traversal—never Python `eval` or object traversal.
+- **Framework-neutral core:** no runtime dependencies and no ORM, token, or user
+  model assumptions.
+- **Custom from day one:** policies, decision strategies, identity/resource
+  resolvers, audit sinks, and framework adapters are public extension points.
+
+`Subject`, `Resource`, `AuthorizationRequest`, and `Decision` expose `to_dict()`
+for JSON-friendly snapshots of their otherwise immutable data.
+
+## Installation
+
+```bash
+pip install AccessGate
+```
+
+For the optional Django adapter:
+
+```bash
+pip install "AccessGate[django]"
+```
+
+## Quick start
+
+```python
+from access_gate import (
+    AuthorizationEngine,
+    Resource,
+    RolePolicy,
+    Subject,
+    TenantBoundaryPolicy,
+)
+
+engine = AuthorizationEngine(
+    [
+        TenantBoundaryPolicy(actions={"incident.read"}),
+        RolePolicy({"incident_manager"}, actions={"incident.read"}),
+    ]
+)
+
+decision = engine.authorize(
+    Subject(
+        "user-42",
+        roles=frozenset({"incident_manager"}),
+        attributes={"tenant_id": "acme"},
+    ),
+    "incident.read",
+    Resource("incident", "INC-123", {"tenant_id": "acme"}),
+)
+
+assert decision.allowed
+```
+
+Tenant boundaries deliberately do not grant access. They abstain when the
+tenant matches and deny when it is missing or different; another policy must
+positively allow the action.
+
+## Attribute-based access control
+
+ABAC policies can compare subject, resource, action, and context attributes:
+
+```python
+from access_gate import (
+    ActionAttribute,
+    AllOf,
+    AttributePolicy,
+    ContextAttribute,
+    ResourceAttribute,
+    SubjectAttribute,
+)
+
+document_access = AttributePolicy(
+    AllOf(
+        SubjectAttribute("department").equals(ResourceAttribute("department")),
+        SubjectAttribute("clearance").greater_than_or_equal(
+            ResourceAttribute("classification")
+        ),
+        ActionAttribute("risk").less_than_or_equal(3),
+        ContextAttribute("device.trusted").equals(True),
+    ),
+    actions={"document.read"},
+    name="document_access",
+)
+```
+
+Conditions support `AllOf`, `AnyOf`, and `Not`, multi-valued attributes, exact
+membership and set relations, numeric comparisons, and explicit existence
+checks. `Not` preserves indeterminate outcomes, so a missing attribute never
+becomes a grant merely because a condition was negated.
+
+Policies serialize to the versioned `access_gate.policy.v1` format:
+
+```python
+from access_gate import dumps_policy, loads_policy
+
+document = dumps_policy(document_access)
+restored = loads_policy(document)
+```
+
+For controlled deployments, identify the exact ordered policy set and pass that
+identifier into the engine so every final and audited decision is attributable:
+
+```python
+from access_gate import AuthorizationEngine, policy_set_fingerprint
+
+policy_set_id = policy_set_fingerprint([document_access])
+engine = AuthorizationEngine([document_access], policy_set_id=policy_set_id)
+```
+
+`dumps_signed_policy()` and `loads_signed_policy()` accept application-supplied
+signer/verifier protocols. AccessGate deliberately does not choose algorithms,
+store keys, or implement a trust store. See
+[`docs/POLICY_FORMAT.md`](docs/POLICY_FORMAT.md).
+
+See [`docs/abac.md`](docs/abac.md) for the full data model, operator semantics,
+customization rules, JSON format, and rollout guidance.
+
+## Application-defined policies
+
+Implement the `Policy` protocol directly or wrap a function:
+
+```python
+from access_gate import Decision, FunctionPolicy
+
+def published_incidents(request):
+    resource = request.resource
+    if resource and resource.attributes.get("published") is True:
+        return Decision.allow("The incident is public.", policy="published")
+    return None
+
+policy = FunctionPolicy("published", published_incidents)
+```
+
+A policy returns an allow/deny `Decision`, or `None` to abstain. Custom decision
+strategies can replace deny-overrides where a domain needs different semantics.
+Policies exposing a validated `frozenset` in an `actions` attribute are indexed
+by the engine and skipped for unrelated actions. `FunctionPolicy` supports this
+directly through its `actions` argument. Use `decide_many()` for ordered batch
+evaluation; every request still receives its own decision and audit event.
+
+For mixed RBAC/ABAC grants, configure alternative grant policies to abstain on
+a miss. Explicit boundary denials still override every grant.
+
+## Django adapter
+
+```python
+from access_gate import AuthorizationEngine, RolePolicy
+from access_gate.adapters.django import DjangoAuthorizer
+
+authorizer = DjangoAuthorizer(
+    AuthorizationEngine([RolePolicy({"admin"}, actions={"users.list"})])
+)
+
+@authorizer.require("users.list")
+def user_list(request):
+    ...
+```
+
+The default Django subject resolver only reads `pk`, `is_authenticated`,
+`access_gate_roles`, and `access_gate_attributes`. Real applications should
+normally provide a resolver that validates and maps their exact identity claims.
+The adapter also accepts custom context and action-attribute resolvers for ABAC.
+Synchronous and asynchronous Django views are supported. Async views may use
+awaitable subject, resource, context, action-attribute, and denial resolvers.
+
+## MCP server
+
+AccessGate includes a dependency-free stdio MCP server:
+
+```bash
+accessgate-mcp
+```
+
+From a source checkout, run `python mcp/server.py`. The server exposes package
+capabilities, authorization-model guidance, the ABAC JSON Schema, exact built-in
+operator discovery, and read-only policy validation. It does not authenticate
+users, evaluate production identity data, or change application policy.
+
+## Project boundary
+
+AccessGate does not authenticate users, validate JWTs, secure sessions, query
+application permissions, or decide how tenants and resources are represented.
+Those are application and adapter responsibilities. See
+[`docs/architecture.md`](docs/architecture.md) and
+[`docs/customization.md`](docs/customization.md). AccessGate provides its own
+policy format but does not claim wire compatibility with XACML, Cedar, Rego, or
+other policy languages.
+
+## Development
+
+```bash
+python -m pip install -e ".[dev]"
+ruff check src tests
+mypy src/access_gate
+pytest --cov=access_gate --cov-report=term-missing
+```
+
+Security reviewers should begin with the
+[`threat model`](docs/THREAT_MODEL.md),
+[`assurance case`](docs/SECURITY_ASSURANCE.md), and
+[`audit scope`](docs/AUDIT_SCOPE.md).
+
+## License
+
+MIT (c) Tunet Ltd.