# Enforcing Cryptographic Distributed-VCS Access Control with No Trust on Servers

Crypto.world

> In a distributed version control system like Git, every participant holds a full copy of the repository and can exchange modifications directly with peers, with no central server in the loop.

**arXiv**: 2607.29417

**Published**: 2026-07-31

**Authors**: Xin Xu, Zhen Yang, Quanwei Cai, Jingqiang Lin, Liangqin Ren, Bo Chen, Yongfeng Huang

## AI summary

Enforcing Cryptographic Distributed-VCS Access Control with No Trust on Servers

## Overview

**Research area:** Applied cryptography and blockchain-based access control for distributed version control systems (DVCS), specifically combining attribute-based encryption (CP-ABE), attribute-based signatures (ABS), and Ethereum smart contracts.

**Technical level:** Advanced. The paper assumes familiarity with attribute-based cryptography, Git internals, and smart contract deployment.

**Scope:** The paper designs, implements, and evaluates DVAC, a server-free access control scheme that enforces file-granularity, read/write-separated permissions directly on distributed DVCS nodes, demonstrated as a prototype integrated with Git.

## What This Paper Is About

In a distributed version control system like Git, every participant holds a full copy of the repository and can exchange modifications directly with peers, with no central server in the loop. Existing access control schemes for cloud storage, central VCS, and even Git either depend on a server to enforce policy, or they only protect read access and ignore write permissions. The paper's goal is to enforce cryptographic read *and* write access control on each individual peer's machine, with no trusted server, while keeping normal version control operations (commit, branch, diff, merge) working.

## Key Contributions

1. **Server-free cryptographic enforcement for DVCS.** DVAC controls access to files on distributed user nodes without any central server participating, using CP-ABE for read permissions and ABS for write permissions.
2. **Read/write separation plus a version control adaptation protocol.** A read/write-separated access control protocol and a version control adaptation (VCA) protocol are defined so that data is protected in the repository and on the network, without disrupting version control operations in the workspace.
3. **Distributed, trusted metadata and policy management via Ethereum smart contracts.** Each access control policy is bound one-to-one to a file, stored and versioned by a smart contract so that all nodes see consistent policy, while the policy remains under the data owner's control.
4. **A Git-integrated prototype with lightweight key management.** The authors implemented DVAC and integrated it with Git through Git filters, requiring minimal configuration; users only maintain their own read and write attribute keys, regardless of the number of users, and the measured overhead is described as modest.

## Main Findings

- **No central server is required for enforcement:** Access control is enforced locally on each peer. Data received from other nodes arrives as `[Cipher, Sig]` and can only be read after signature verification and decryption by the recipient; unauthorized modifications only corrupt the modifier's own local repository and are not accepted by others.
- **Read and write permissions are controlled separately and at file granularity:** Users whose attributes do not satisfy the read policy `AP_r` cannot decrypt the ciphertext; modifications signed by users whose attributes do not satisfy the write policy `AP_w` are rejected during verification. Version validity is checked by walking back through historical versions until a valid one is found.
- **Per-file unique identifiers prevent ownership confusion:** The file ID is defined as `ID^f = (Init_CID | R_Name | F_Path)`, combining a digest of the repository's first commit information, the repository name, and the relative file path, so users can reliably index metadata without duplication or data-owner preemption.
- **Metadata replay and preemption attacks are addressed through the blockchain:** Because DVCS users cannot build a global view of the repository on their own, metadata stored as ordinary files would be vulnerable to metadata replay attacks (recovering revoked permissions) and data owner preemption attacks. The TMM module stores metadata in an append-only, immutable smart contract ledger with `Md_Create`, `Md_Modify`, `Md_Replace`, and `Md_Query` operations; creation checks that `ID^f` is unused in `List_f`, and modifications verify `ID^o` and account binding.
- **Key management does not scale with the number of collaborators:** DVAC requires each entity to perform one ABE encryption and one ABS signature per version, regardless of the number of cooperators, in contrast to proxy re-encryption schemes that re-encrypt per version per delegated user.
- **Version control still works on ciphertext repositories:** The VCA protocol releases cryptographic protection only when a version control command (e.g. diff/merge) is executed, forwards the plaintext of the relevant versions to the DVCS, and displays the result in the workspace while the files in the repository remain encrypted.
- **Overhead is described qualitatively, not numerically, in the provided content:** The paper states that a comprehensive performance evaluation was conducted and that the overhead is "modest" and "within acceptable limits for practical usage scenarios." Specific measurement values, dataset sizes, and benchmark names are not reported in the supplied text (the evaluation section is truncated).

## Methodology in Plain English

The authors split the problem into three cooperating modules and designed a protocol for each.

