Analysis of Commit Signing on GitHub

summary

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…

In short

The study analyzed commit signing practices across millions of GitHub accounts to find that full end-to-end (E2E) commit signing is extremely rare and inconsistent. The primary finding is that the failure isn't behavioral but structural, creating a difficult trilemma between ease of use, security, and consistency.

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 used across episodes

This episode discusses

The paper

Analysis of Commit Signing on GitHub · Read on arXiv

Abubakar Sadiq Shittu, John Sadik, Farzin Gholamrezae, Scott Ruoti

University of Tennessee

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.

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.

More episodes

← Home