Skip to the content
Know your tech before you buy it. Makers: get listed from $49/mo

OpenPubkey

github.com

  • Free plan
  • Windows
  • macOS
  • Linux
  • API
  • Self-hosted
7.9 Club score Visit github.com

What OpenPubkey is

OpenPubkey binds an OpenID Connect identity to a public key so a user or workload can sign messages or artifacts. Its PK Token represents control of the identity and related private key at a particular time, assuming the verifier trusts the identity provider. The project lists Google, Azure/Microsoft, Okta, OneLogin, and Keycloak as compatible without changes to the provider, but says its client and verifier currently create and check tokens from Google for users and GitHub for workloads. Workload identity use requires GQ signatures; these are unnecessary for user scenarios when the token is not public. GQ signatures let the provider signature be removed from an ID Token while preserving proof of that signature, preventing use against OIDC resource providers. OpenPubkey says it does not need an added certificate authority because the identity provider serves that role. Public PK Tokens can disclose claims from the ID Token, such as a name or email address. The Linux Foundation project is free and licensed under Apache 2.0, and its repository says it is being prepared for version 1.0. The project directs technical questions and reports to GitHub issues and offers a community Slack channel.

Who it suits

OpenPubkey is for developers and teams connecting user or workload identities to signatures on messages and artifacts. Workload use requires GQ signatures, and public tokens may expose identity claims.

Good to know, and what to watch

  • Supports user and workload identities.
  • Does not require adding a certificate authority.
  • Lists five compatible OpenID providers.
  • Free under the Apache 2.0 license.
  • Optional MFA cosigner protocol for user identity scenarios.
  • Current token support is Google for users and GitHub for workloads.
  • Public tokens may expose name or email claims.
  • MFA cosigner is unsupported for workload identities.
  • Project is being prepared for version 1.0.

OpenPubkey

Free

Free plan

Getting started

  1. Open the OpenPubkey GitHub repository
  2. Use the Go client and verifier
  3. Authenticate with a supported current provider
  4. Create a PK Token
  5. Sign a message or artifact
  6. Verify the signature

Limits to check

The free OpenPubkey plan is a reference implementation under Apache 2.0. Current client and verifier support is described for Google users and GitHub workloads, and workload scenarios require GQ signatures.

The Club's review

OpenPubkey is an Apache 2.0 project for tying user or workload identities to keys used to sign messages and artifacts. It best suits teams building signing into OpenID Connect workflows. Its CA-free approach is appealing, though current provider support and token privacy deserve close attention.

Overview

OpenPubkey uses OpenID Connect to bind an identity to a public key. A PK Token proves that the identity controlled the associated private key at a particular time, as long as the verifier trusts the identity provider. This gives teams an identity-backed signing mechanism without requiring a separate certificate authority: the OpenID Provider serves that role. OpenPubkey itself does not provide certificates.

The project supports both user and workload identities, and targets messages and artifacts. Its Go client and verifier example walks through authentication, PK Token creation, signing, and verification. Docker is building a public registry that uses OpenPubkey to sign Docker Official Images, while BastionZero uses it for secure remote infrastructure access.

Key features

Identity-backed signing

PK Tokens connect proof of an OIDC identity with proof of control of its key. That can suit organizations that already trust an OpenID Provider and want signatures tied to that identity. The verifier’s trust in the provider remains essential, so this approach is less useful when signers and verifiers do not share an acceptable identity authority.

Provider compatibility and current support

The project says it can work with Google, Azure/Microsoft, Okta, OneLogin, and Keycloak without changes to those providers. Its client and verifier currently create and verify PK Tokens from Google for users and GitHub for workloads. That distinction matters: broad compatibility claims do not mean every provider is currently supported in the client and verifier, particularly for workload use.

Replay protection and workload signing

GQ signatures let the OpenID Provider signature be stripped from an ID Token while preserving proof that it was valid. This prevents the token from being reused against OIDC resource providers. GQ signatures are required for all current workload identity use cases; user identity scenarios do not need them when the PK Token stays private. Teams adopting workload signing should account for this requirement.

Key and token privacy

OpenPubkey assumes identity-held key pairs are ephemeral: users generate keys as needed and delete them when finished. Public PK Tokens can expose claims from the signer’s ID Token, potentially including a name or email address. That makes token visibility a design decision, especially when signatures or artifacts will be shared publicly.

User identity scenarios can add an optional MFA cosigner protocol, which independently authenticates the user and cosigns the PK Token. It is not supported for workload identities. The project is being prepared for version 1.0, and directs feature requests, bug reports, and technical questions to GitHub issues, with a community Slack channel for discussion.

Pricing

OpenPubkey is free: its OpenPubkey plan costs nothing and provides an open source Apache 2.0 reference implementation. There are no paid tiers to weigh against it. The value is clearest for teams able to build around a reference implementation; the project’s pre-1.0 status is a relevant consideration for those seeking a settled product commitment.

Platforms

OpenPubkey supports API use, Linux, macOS, Windows, and self-hosted deployments. Its signing targets are messages and artifacts. It provides no certificate, so teams needing a certificate as an output should choose a different tool or add that capability elsewhere.

Who it's for

OpenPubkey is a strong fit for developers and infrastructure teams that want to connect signatures to user or workload identities already managed through OpenID Connect. It is particularly relevant to teams whose verifiers trust Google for users or GitHub for workloads, and who can manage ephemeral keys and token exposure. It is a weaker fit when the required provider is outside the client’s and verifier’s current support, when public tokens would reveal sensitive identity claims, or when a certificate is required.