First, an **enforcing cryptographic access control (EAC)** module. A trusted attribute authority runs the ABE and ABS setup procedures, registers users with verifiable identities, and issues each user a read attribute key and a write attribute key. When a data owner creates a file, they choose a read policy and a write policy, the system derives a unique file ID, and a metadata creation request goes to the smart contract, possibly in parallel with writing the file. The file content is encrypted with symmetric encryption under a key protected by CP-ABE, then signed with ABS, and stored as `[Meta, Cipher, Sig]`. Readers fetch the metadata for the specific version from the contract, verify the signature against the write policy, then attempt decryption against the read policy.

Second, a **version control adaptation (VCA)** module, because Git's diff, merge, and comparison logic cannot operate on ciphertext that changes on every version. When a user issues such a command, DVAC queries the contract for metadata for the involved versions, verifies and decrypts each, and hands the plaintext to Git, leaving the stored files encrypted.

Third, a **trusted metadata management (TMM)** module built as an Ethereum smart contract. It maintains a user list mapping blockchain accounts to identities, a list of allocated file IDs, and a list of all metadata versions indexed by file ID. Registration verifies a certificate signed by a trusted institution and a user signature over the account and certificate. Creation and modification require the caller's account to match the recorded owner account. Queries are open to anyone.

The prototype hooks into Git using Git filters, so the standard workflow is preserved. Security is argued against a threat model in which the attribute authority is trusted, public repositories are honest-but-curious, and malicious users may attempt unauthorized reads, upload invalid modifications, launch DDoS attacks, or collude.

## Why This Matters

**Impact on research.** The paper reframes access control for version control as a problem that must be solved on untrusted endpoints rather than at a server, and shows that read and write permissions can be separated cryptographically for a system whose whole design assumes peers trust each other's data exchange. It also identifies metadata freshness as a first-class security problem in decentralized settings, motivating the use of an append-only ledger rather than ordinary file storage for policy.

**Real-world applications:**

- **Open-source and enterprise code collaboration** where developers mirror repositories and no single hosting provider is trusted to enforce policy.
- **Regulated document and source management** in which some collaborators may read a file but only a subset may modify it, and where an audit trail of policy versions is required.
- **Multi-party projects spanning organizations** (for example consortium engineering or research collaborations) with no mutually trusted administrative server.
- **Air-gapped or offline-capable workflows** where contributors synchronize peer-to-peer rather than through a hosted platform.

**Industry relevance.** Because the design targets Git with minimal modification and uses Git filters for integration, it is a plausible drop-in layer for existing developer tooling rather than a replacement VCS. The use of Ethereum for policy storage rather than for data storage keeps on-chain costs limited to metadata, and the property that key management is independent of collaborator count matters for large repositories. The paper explicitly positions DVAC against Git-based tools including Gitolite, Git-crypt, git-remote-gcrypt, GitHub Enterprise's role-based model, Keybase-git, and Gringotts (Xu et al., 2023), which relies on a remote server holding an encrypted shadow repository.

## Future Directions

- **Quantifying the overhead in detail.** The supplied content reports only that overhead is "modest"; publishing per-operation costs for encryption, signing, verification, decryption, contract calls, and diff/merge on encrypted files would let practitioners judge fit for large repositories.
- **Reducing blockchain dependence and cost.** Every metadata creation, modification, and query involves a smart contract; measuring and lowering gas cost, or designing caching and batching, is a natural next step, as is examining behavior when the chain is congested or unavailable.
- **Strengthening the trusted-authority assumption.** The threat model trusts the attribute authority to hold `MK_r`, `MK_w`, and user secret keys and to verify attributes honestly; decentralizing or thresholdizing key issuance, and adding attribute revocation for DVCS, remain open questions.
- **Handling richer Git semantics.** The version control adaptation protocol is described for diff and merge on file versions; extending cryptographic enforcement to branch-level and repository-level granularity, and to conflict resolution across many concurrent writers, is not addressed and would broaden applicability.

## Target Audience

Researchers and graduate students in applied cryptography, blockchain systems, and secure software engineering; developers and security architects building or hardening self-hosted and federated code collaboration platforms; and practitioners who need file-level, read/write-separated access control in environments where no server can be trusted. Readers should be comfortable with attribute-based cryptography and Git internals, since the paper's core arguments rest on CP-ABE and ABS constructions and on Git's filter and object model.

## Authors’ abstract

Version control systems (VCS), including central VCS (CVCS) and distributed VCS (DVCS), are widely adopted to manage changes to software code and various types of documents. Unlike CVCS, where entities obtain data from a central server, each entity in DVCS stores the entire repository and shares it independently. In VCS, existing access control schemes require the participation of a central server and cannot be deployed in a completely distributed scenario. Additionally,…

[The full abstract on arXiv](https://arxiv.org/abs/2607.29417)

[Read the original paper](https://arxiv.org/abs/2607.29417)

---

Canonical: https://crypto.world/paper/enforcing-cryptographic-distributed-vcs-access-control-with-no-trust-on-2607.29417
