Analysis of Commit Signing on GitHub
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.
Tom: I'm Tom.
Jane: And I'm Jane, here with Lu, Meng and our in-house large language model, Lalam.
Tom: We're looking at the paper: "Analysis of Commit Signing on GitHub".
Paper summary: Tom: So, looking at "Analysis of Commit Signing on GitHub," this paper really drives home a point about how we talk about security versus what's actually happening in practice on these massive platforms.
Jane: It seems the authors are showing that the illusion of widespread commit signing is largely an artifact of platform mediation, not necessarily developer intent.
Lu: They conclude that the failure to achieve ubiquitous end-to-end commit signing isn't just a behavioral issue with developers; it’s a structural problem within GitHub’s ecosystem design.
Meng: From an engineering standpoint, this suggests that relying on manual key management for every single contributor is fundamentally unsustainable because of the friction they found.
Tom: And what they find is this tension between how easy it is to use something, how cryptographically sound it needs to be, and making sure everyone follows the same pattern consistently.
Jane: So, for someone just listening who isn't deep into commit signing, what does this paper actually change for them?
Lu: It suggests that future solutions might need to focus less on getting every developer to adopt a single manual process and more on tooling that abstracts away the complexity of key management entirely.
Meng: I think if the tools could handle the friction, maybe developers would actually stick with it instead of abandoning it when they get tired.
Tom: Exactly. The paper shows that until we solve this structural problem, we're stuck with a fragmented and inconsistent approach to verifying code provenance on GitHub.
Conclusion: Tom: So we're wrapping up our look at this paper, "Analysis of Commit Signing on GitHub."
Jane: It basically boils down to how most of what you see as secure code contributions on GitHub isn't actually end-to-end signed by the developer.
Tom: Yeah, it shows that a huge chunk of those signatures are just coming from the GitHub website itself, not from the person who wrote the code.
Lu: The authors say this failure to get widespread end-to-end signing isn't just about people being lazy or bad at security.
Meng: They found a structural problem in how things are set up that makes it really hard for developers to stick with it consistently across all their work.
Jane: So what’s the big picture here? It suggests that even though we talk about secure software supply chains, the way GitHub is currently built doesn't actually enforce the security we expect.
Tom: Exactly. The paper points out a trilemma between how easy it is to sign something, how well it's actually cryptographically secure, and whether everyone uses the same method.
Jane: It’s like trying to make a universal lock that works for every single door on GitHub, but the design of the lock itself makes it impossible to be both easy and perfect everywhere at once.
Tom: And they found that even if a developer *does* manage to sign things, they rarely keep doing it consistently across all their projects over time.
Jane: That means the "perfect security practitioner" you see on GitHub might just be a rare exception rather than the norm.
Lu: They also looked at key management and found that most of those keys just sit there for a long time without anyone actually revoking them when they should.
Meng: That’s worrying because if keys aren't managed properly, it opens up vulnerabilities down the line where an attacker could use old credentials.
Jane: The conclusion is that we can't fix this by just telling developers to be better at signing things individually.
Tom: No, the paper suggests we need to look at how GitHub organizes these signing processes fundamentally to make consistency the default, not something that requires a lot of manual effort from every single person.
Jane: So what does that mean for us on the outside? It means we need to think about better ways to verify code provenance than just looking at individual commit signatures anymore.
Tom: Right. And if we don't address this structural mismatch between ease of use and true security, then the whole idea of a trusted open-source supply chain stays pretty fragile.
Jane: Next up, we’re going to look at how this impacts the actual tools developers use for checking code integrity.
Abubakar Sadiq Shittu, John Sadik, Farzin Gholamrezae, Scott Ruoti
University of Tennessee
cs.SE, cs.CR
Submitted: 2026-04-15
Updated: 2026-11-18
Code: https://github.com/en/authentication
License: http://creativecommons.org/licenses/by-nc-nd/4.0/
The gist: Securing the open-source software supply chain requires verifying the provenance of every code contributionThe vast majority of signed activity is generated automatically by GitHub’s web interface…
Key concepts
- Platform Signatures
- GitHub automatically signs commits made through its web interface using a platform-controlled key. These signatures are overwhelmingly dominant in volume because they reflect platform mediation rather than individual developer end-to-end security.
- E2E Commit Signing
- This refers to developers signing their code contributions directly with their own cryptographic keys for every commit, ensuring verifiable provenance. The study found this practice is exceptionally rare and erratic among adopters.
- Consistency Paradox
- This paradox describes the conflict where users who are 'perfect' security practitioners (always sign) are actually heavily dependent on the web interface. Conversely, intermittent signers rarely use E2E signing, showing that true end-to-end consistency is nearly impossible to achieve.
- Dead Keys
- These are registered cryptographic keys that exist in states undermining best practices, such as having no expiration boundary or being unverified. The study found that 99.81% of expired keys remain unrevoked, indicating a lack of active key hygiene.
Terminology
Summary
Securing the open-source software supply chain requires verifying the provenance of every code contributionThe vast majority of signed activity is generated automatically by GitHub’s web interface rather than by individual developersGenuine E2E commit signing is exceptionally rare, and the few developers who adopt it practice it erratically, frequently abandoning it over time or leaving expired keys unrevokedUltimately, we show that manual key management creates a false sense of security across the open-source communityThe deeper finding of this study is that the failure of E2E commit signing is not behavioral but structuralThis mismatch creates an unresolvable trilemma among ease of use, cryptographic security, and ubiquitous consistency
Research Scope and Methodology
The study analyzed 2,737,649 GitHub accounts across 874,198 repositories to characterize their commit-signing practices throughout GitHub’s historyWe conduct a developer-centric, ecosystem-wide measurement of E2E commit signing on GitHubOur measurement includes a stratified sample of GitHub accounts spanning the platform’s full operational historyWe constructed our dataset via GitHub’s REST API GET /users?since= for account enumerationWe sampled uniformly across the ∼230M ID range by dividing it into 23,000 equal intervals and querying /users? p. 2 We sampled uniformly across
the ∼230M ID range by dividing it into 23,000 equal intervals and
querying /users? since={id} at each interval’s starting ID. The 1% sample spans
GitHub’s full operational history (2008–2025) [10], confirming
representativeness across account age. Treating the 1% collection
as an exploratory baseline, we expanded to 2%, doubling coverage,
to evaluate whether key population-level proportions remain
stable as coverage increases. The
2% cohort is 87. 9% complete (71,694/81,540 users; 16. The
2% cohort is 87. 9% complete (71,694/81,540 users; 16. The
2% cohort is 87. 9% complete (71,694/81,540 users; 16. While
differences are statistically detectable due to our large sample sizes,
the effect sizes are negligible, confirming that expanding the sample
beyond 1% does not materially shift population-level estimates. 3 Commit Metadata Collection
We restricted commit metadata collection to active users (Table 2),
removing dormant accounts to focus on developers with tangible
platform contributions. since={id} at each interval’s starting ID. Since
each request returns up to 100 consecutive users, this 1% strategy
captures local account clusters rather than isolated IDs, reducing the
risk of missing cohort-specific distributions. Second, we
isolated and extracted detailed metadata (1) for commits authored
explicitly by our target accounts, ignoring other collaborators to
maintain a user-centric focus without downloading full repository
histories. Because commit retrieval is highly resource-intensive, we
structured collection in stages.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Platform Dominance and Adoption
Platform signatures dominate the volume of signed commits, as GitHub automatically signs web-interface commits using a platform-controlled key [18]Because GitHub automatically signs web-interface commits using a platform-controlled key [18], these signatures reflect platform mediation rather than E2E securityAlthough UI-generated commits account for only 20.63% of our dataset, they are signed at a rate of 96. p. 4 Although UI-generated commits account for only 20. 63% of our
dataset, they are signed at a rate of 96. 69% of all signed commits originate from the GitHub UI, implying
that verifiable provenance is largely a byproduct of the interface
used rather than a deliberate developer practice. At the user level,
this dominance is even stronger: 94. This platform dominance creates the “consistency paradox”
detailed in Table 4. When we analyze the users who appear to be
perfect security practitioners (Always signs), we found they are
overwhelmingly dependent on the web interface (97.Where the paper says it
Where the paper says it
Where the paper says it
Inconsistency and Key Management Breakdown
By tracking individual developers across all their repositories over time, we are the first to establish that E2E signing is not only rare but erratic among those who adopt itBecause unsigned commits are already routine even among developers who have signed before, an attacker’s unsigned malicious commit raises no flagWe found that even among developers who ever produced an E2E signature, signing rarely persists as a stable default across their ongoing workAt the repository level, only 12.65% (461) of E2E signers sign commits in all repositories they contribute to, while the vast majority sign in some repositories but not others (3,181; 87. p. 6 At the repository level, only 12. 65%
(461) of E2E signers sign commits in all repositories they
contribute to, while the vast majority sign in some repositories but
not others (3,181; 87. 65%
(461) of E2E signers sign commits in all repositories they
contribute to, while the vast majority sign in some repositories but
not others (3,181; 87. The difference in repository breadth
between consistent and inconsistent signers is statistically
significant (Mann–Whitney 𝑈 = 123,836, 𝑝 < 0.Where the paper says it
Where the paper says it
Key Lifecycle and Hygiene Risks
To assess whether GitHub’s cryptographic provenance can be sustained in practice, we shift from commits to the key registry—the public keys users upload and maintain on the platformWe evaluate lifecycle state at the most recent snapshot in our collection (Dec 31, 2025), and interpret expiry and revocation relative to that pointIf expiration functioned as a widely adopted hygiene mechanism, expiry metadata would be expected across all key typesWe observe the opposite: 99.81% of expired keys remain unrevokedThis confirms revocation is effectively non-existent in this ecosystem and that even among users who configure expiration, it functions primarily as a passive timestamp rather than a trigger for active credential cleanupDead keys are defined as registered credentials existing in states that undermine best-practice lifecycle managementThe dominant contributors are keys with no expiration boundary and unverified signing-relevant keys, the latter representing an identity gapAccount age is a moderate but consistent predictor of dead key accumulation (Spearman ρ = 0. p. 7 81% of expired keys remain unrevoked. This confirms revocation is effectively non-existent in this
ecosystem and that even among users who configure expiration, it
functions primarily as a passive timestamp rather than a trigger
for active credential cleanup. 001), with the
pattern holding monotonically across age groups (Table 8). Among
accounts under two years old, fewer than 7% carry any dead key.Where the paper says it
Where the paper says it
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Platform signature differentiation: The system should display GitHub-generated signatures separately from end-to-end (E2E) developer signatures because
These carry fundamentally different security guarantees and should not share the same badge.
-
E2E commit warning: The system should warn developers and require an explicit override when someone with a history of signing in a given repository attempts to push an unsigned commit, as
unsigned commits are already routine even among developers who have signed before.
-
Key management alerts: The system should alert developers when keys approach expiration and flag unrevoked expired keys in the security dashboard because
dead-key accumulation is concentrated among long-tenured accounts
andthe pattern holds monotonically across age groups.
-
Provenance signal combination: Verification systems should treat a commit signature
as one signal among many, combining signatures with other provenance evidence to provide a more robust assessment of trust,
rather than treating it as a binary guarantee. -
Identity-based signing adoption modeling: The system can model the difference between UI and E2E adoption by showing that
UI adoption immediate (median 0 days); local signing severely delayed (median 1,122 days).
-
Consistency metric for developers: The system can measure the consistency of a developer's signing behavior across repositories, noting that
signing behavior is decoupled from contribution volume
and thatonly 12.65% (461) of E2E signers sign commits in all repositories they contribute to.
-
Key lifecycle risk assessment: The system should track keys based on the findings in Table 7, specifically flagging keys with
no expiration boundary and unverified signing-relevant keys
as the dominant contributors to hygiene risk.
Abstract
Since 1999, the security community has known that managing cryptographic keys is hard for users of cryptographic systems. Git lets software developers use private keys they control to digitally sign the commits that record their code changes to a repository. This practice offers a rare opportunity to study how a large community manages cryptographic keys in everyday work. In this paper, we study end-to-end commit signing, using GitHub accounts as our sampling unit. Our 2% stratified sample of the GitHub population comprises 2,737,649 accounts, 71,694 of which have made at least one commit. For these accounts, we analyze 16,112,439 commits across 874,198 repositories and collect 208,546 public keys uploaded to the sampled accounts. We examine developers' signing key usage patterns and compare our findings with those of prior commit signing studies, most of which used repository-based samples and paid less attention to key management. We then outline a path toward more usable key management for developers.
Sources
- Kettle: Attested builds for verifiable software provenance
- An Evidence-driven Protocol for Trustworthy CI Pipelines
- Identity-Based Signing Shifts, Not Solves, Usability: Evidence from Five Identity-Based Signing Ecosystems
Related papers
- ArkEval: Benchmarking and Evaluating Automated CodeRepair for ArkTS
- TestPrism: Rethinking Test Evaluation Beyond a Single Reference
- Mining Workflow Graphs for Black-Box Boundary Testing of Conversational LLM Agents
- Falsification-Based Verification of LLM-Generated Optimization Models: Sound Test Batteries and Their Detection Limits
- GitSkills: A Dataset of Agent Skills on GitHub
- For Coding Agents, the Repository Matters