Pros and cons

  • Pros: Links identity and key control through OIDC, so teams can use provider trust without adding a separate certificate authority.
  • Pros: Supports user and workload identities, with messages and artifacts as targets.
  • Pros: Free Apache 2.0 reference implementation can be adapted by teams that want to build signing into their own workflows.
  • Cons: Current client and verifier support is Google for users and GitHub for workloads, narrower than the provider compatibility list.
  • Cons: Public PK Tokens may disclose a signer’s name or email address through ID Token claims.
  • Cons: Workload identity use currently requires GQ signatures, and the optional MFA cosigner is limited to user scenarios.
  • Cons: OpenPubkey provides no certificate and is still being prepared for version 1.0.

Alternatives

For a broader code signing software comparison, consider what kind of signing workflow and deployment you need. SignServer is a better fit when basic code, document, or container signing and timestamping are the priority; its free Community plan supports source code or container deployment, and it also offers a free trial. SignPath is worth considering for eligible open source projects seeking a free signing plan.

AWS Signer is the alternative to consider for signing workflows centered on AWS services; its listed free use applies with AWS IoT Device Management, Lambda, ECR, EKS, or third-party container services. Notation is a free Apache 2.0 CLI project for readers who want that project format. Cosign is a free open source option for teams looking for signing software without a hosted service.

Sigstore is free for developers and software providers and supports API and self-hosted use alongside desktop platforms. Keyfactor Platform is the paid alternative to consider for certificate lifecycle automation, with custom pricing and no per-certificate fees. SignPath Foundation offers a free SignPath.io subscription for eligible, actively maintained open source projects whose releases meet its stated conditions.

Verdict

Choose OpenPubkey if you want a free, Apache 2.0 way to bind signatures to OIDC identities and your identity provider, token privacy, and key lifecycle fit the design. Its main advantage is doing that without a separate CA; look elsewhere if you need a certificate, broader current provider support, or a more mature release.

The verdict

OpenPubkey offers an identity-to-key approach for signing messages and artifacts, with a free Apache 2.0 reference implementation. Check the current provider support and token privacy implications for the identity scenario in use.

Questions people ask

Is OpenPubkey free?

Yes. The listed OpenPubkey plan is free, with Apache 2.0 licensing.

Which identity providers are compatible?

The project lists Google, Azure/Microsoft, Okta, OneLogin, and Keycloak without requiring provider changes. Its current client and verifier create and verify tokens from Google for users and GitHub for workloads.

What can identities sign?

OpenPubkey supports signing messages and artifacts.

Does it require a certificate authority?

No. The project says the OpenID Provider fulfills that role.

Can public PK Tokens reveal personal details?

Yes. Public tokens can expose claims from the signer's OIDC ID Token, including a name or email address.

Is MFA cosigning supported?

An optional MFA cosigner is available for user identity scenarios. The FAQ says it is unsupported for workload identities.

What the maker publishes

Adoption
The README says Docker is building a public container registry that uses OpenPubkey to sign Docker Official Images, and BastionZero uses it for secure remote infrastructure access. source
Current providers
The project says its client and verifier currently create and verify PK Tokens from Google for users and GitHub for workloads. source
Current provider support
The project says its client and verifier currently create and verify PK Tokens from Google for users and GitHub for workloads. source
Development status
The repository says it is being prepared for version 1.0. source
Development status
The README says the project is working to get the repository ready for version 1.0. source
Identity providers
The README lists Google, Azure/Microsoft, Okta, OneLogin, and Keycloak as compatible OpenID Providers without requiring provider changes. source
Identity types
OpenPubkey supports both user identities and workload identities. source
Integrations
The project identifies Docker as using OpenPubkey to sign Docker Official Images and BastionZero as using it for secure remote infrastructure access. source
Key handling
OpenPubkey assumes identity-held key pairs are ephemeral and says users generate them as needed and delete them when finished. source
License
OpenPubkey is a Linux Foundation project released under the Apache 2.0 license. source
MFA cosigner
For user identity scenarios, an optional MFA cosigner protocol independently authenticates the user and cosigns the PK Token; the FAQ says this is unsupported for workload identities. source
No added CA
The project says OpenPubkey does not require adding a certificate authority because the OpenID Provider fulfills that role. source
PK Tokens
A PK Token proves control of an OIDC identity and its associated private key at a specific time, provided the verifier trusts the identity provider. source
PK Tokens
A PK Token bundles an OpenID Connect ID Token with proof that the identity holder controls the associated private key. source
Privacy consideration
Public PK Tokens expose claims from the signer's OIDC ID Token, which may include their name or email address. source
Project governance
OpenPubkey describes itself as a Linux Foundation project licensed under Apache 2.0. source
Providers
The project says it is compatible with Google, Azure/Microsoft, Okta, OneLogin, and Keycloak without changes to the identity provider. source
Purpose
OpenPubkey binds user or workload identities to public keys through OpenID Connect, allowing identities to sign messages or artifacts. source
Purpose
OpenPubkey binds user or workload identities to public keys through OpenID Connect, allowing identities to sign messages or artifacts. source
Replay protection
GQ signatures let the OpenID Provider signature be stripped from an ID Token while retaining proof of that signature, preventing the token from being used against OIDC resource providers. source
Replay protection
GQ signatures let the provider signature be stripped and replaced with proof, preventing the ID Token from being replayed against OIDC resource providers. source
Security reporting
The security policy asks reporters to email [email protected] privately and says the project does not currently offer bug bounties. source
Support
The project directs users to GitHub issues for feature requests, bug reports, and technical questions, and provides a community Slack channel. source
Support
The project directs feature requests, bug reports, and technical questions to GitHub issues and points users to its OpenSSF Slack channel. source

Checked against the maker's pages on 8 Oct 2026.