✦ For everyone, free.

Practical knowledge for real and everyday life

Home

Trust Anchors and Keyrings

Trust Anchors and Keyrings secure Linux package management by validating software with trusted keys and secure storage.

Trust Anchors and Keyrings are fundamental components in Linux package management systems that establish and maintain the authenticity and integrity of software packages. A Trust Anchor is a known and trusted public key or certificate that serves as the root of trust in a cryptographic verification process. It is a secure starting point against which other keys or signatures are validated. A Keyring is a collection or database of cryptographic keys, including public keys used to verify digital signatures on packages or repositories. Together, trust anchors and keyrings ensure that software packages originate from trusted sources and have not been tampered with during distribution or installation.


Trust Anchors

Definition and Role

A trust anchor is the ultimate trusted entity in a chain of trust, often a root certificate authority (CA) or a public key embedded within the system or package manager’s trusted database. It acts as the foundation for validating digital signatures on software packages. Any signature verification process starts by trusting the trust anchor implicitly and then validating subordinate keys or signatures based on that anchor.

Trust Anchor Characteristics

  • Immutable and Secure: Trust anchors are securely stored and rarely changed to prevent compromising the entire trust chain.
  • Root of Trust: They are the highest-level keys or certificates in a hierarchy used to validate subordinate entities.
  • Source of Trust: Provided and maintained by operating system vendors or package maintainers, ensuring packages come from verified sources.

Examples in Linux Systems

  • In Debian-based systems, the keyring package includes trust anchors for Debian archive keys.
  • RPM-based distributions use GPG public keys as trust anchors to verify package signatures.

Keyrings

Definition and Structure

A keyring is a collection of cryptographic keys, primarily public keys, used by package managers to verify the authenticity of software packages and repositories. Keyrings can include multiple keys from different package maintainers or organizations trusted to provide software.

Types of Keys in Keyrings

  • Public Keys: Used to verify package signatures.
  • Revoked Keys: Keys marked as invalid and no longer trusted.
  • Expired Keys: Keys that have exceeded their validity period and require renewal or replacement.

Storage and Formats

Keyrings are stored in specific formats depending on the package management system:

Package SystemKeyring FormatStorage Location
APT (Debian)GPG keyrings (.gpg files)/etc/apt/trusted.gpg and /etc/apt/trusted.gpg.d/
RPM (Fedora)GPG public keys/etc/pki/rpm-gpg/

Management and Usage

Keyrings are managed through dedicated tools:

  • APT: Uses apt-key (deprecated) or direct keyring file management for adding/removing keys.
  • RPM: Uses rpm --import to add keys and rpm -K or rpm --checksig to verify package signatures.

Package managers check the digital signatures of packages against keys in the keyring. If a package signature matches a trusted key, the package is considered authentic and safe to install.


Digital Signatures and Verification

Digital Signature Process

When a package is built, the maintainer signs it with a private key. This signature is a cryptographic hash of the package contents encrypted by the signer’s private key. Upon installation, the package manager uses the corresponding public key from the keyring to decrypt the signature and compare it to the hash of the package content.

If the hashes match, the package is verified as untampered and originating from a trusted source.

Chain of Trust

Verification often involves a chain of trust, where:

  1. The trust anchor validates an intermediate key.
  2. The intermediate key validates the maintainer’s key.
  3. The maintainer’s key verifies the package signature.

This hierarchical trust model increases security by allowing delegation of signing authority while maintaining a secure root trust anchor.


Security Considerations

Risks of Key Compromise

  • If a private key corresponding to a trusted public key is compromised, attackers can create malicious packages that appear authentic.
  • Revocation mechanisms must be in place to invalidate compromised keys promptly.

Key Rotation and Expiration

  • Keys have validity periods after which they expire and must be replaced.
  • Regular key rotation limits the impact of potential key compromise.

Secure Key Distribution

  • Trust anchors and keyrings must be securely distributed, often via signed updates or secure channels.
  • Users should avoid manually adding untrusted keys to keyrings to prevent malicious packages.

Practical Examples

Adding a Key to APT Keyring

wget -qO - https://example.com/repo-key.gpg | sudo tee /etc/apt/trusted.gpg.d/example-repo.gpg
sudo apt update

Importing a GPG Key for RPM

sudo rpm --import /etc/pki/rpm-gpg/RPM-GPG-KEY-example

Verifying Package Signature with RPM

rpm --checksig package.rpm

Output indicates whether the package is signed by a trusted key.


Summary of Components

ComponentDescriptionPurpose
Trust AnchorRoot public key or certificateEstablishes base of trust in verification
KeyringCollection of public keysStores trusted keys for signature checks
Digital SignatureCryptographic hash encrypted with private keyValidates package authenticity and integrity
Package ManagerSoftware that manages package installation and verificationUses trust anchors and keyrings to verify packages

Trust anchors and keyrings form the cryptographic backbone that ensures the security and trustworthiness of software packages in Linux operating systems, preventing unauthorized or malicious software installation by verifying package provenance and integrity.