diff --git a/README.md b/README.md index c4e37eb..108c9fa 100644 --- a/README.md +++ b/README.md @@ -1,171 +1,156 @@ -This is a guide to using [YubiKey](https://www.yubico.com/products/yubikey-hardware/) as a [SmartCard](https://security.stackexchange.com/questions/38924/how-does-storing-gpg-ssh-private-keys-on-smart-cards-compare-to-plain-usb-drives) for storing GPG encryption, signing and authentication keys, which can also be used for SSH. Many of the principles in this document are applicable to other smart card devices. +This is a guide to using [YubiKey](https://www.yubico.com/products/) as a [smart card](https://security.stackexchange.com/questions/38924/how-does-storing-gpg-ssh-private-keys-on-smart-cards-compare-to-plain-usb-drives) for secure encryption, signing and authentication operations. -Keys stored on YubiKey are [non-exportable](http://web.archive.org/web/20201125172759/https://support.yubico.com/hc/en-us/articles/360016614880-Can-I-Duplicate-or-Back-Up-a-YubiKey-) (as opposed to file-based keys that are stored on disk) and are convenient for everyday use. Instead of having to remember and enter passphrases to unlock SSH/GPG keys, YubiKey needs only a physical touch after being unlocked with a PIN. All signing and encryption operations happen on the card, rather than in OS memory. +Keys stored on YubiKey are [non-exportable](https://web.archive.org/web/20201125172759/https://support.yubico.com/hc/en-us/articles/360016614880-Can-I-Duplicate-or-Back-Up-a-YubiKey-), unlike filesystem-based credentials, while remaining convenient for daily use. YubiKey can be configured to require a physical touch for cryptographic operations, reducing the risk of credential compromise. -**Security Note**: If you followed this guide before Jan 2021, your GPG *PIN* and *Admin PIN* may be set to their default values (`123456` and `12345678` respectively). This would allow an attacker to use your Yubikey or reset your PIN. Please see the [Change PIN](#change-pin) section for details on how to change your PINs. +**Important** If you followed this guide before Jan 2021, *PIN* and *Admin PIN* may be set to default values of `123456` and `12345678`. See [Change PIN](#change-pin) to change PINs. -If you have a comment or suggestion, please open an [Issue](https://github.com/drduh/YubiKey-Guide/issues) on GitHub. +To suggest an improvement, please send a pull request or open an [issue](https://github.com/drduh/YubiKey-Guide/issues). -**Tip** [drduh/Purse](https://github.com/drduh/Purse) is a password manager which uses GPG and YubiKey to securely store and read credentials. +**Tip** [drduh/Purse](https://github.com/drduh/Purse) is a password manager which uses GnuPG and YubiKey to securely store and use credentials. - [Purchase](#purchase) - [Prepare environment](#prepare-environment) - [Required software](#required-software) - - [Debian and Ubuntu](#debian-and-ubuntu) - - [Fedora](#fedora) - - [Arch](#arch) - - [RHEL7](#rhel7) - - [NixOS](#nixos) - - [OpenBSD](#openbsd) - - [macOS](#macos) - - [Windows](#windows) + * [Debian and Ubuntu](#debian-and-ubuntu) + * [Fedora](#fedora) + * [Arch](#arch) + * [RHEL7](#rhel7) + * [NixOS](#nixos) + * [OpenBSD](#openbsd) + * [macOS](#macos) + * [Windows](#windows) - [Entropy](#entropy) - - [YubiKey](#yubikey) - - [OneRNG](#onerng) -- [Creating keys](#creating-keys) - - [Temporary working directory](#temporary-working-directory) - - [Harden configuration](#harden-configuration) -- [Master key](#master-key) + * [YubiKey](#yubikey) + * [OneRNG](#onerng) +- [Generate keys](#generate-keys) + * [Temporary working directory](#temporary-working-directory) + * [Hardened configuration](#hardened-configuration) +- [Certify key](#certify-key) - [Sign with existing key](#sign-with-existing-key) -- [Sub-keys](#sub-keys) - - [Signing](#signing) - - [Encryption](#encryption) - - [Authentication](#authentication) - - [Add extra identities](#add-extra-identities) +- [Subkeys](#subkeys) + * [Signing](#signing) + * [Encryption](#encryption) + * [Authentication](#authentication) + * [Extra Identities](#extra-identities) - [Verify](#verify) - [Export secret keys](#export-secret-keys) - [Revocation certificate](#revocation-certificate) - [Backup](#backup) - [Export public keys](#export-public-keys) -- [Configure Smartcard](#configure-smartcard) - - [Enable KDF](#enable-kdf) - - [Change PIN](#change-pin) - - [Set information](#set-information) +- [Configure YubiKey](#configure-yubikey) + * [Enable KDF](#enable-kdf) + * [Change PIN](#change-pin) + * [Set information](#set-information) - [Transfer keys](#transfer-keys) - - [Signing](#signing) - - [Encryption](#encryption) - - [Authentication](#authentication) + * [Signing](#signing-1) + * [Encryption](#encryption-1) + * [Authentication](#authentication-1) - [Verify card](#verify-card) - [Multiple YubiKeys](#multiple-yubikeys) - - [Switching between two or more Yubikeys](#switching-between-two-or-more-yubikeys) -- [Multiple Hosts](#multiple-hosts) -- [Cleanup](#cleanup) + * [Switching between YubiKeys](#switching-between-yubikeys) +- [Finish](#finish) - [Using keys](#using-keys) - [Rotating keys](#rotating-keys) - - [Setup environment](#setup-environment) - - [Renewing sub-keys](#renewing-sub-keys) - - [Rotating keys](#rotating-keys-1) + * [Setup environment](#setup-environment) + * [Renewing Subkeys](#renewing-subkeys) + * [Rotating keys](#rotating-keys-1) - [Adding notations](#adding-notations) - [SSH](#ssh) - - [Create configuration](#create-configuration) - - [Replace agents](#replace-agents) - - [Copy public key](#copy-public-key) - - [(Optional) Save public key for identity file configuration](#optional-save-public-key-for-identity-file-configuration) - - [Connect with public key authentication](#connect-with-public-key-authentication) - - [Import SSH keys](#import-ssh-keys) - - [Remote Machines (SSH Agent Forwarding)](#remote-machines-ssh-agent-forwarding) - - [Use ssh-agent](#use-ssh-agent) - - [Use S.gpg-agent.ssh](#use-sgpg-agentssh) - - [Chained SSH Agent Forwarding](#chained-ssh-agent-forwarding) - - [GitHub](#github) - - [OpenBSD](#openbsd) - - [Windows](#windows) - - [WSL](#wsl) - - [Use ssh-agent or use S.weasel-pageant](#use-ssh-agent-or-use-sweasel-pageant) - - [Prerequisites](#prerequisites) - - [WSL configuration](#wsl-configuration) - - [Remote host configuration](#remote-host-configuration) - - [macOS](#macos) + * [Create configuration](#create-configuration) + * [Replace agents](#replace-agents) + * [Copy public key](#copy-public-key) + * [(Optional) Save public key for identity file configuration](#optional-save-public-key-for-identity-file-configuration) + * [Connect with public key authentication](#connect-with-public-key-authentication) + * [Import SSH keys](#import-ssh-keys) + * [Remote Machines (SSH Agent Forwarding)](#remote-machines-ssh-agent-forwarding) + + [Use ssh-agent ](#use-ssh-agent) + + [Use S.gpg-agent.ssh](#use-sgpg-agentssh) + + [Chained SSH agent forwarding](#chained-ssh-agent-forwarding) + * [GitHub](#github) + * [OpenBSD](#openbsd-1) + * [Windows](#windows-1) + + [WSL](#wsl) + * [macOS](#macos-1) - [Remote Machines (GPG Agent Forwarding)](#remote-machines-gpg-agent-forwarding) - - [Steps for older distributions](#steps-for-older-distributions) - - [Chained GPG Agent Forwarding](#chained-gpg-agent-forwarding) + * [Steps for older distributions](#steps-for-older-distributions) + * [Chained GnuPG agent forwarding](#chained-gnupg-agent-forwarding) - [Using Multiple Keys](#using-multiple-keys) - [Adding an identity](#adding-an-identity) - - [Add an identity to your master key](#add-an-identity-to-your-master-key) - - [Updating your YubiKey](#updating-your-yubikey) + * [Updating YubiKey](#updating-yubikey) - [Require touch](#require-touch) - [Email](#email) - - [Mailvelope on macOS](#mailvelope-on-macos) - - [Mutt](#mutt) + * [Mailvelope](#mailvelope) + * [Mutt](#mutt) - [Reset](#reset) -- [Recovery after reset](#recovery-after-reset) + * [Recovery after reset](#recovery-after-reset) - [Notes](#notes) - [Troubleshooting](#troubleshooting) - [Alternatives](#alternatives) - - [Create keys with batch](#create-keys-with-batch) -- [Links](#links) + * [Create keys with batch](#create-keys-with-batch) +- [Additional resources](#additional-resources) # Purchase -All YubiKeys except the blue "security key" model and the "Bio Series - FIDO Edition" are compatible with this guide. NEO models are limited to 2048-bit RSA keys. Compare YubiKeys [here](https://www.yubico.com/products/yubikey-hardware/compare-products-series/). A list of the YubiKeys compatible with OpenPGP is available [here](https://support.yubico.com/hc/en-us/articles/360013790259-Using-Your-YubiKey-with-OpenPGP). In May 2021, Yubico also released a press release and blog post about supporting resident ssh keys on their Yubikeys including blue "security key 5 NFC" with OpenSSH 8.2 or later, see [here](https://www.yubico.com/blog/github-now-supports-ssh-security-keys/) for details. +All YubiKeys except the blue "security key" model and the "Bio Series - FIDO Edition" are compatible with this guide. NEO models are limited to 2048-bit RSA keys. Compare YubiKeys [here](https://www.yubico.com/products/yubikey-hardware/compare-products-series/). A list of the YubiKeys compatible with OpenPGP is available [here](https://support.yubico.com/hc/en-us/articles/360013790259-Using-Your-YubiKey-with-OpenPGP). In May 2021, Yubico also released a press release and blog post about supporting resident ssh keys on their YubiKeys including blue "security key 5 NFC" with OpenSSH 8.2 or later, see [here](https://www.yubico.com/blog/github-now-supports-ssh-security-keys/) for more information. -To verify a YubiKey is genuine, open a [browser with U2F support](https://support.yubico.com/hc/en-us/articles/360013723419-How-to-Confirm-Your-Yubico-Device-is-Genuine) to [https://www.yubico.com/genuine/](https://www.yubico.com/genuine/). Insert a Yubico device, and select *Verify Device* to begin the process. Touch the YubiKey when prompted, and if asked, allow it to see the make and model of the device. If you see *Verification complete*, the device is authentic. +To [verify a YubiKey](https://support.yubico.com/hc/en-us/articles/360013723419-How-to-Confirm-Your-Yubico-Device-is-Genuine), visit [yubico.com/genuine](https://www.yubico.com/genuine/). Insert a Yubico device, and select *Verify Device* to begin the process. Touch the YubiKey when prompted, and if asked, allow the site to see the make and model of the device. This device attestation may help mitigate [supply chain attacks](https://media.defcon.org/DEF%20CON%2025/DEF%20CON%2025%20presentations/DEF%20CON%2025%20-%20r00killah-and-securelyfitz-Secure-Tokin-and-Doobiekeys.pdf). -This website verifies YubiKey device attestation certificates signed by a set of Yubico certificate authorities, and helps mitigate [supply chain attacks](https://media.defcon.org/DEF%20CON%2025/DEF%20CON%2025%20presentations/DEF%20CON%2025%20-%20r00killah-and-securelyfitz-Secure-Tokin-and-Doobiekeys.pdf). - -You will also need several small storage devices (microSD cards work well) for storing encrypted backups of your keys. +Several portable storage devices (such as microSD cards) for storing encrypted backups are also recommended. # Prepare environment -To create cryptographic keys, a secure environment that can be reasonably assured to be free of adversarial control is recommended. Here is a general ranking of environments most to least likely to be compromised: +To generate cryptographic keys, creating a dedicated secure environment is recommended. + +The following is a general ranking of environments most to least likely to be compromised: -1. Daily-use operating system -1. Virtual machine on daily-use host OS (using [virt-manager](https://virt-manager.org/), VirtualBox, or VMware) -1. Separate hardened [Debian](https://www.debian.org/) or [OpenBSD](https://www.openbsd.org/) installation which can be dual booted +1. Daily-use system with unrestricted network access +1. Virtual machine on daily-use host OS (using [virt-manager](https://virt-manager.org/), VirtualBox or VMware) +1. Dedicated and hardened [Debian](https://www.debian.org/) or [OpenBSD](https://www.openbsd.org/) system 1. Live image, such as [Debian Live](https://www.debian.org/CD/live/) or [Tails](https://tails.boum.org/index.en.html) -1. Secure hardware/firmware ([Coreboot](https://www.coreboot.org/), [Intel ME removed](https://github.com/corna/me_cleaner)) -1. Dedicated air-gapped system with no networking capabilities +1. Hardened hardware and firmware ([Coreboot](https://www.coreboot.org/), [Intel ME removed](https://github.com/corna/me_cleaner)) +1. Dedicated air-gapped system without network capabilities (ARM-based Raspberry Pi or other architecturally diverse equivalent) -This guide recommends using a bootable "live" Debian Linux image to provide such an environment, however, depending on your threat model, you may want to take fewer or more steps to secure it. +A Debian Linux live image is recommended to balance usability and security. -To use Debian Live, download the latest image: +Download the latest image and signature files: ```console -$ curl -fLO https://cdimage.debian.org/debian-cd/current-live/amd64/iso-hybrid/SHA512SUMS +curl -fLO "https://cdimage.debian.org/debian-cd/current-live/amd64/iso-hybrid/SHA512SUMS" -$ curl -fLO https://cdimage.debian.org/debian-cd/current-live/amd64/iso-hybrid/SHA512SUMS.sign +curl -fLO "https://cdimage.debian.org/debian-cd/current-live/amd64/iso-hybrid/SHA512SUMS.sign" -$ curl -fLO "https://cdimage.debian.org/debian-cd/current-live/amd64/iso-hybrid/$(awk '/xfce.iso$/ {print $2}' SHA512SUMS)" +curl -fLO "https://cdimage.debian.org/debian-cd/current-live/amd64/iso-hybrid/$(awk '/xfce.iso$/ {print $2}' SHA512SUMS)" ``` -Verify the signature of the hashes file with GPG: +Download the Debian signing public key: ```console -$ gpg --verify SHA512SUMS.sign SHA512SUMS -gpg: Signature made Sat 07 Oct 2023 01:24:57 PM PDT -gpg: using RSA key DF9B9C49EAA9298432589D76DA87E80D6294BE9B -gpg: Can't check signature: No public key +gpg --keyserver hkps://keyring.debian.org --recv DF9B9C49EAA9298432589D76DA87E80D6294BE9B +``` -$ gpg --keyserver hkps://keyring.debian.org --recv DF9B9C49EAA9298432589D76DA87E80D6294BE9B -gpg: key 0xDA87E80D6294BE9B: public key "Debian CD signing key " imported -gpg: Total number processed: 1 -gpg: imported: 1 +If the public key cannot be received, use a different keyserver or DNS server: -$ gpg --verify SHA512SUMS.sign SHA512SUMS -gpg: Signature made Sat 07 Oct 2023 01:24:57 PM PDT -gpg: using RSA key DF9B9C49EAA9298432589D76DA87E80D6294BE9B -gpg: Good signature from "Debian CD signing key " [unknown] -gpg: WARNING: This key is not certified with a trusted signature! -gpg: There is no indication that the signature belongs to the owner. -Primary key fingerprint: DF9B 9C49 EAA9 2984 3258 9D76 DA87 E80D 6294 BE9B +```console +gpg --keyserver hkps://keyserver.ubuntu.com:443 --recv DF9B9C49EAA9298432589D76DA87E80D6294BE9B ``` -If the public key cannot be received, try changing the DNS resolver and/or use a different keyserver: +Verify the signature: ```console -$ gpg --keyserver hkps://keyserver.ubuntu.com:443 --recv DF9B9C49EAA9298432589D76DA87E80D6294BE9B +gpg --verify SHA512SUMS.sign SHA512SUMS ``` -Ensure the SHA512 hash of the live image matches the one in the signed file - if there following command produces output, it is correct: +`gpg: Good signature from "Debian CD signing key "` must appear in the output. + +Verify the cryptographic hash of the image file matches the one in the signed file: ```console -$ grep $(sha512sum debian-live-*-amd64-xfce.iso) SHA512SUMS -SHA512SUMS:3c74715380c804798d892f55ebe4d2f79ae266be93df2468a066c192cfe1af6ddae3139e1937d5cbfa2fccb6fe291920148401de30f504c0876be2f141811ff1 debian-live-12.2.0-amd64-xfce.iso +grep $(sha512sum debian-live-*-amd64-xfce.iso) SHA512SUMS ``` See [Verifying authenticity of Debian CDs](https://www.debian.org/CD/verify) for more information. -Mount a storage device and copy the image to it: +Mount a portable storage device and copy the image: **Linux** @@ -201,37 +186,38 @@ $ doas dd if=debian-live-*-amd64-xfce.iso of=/dev/rsd2c bs=4m 1951432704 bytes transferred in 139.125 secs (14026448 bytes/sec) ``` -Shut down the computer and disconnect internal hard drives and all unnecessary peripheral devices. If being run within a VM, this part can be skipped as no such devices should be attached to the VM since the image will still be run as a "live image". +Power off, then disconnect internal hard drives and all unnecessary devices, such as the wireless card. # Required software Boot the live image and configure networking. -**Note** If the screen locks, unlock with `user`/`live`. +**Note** If the screen locks, unlock with `user` / `live` -Open the terminal and install required software packages. +Open terminal and install required software packages. ## Debian and Ubuntu ```console -$ sudo apt update +sudo apt update -$ sudo apt -y upgrade +sudo apt -y upgrade -$ sudo apt -y install wget gnupg2 gnupg-agent dirmngr cryptsetup scdaemon pcscd secure-delete hopenpgp-tools yubikey-personalization +sudo apt -y install \ + wget gnupg2 gnupg-agent dirmngr \ + cryptsetup scdaemon pcscd secure-delete \ + yubikey-personalization ``` -**Note** -As of 2023 June, the `hopenpgp-tools` is not part of the latest Debian 12 stable package repositories. - -To install it, go to [https://packages.debian.org/sid/hopenpgp-tools](https://packages.debian.org/sid/hopenpgp-tools) to select your architecture and then an ftp server. +**Note** `hopenpgp-tools` is no longer part of the latest Debian stable package repositories. To install it, go to [https://packages.debian.org/sid/hopenpgp-tools](https://packages.debian.org/sid/hopenpgp-tools) to select the correct architecture (likely `amd64`) and then an ftp server. Edit `/etc/apt/sources.list` and add the ftp server: + ``` deb http://ftp.debian.org/debian sid main ``` -and then add this to `/etc/apt/preferences` (or a fragment, e.g. `/etc/apt/preferences.d/00-sid`) so that APT still prioritizes packages from the stable repository over sid. +Then add this to `/etc/apt/preferences` (or a fragment, e.g. `/etc/apt/preferences.d/00-sid`) so that APT still prioritizes packages from the stable repository over sid. ``` Package: * @@ -239,61 +225,67 @@ Pin: release n=sid Pin-Priority: 10 ``` - **Note** Live Ubuntu images [may require modification](https://github.com/drduh/YubiKey-Guide/issues/116) to `/etc/apt/sources.list` and may need additional packages: ```console -$ sudo apt -y install libssl-dev swig libpcsclite-dev +sudo apt -y install libssl-dev swig libpcsclite-dev ``` **Optional** Install the `ykman` utility, which will allow you to enable touch policies (requires admin PIN): ```console -$ sudo apt -y install python3-pip python3-pyscard +sudo apt -y install python3-pip python3-pyscard -$ pip3 install PyOpenSSL +pip3 install PyOpenSSL -$ pip3 install yubikey-manager +pip3 install yubikey-manager -$ sudo service pcscd start +sudo service pcscd start -$ ~/.local/bin/ykman openpgp info +~/.local/bin/ykman openpgp info ``` -**Note** Debian 12 doesn't recommend installing non-Debian packaged Python applications globally. But fortunately, it isn't even necessary as `yubikey-manager` is available in the stable main repository: -`$ sudo apt install yubikey-manager`. +**Note** Debian 12 does not recommend installing non-Debian packaged Python applications globally. But fortunately, it is not necessary as `yubikey-manager` is available in the stable main repository: + +```console +sudo apt install yubikey-manager +``` ## Fedora ```console -$ sudo dnf install wget +sudo dnf install wget -$ wget https://github.com/rpmsphere/noarch/raw/master/r/rpmsphere-release-38-1.noarch.rpm +wget https://github.com/rpmsphere/noarch/raw/master/r/rpmsphere-release-38-1.noarch.rpm -$ sudo rpm -Uvh rpmsphere-release*rpm +sudo rpm -Uvh rpmsphere-release*rpm -$ sudo dnf install gnupg2 dirmngr cryptsetup gnupg2-smime pcsc-tools opensc pcsc-lite secure-delete pgp-tools yubikey-personalization-gui +sudo dnf install \ + gnupg2 dirmngr cryptsetup gnupg2-smime \ + pcsc-tools opensc pcsc-lite secure-delete \ + pgp-tools yubikey-personalization-gui ``` ## Arch ```console -$ sudo pacman -Syu gnupg pcsclite ccid hopenpgp-tools yubikey-personalization +sudo pacman -Syu gnupg pcsclite ccid hopenpgp-tools yubikey-personalization ``` ## RHEL7 ```console -$ sudo yum install -y gnupg2 pinentry-curses pcsc-lite pcsc-lite-libs gnupg2-smime +sudo yum install -y gnupg2 pinentry-curses pcsc-lite pcsc-lite-libs gnupg2-smime ``` ## NixOS -Generate an air-gapped NixOS LiveCD image: +Build an air-gapped NixOS LiveCD image: ```console -$ ref=$(git ls-remote https://github.com/drduh/Yubikey-Guide refs/heads/master | awk '{print $1}') -$ nix build --experimental-features "nix-command flakes" github:drduh/YubiKey-Guide/$ref#nixosConfigurations.yubikeyLive.x86_64-linux.config.system.build.isoImage +ref=$(git ls-remote https://github.com/drduh/Yubikey-Guide refs/heads/master | awk '{print $1}') + +nix build --experimental-features "nix-command flakes" github:drduh/YubiKey-Guide/$ref#nixosConfigurations.yubikeyLive.x86_64-linux.config.system.build.isoImage ``` If you have this repository checked out: @@ -301,28 +293,27 @@ If you have this repository checked out: Recommended, but optional: update `nixpkgs` and `drduh/config`: ```console -$ nix flake update --commit-lock-file +nix flake update --commit-lock-file ``` -Generate the ISO: +Build the ISO: ```console -$ nix build --experimental-features "nix-command flakes" .#nixosConfigurations.yubikeyLive.x86_64-linux.config.system.build.isoImage +nix build --experimental-features "nix-command flakes" .#nixosConfigurations.yubikeyLive.x86_64-linux.config.system.build.isoImage ``` Copy it to a USB drive: ```console -$ sudo cp -v result/iso/yubikeyLive.iso /dev/sdb; sync -'result/iso/yubikeyLive.iso' -> '/dev/sdb' +sudo cp -v result/iso/yubikeyLive.iso /dev/sdb ; sync ``` -With this image, you won't need to manually create a [temporary working directory](#temporary-working-directory) or [harden the configuration](#harden-configuration), as it was done when creating the image. +With this image, you won't need to create a [temporary working directory](#temporary-working-directory) or [harden the configuration](#hardened-configuration), as it was done when creating the image. ## OpenBSD ```console -$ doas pkg_add gnupg pcsc-tools +doas pkg_add gnupg pcsc-tools ``` ## macOS @@ -330,7 +321,7 @@ $ doas pkg_add gnupg pcsc-tools Download and install [Homebrew](https://brew.sh/) and the following packages: ```console -$ brew install gnupg yubikey-personalization hopenpgp-tools ykman pinentry-mac wget +brew install gnupg yubikey-personalization hopenpgp-tools ykman pinentry-mac wget ``` **Note** An additional Python package dependency may need to be installed to use [`ykman`](https://support.yubico.com/support/solutions/articles/15000012643-yubikey-manager-cli-ykman-user-guide) - `pip install yubikey-manager` @@ -347,66 +338,72 @@ Generating cryptographic keys requires high-quality [randomness](https://www.ran Most operating systems use software-based pseudorandom number generators or CPU-based hardware random number generators (HRNG). -Optionally, you can use a separate hardware device like [OneRNG](https://onerng.info/onerng/) to [increase the speed](https://lwn.net/Articles/648550/) of entropy generation and possibly also the quality. +**Optional** A device such as [OneRNG](https://onerng.info/onerng/) may be used to [increase the speed](https://lwn.net/Articles/648550/) and possibly the quality of available entropy. ## YubiKey -YubiKey firmware version 5.2.3 introduced "Enhancements to OpenPGP 3.4 Support" - which can optionally gather additional entropy from YubiKey via the SmartCard interface. +YubiKey version 5.2.3 introduced "Enhancements to OpenPGP 3.4 Support" which can gather additional entropy from YubiKey. -To seed the kernel's PRNG with additional 512 bytes retrieved from the YubiKey: +To seed PRNG with an additional 512 bytes retrieved from the YubiKey: ```console -$ echo "SCD RANDOM 512" | gpg-connect-agent | sudo tee /dev/random | hexdump -C +echo "SCD RANDOM 512" | gpg-connect-agent | sudo tee /dev/random | hexdump -C ``` ## OneRNG -Install [rng-tools](https://wiki.archlinux.org/index.php/Rng-tools) software: +Configure [rng-tools](https://wiki.archlinux.org/title/Rng-tools): ```console -$ sudo apt -y install at rng-tools python3-gnupg openssl +sudo apt -y install at rng-tools python3-gnupg openssl -$ wget https://github.com/OneRNG/onerng.github.io/raw/master/sw/onerng_3.7-1_all.deb +wget https://github.com/OneRNG/onerng.github.io/raw/master/sw/onerng_3.7-1_all.deb +``` +Verify the package: + +```console $ sha256sum onerng_3.7-1_all.deb b7cda2fe07dce219a95dfeabeb5ee0f662f64ba1474f6b9dddacc3e8734d8f57 onerng_3.7-1_all.deb +``` + +Install the package: -$ sudo dpkg -i onerng_3.7-1_all.deb +```console +sudo dpkg -i onerng_3.7-1_all.deb -$ echo "HRNGDEVICE=/dev/ttyACM0" | sudo tee /etc/default/rng-tools +echo "HRNGDEVICE=/dev/ttyACM0" | sudo tee /etc/default/rng-tools ``` -Plug in the device and restart rng-tools: +Insert the device and restart rng-tools: ```console -$ sudo atd +sudo atd -$ sudo service rng-tools restart +sudo service rng-tools restart ``` -# Creating keys +# Generate keys ## Temporary working directory Create a temporary directory which will be cleared on [reboot](https://en.wikipedia.org/wiki/Tmpfs) and set it as the GnuPG directory: ```console -$ export GNUPGHOME=$(mktemp -d -t gnupg_$(date +%Y%m%d%H%M)_XXX) +export GNUPGHOME=$(mktemp -d -t gnupg_$(date +%Y%m%d%H%M)_XXX) ``` -Otherwise, to preserve the working environment, set the GnuPG directory to your home folder: +## Hardened configuration + +Import or create a hardened configuration for GnuPG: ```console -$ export GNUPGHOME=~/gnupg-workspace +wget -O $GNUPGHOME/gpg.conf https://raw.githubusercontent.com/drduh/config/master/gpg.conf ``` -## Harden configuration - -Create a hardened configuration in the temporary working directory with the following options: +The options will look similar to: ```console -$ wget -O $GNUPGHOME/gpg.conf https://raw.githubusercontent.com/drduh/config/master/gpg.conf - $ grep -ve "^#" $GNUPGHOME/gpg.conf personal-cipher-preferences AES256 AES192 AES personal-digest-preferences SHA512 SHA384 SHA256 @@ -432,38 +429,50 @@ throw-keyids **Tip** Networking can be disabled for the remainder of the setup. -# Master key +# Certify key + +The primary key to generate is the Certify key, which will be used to issue Subkeys for Encrypt, Sign and Authenticate operations. -The first key to generate is the master key. It will be used for certification only: to issue sub-keys that are used for encryption, signing and authentication. +The Certify key should be kept offline at all times and only accessed from a secure environment to revoke or issue Subkeys. Keys can also be generated on the YubiKey itself to avoid duplication, however for usability and durability reasons this guide recommends against doing so. -**Important** The master key should be kept offline at all times and only accessed to revoke or issue new sub-keys. Keys can also be generated on the YubiKey itself to ensure no other copies exist. +Generate a passphrase which will be needed throughout the guide to create and export Subkeys. The passphrase should be memorized or written down in a secure location, ideally separate from the portable storage device used for key material. -You'll be prompted to enter and verify a passphrase - keep it handy as you'll need it multiple times later. +The passphrase is recommended to consist of only upper case letters and numbers for improved readability. -Generate a strong passphrase which could be written down in a secure place or memorized: +The following command will generate strong passphrases while avoiding ambiguous characters: ```console -$ gpg --gen-random --armor 0 24 -ydOmByxmDe63u7gqx2XI9eDgpvJwibNH +LC_ALL=C tr -dc 'A-Z1-9' < /dev/urandom | \ + tr -d "1IOS5U" | fold -w 30 | head -n10 | \ + sed "-es/./ /"{1..26..5} | cut -c2- | tr " " "-" ``` -Use upper case letters for improved readability if passwords are written down by hand: +Example output: ```console -$ LC_ALL=C tr -dc '[:upper:]' < /dev/urandom | fold -w 20 | head -n1 -BSSYMUGGTJQVWZZWOPJG +A4ZK-YRRJ-8WPM-82NY-CX9T-AGKT +PH9Z-HFDX-QDB9-YMMC-GQZB-Z3EV +EC3H-C42G-8E9K-VF7F-ZWT7-BTL6 +B3CA-QCCE-JMNE-VAZG-ZEYD-J3XP +YKP4-M42X-4WWE-WEKR-C3J7-GZYF +ZQWC-E7MN-M7CT-4Y4Z-9QFV-44VY +KY4F-C83Q-BTYQ-V8EM-WGCR-DPZN +GYWQ-WNAC-ERWM-XGAD-6XVD-ZCLD +L8JL-EK8H-Z4ZF-MA93-NND8-FPKA +WM2J-XF7L-QV6D-AWLY-Y2D8-4TQQ ``` -**Important** Save this credential in a permanent, secure place as it will be needed to issue new sub-keys after expiration, and to provision additional YubiKeys, as well as to your Debian Live environment clipboard, as you'll need it several times throughout to generate keys. +**Tip** On Linux or OpenBSD, select the passphrase using the mouse or by double-clicking on it to copy to clipboard. Paste using the middle mouse button or `Shift`-`Insert` -**Tip** On Linux or OpenBSD, select the password using the mouse or by double-clicking on it to copy to clipboard. Paste using the middle mouse button or `Shift`-`Insert`. +Generate the Certify key with GnuPG: -Generate a new key with GPG, selecting `(8) RSA (set your own capabilities)`, `Certify` capability only and `4096` bit key size. +```console +gpg --expert --full-generate-key +``` -Do **not** set the master (certify) key to expire - see [Note #3](#notes). +Select `(8) RSA (set your own capabilities)`, then type `E` and `S` deselect Encrypt and Sign actions and only the Certify capability remains: ```console -$ gpg --expert --full-generate-key Please select what kind of key you want: (1) RSA and RSA (default) (2) DSA and Elgamal @@ -505,7 +514,13 @@ Current allowed actions: Certify (E) Toggle the encrypt capability (A) Toggle the authenticate capability (Q) Finished +``` + +Type `Q` then `4096` as the requested keysize. +Do **not** set the Certify key to expire (see [Note #3](#notes)). + +```console Your selection? Q RSA keys may be between 1024 and 4096 bits long. What keysize do you want? (2048) 4096 @@ -521,88 +536,72 @@ Key does not expire at all Is this correct? (y/N) y ``` -Input any name and email address (it doesn't have to be valid): +Input any value for Real name and Email address; Comment is optional: ```console GnuPG needs to construct a user ID to identify your key. -Real name: Dr Duh -Email address: doc@duh.to -Comment: [Optional - leave blank] +Real name: YubiKey User +Email address: yubikey@example +Comment: You selected this USER-ID: - "Dr Duh " - -Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? o + "YubiKey User " +Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? O We need to generate a lot of random bytes. It is a good idea to perform some other action (type on the keyboard, move the mouse, utilize the disks) during the prime generation; this gives the random number generator a better chance to gain enough entropy. - -gpg: /tmp.FLZC0xcM/trustdb.gpg: trustdb created -gpg: key 0xFF3E7D88647EBCDB marked as ultimately trusted -gpg: directory '/tmp.FLZC0xcM/openpgp-revocs.d' created -gpg: revocation certificate stored as '/tmp.FLZC0xcM/openpgp-revocs.d/011CE16BD45B27A55BA8776DFF3E7D88647EBCDB.rev' +gpg: /tmp/gnupg_202401011200_TnL/trustdb.gpg: trustdb created +gpg: directory '/tmp/gnupg_202401011200_TnL/openpgp-revocs.d' created +gpg: revocation certificate stored as '/tmp/gnupg_202401011200_TnL/openpgp-revocs.d/4E2C1FA3372CBA96A06AC34AF0F2CFEB04341FB5.rev' public and secret key created and signed. -pub rsa4096/0xFF3E7D88647EBCDB 2017-10-09 [C] - Key fingerprint = 011C E16B D45B 27A5 5BA8 776D FF3E 7D88 647E BCDB -uid Dr Duh +pub rsa4096/0xF0F2CFEB04341FB5 2024-01-01 [C] + Key fingerprint = 4E2C 1FA3 372C BA96 A06A C34A F0F2 CFEB 0434 1FB5 +uid YubiKey User ``` -Export the key ID as a [variable](https://stackoverflow.com/questions/1158091/defining-a-variable-with-or-without-export/1158231#1158231) (`KEYID`) for use later: +Copy the Certify key identifier beginning with `0x` and export it as a [variable](https://stackoverflow.com/questions/1158091/defining-a-variable-with-or-without-export/1158231#1158231) (`KEYID`): ```console -$ export KEYID=0xFF3E7D88647EBCDB +export KEYID=0xF0F2CFEB04341FB5 ``` # Sign with existing key -(Optional) If you already have a PGP key, you may want to sign the new key with the old one to prove that the new key is controlled by you. +**Optional** Existing PGP keys may be used to sign new ones to prove ownership. -Export your existing key to move it to the working keyring: +Export the existing key to move it to the working keyring: ```console -$ gpg --export-secret-keys --armor --output /tmp/new.sec +gpg --export-secret-keys --armor --output /tmp/new.sec ``` -Then sign the new key: +Sign the new key: ```console -$ gpg --default-key $OLDKEY --sign-key $KEYID +gpg --default-key $OLDKEY --sign-key $KEYID ``` -# Sub-keys +# Subkeys -Edit the master key to add sub-keys: +Edit the identity to add Subkeys: ```console -$ gpg --expert --edit-key $KEYID - -Secret key is available. - -sec rsa4096/0xEA5DE91459B80592 - created: 2017-10-09 expires: never usage: C - trust: ultimate validity: ultimate -[ultimate] (1). Dr Duh +gpg --expert --edit-key $KEYID ``` -Use 4096-bit RSA keys. +RSA with 4096-bit key length is recommended. -Use a 1 year expiration for sub-keys - they can be renewed using the offline master key. See [rotating keys](#rotating-keys). +Subkeys are recommended to have one or several year expirations. They must be renewed using the Certify key - see [Rotating keys](#rotating-keys). ## Signing -Create a [signing key](https://stackoverflow.com/questions/5421107/can-rsa-be-both-used-as-encryption-and-signature/5432623#5432623) by selecting `addkey` then `(4) RSA (sign only)`: +Create a [signing key](https://stackoverflow.com/questions/5421107/can-rsa-be-both-used-as-encryption-and-signature/5432623#5432623) by typing `addkey` then select the `(4) RSA (sign only)` option: ```console gpg> addkey -Key is protected. - -You need a passphrase to unlock the secret key for -user: "Dr Duh " -4096-bit RSA key, ID 0xFF3E7D88647EBCDB, created 2016-05-24 - Please select what kind of key you want: (3) DSA (sign only) (4) RSA (sign only) @@ -610,9 +609,14 @@ Please select what kind of key you want: (6) RSA (encrypt only) (7) DSA (set your own capabilities) (8) RSA (set your own capabilities) + (10) ECC (sign only) + (11) ECC (set your own capabilities) + (12) ECC (encrypt only) + (13) Existing key + (14) Existing key from card Your selection? 4 RSA keys may be between 1024 and 4096 bits long. -What keysize do you want? (2048) 4096 +What keysize do you want? (3072) 4096 Requested keysize is 4096 bits Please specify how long the key should be valid. 0 = key does not expire @@ -620,8 +624,7 @@ Please specify how long the key should be valid. w = key expires in n weeks m = key expires in n months y = key expires in n years -Key is valid for? (0) 1y -Key expires at Mon 10 Sep 2018 00:00:00 PM UTC +Key is valid for? (0) 2y Is this correct? (y/N) y Really create? (y/N) y We need to generate a lot of random bytes. It is a good idea to perform @@ -629,17 +632,17 @@ some other action (type on the keyboard, move the mouse, utilize the disks) during the prime generation; this gives the random number generator a better chance to gain enough entropy. -sec rsa4096/0xFF3E7D88647EBCDB - created: 2017-10-09 expires: never usage: C - trust: ultimate validity: ultimate -ssb rsa4096/0xBECFA3C1AE191D15 - created: 2017-10-09 expires: 2018-10-09 usage: S -[ultimate] (1). Dr Duh +sec rsa4096/0xF0F2CFEB04341FB5 + created: 2024-01-01 expires: never usage: C + trust: ultimate validity: ultimate +ssb rsa4096/0xB3CD10E502E19637 + created: 2024-01-01 expires: 2026-01-01 usage: S +[ultimate] (1). YubiKey User ``` ## Encryption -Next, create an [encryption key](https://www.cs.cornell.edu/courses/cs5430/2015sp/notes/rsa_sign_vs_dec.php) by selecting `(6) RSA (encrypt only)`: +Next, create an [encryption key](https://www.cs.cornell.edu/courses/cs5430/2015sp/notes/rsa_sign_vs_dec.php) by typing `addkey` then select the `(6) RSA (encrypt only)` option: ```console gpg> addkey @@ -654,9 +657,10 @@ Please select what kind of key you want: (11) ECC (set your own capabilities) (12) ECC (encrypt only) (13) Existing key + (14) Existing key from card Your selection? 6 RSA keys may be between 1024 and 4096 bits long. -What keysize do you want? (2048) 4096 +What keysize do you want? (3072) 4096 Requested keysize is 4096 bits Please specify how long the key should be valid. 0 = key does not expire @@ -664,8 +668,7 @@ Please specify how long the key should be valid. w = key expires in n weeks m = key expires in n months y = key expires in n years -Key is valid for? (0) 1y -Key expires at Mon 10 Sep 2018 00:00:00 PM UTC +Key is valid for? (0) 2y Is this correct? (y/N) y Really create? (y/N) y We need to generate a lot of random bytes. It is a good idea to perform @@ -673,21 +676,21 @@ some other action (type on the keyboard, move the mouse, utilize the disks) during the prime generation; this gives the random number generator a better chance to gain enough entropy. -sec rsa4096/0xFF3E7D88647EBCDB - created: 2017-10-09 expires: never usage: C - trust: ultimate validity: ultimate -ssb rsa4096/0xBECFA3C1AE191D15 - created: 2017-10-09 expires: 2018-10-09 usage: S -ssb rsa4096/0x5912A795E90DD2CF - created: 2017-10-09 expires: 2018-10-09 usage: E -[ultimate] (1). Dr Duh +sec rsa4096/0xF0F2CFEB04341FB5 + created: 2024-01-01 expires: never usage: C + trust: ultimate validity: ultimate +ssb rsa4096/0xB3CD10E502E19637 + created: 2024-01-01 expires: 2026-01-01 usage: S +ssb rsa4096/0x30CBE8C4B085B9F7 + created: 2024-01-01 expires: 2026-01-01 usage: E +[ultimate] (1). YubiKey User ``` ## Authentication -Finally, create an [authentication key](https://superuser.com/questions/390265/what-is-a-gpg-with-authenticate-capability-used-for). +Finally, create an [authentication key](https://superuser.com/questions/390265/what-is-a-gpg-with-authenticate-capability-used-for) by typing `addkey` then select the `(8) RSA (set your own capabilities)` option. -GPG doesn't provide an authenticate-only key type, so select `(8) RSA (set your own capabilities)` and toggle the required capabilities until the only allowed action is `Authenticate`: +Toggle the required capabilities with `S`, `E` and `A` until `Authenticate` is the only selected action: ```console gpg> addkey @@ -702,6 +705,7 @@ Please select what kind of key you want: (11) ECC (set your own capabilities) (12) ECC (encrypt only) (13) Existing key + (14) Existing key from card Your selection? 8 Possible actions for a RSA key: Sign Encrypt Authenticate @@ -752,8 +756,7 @@ Please specify how long the key should be valid. w = key expires in n weeks m = key expires in n months y = key expires in n years -Key is valid for? (0) 1y -Key expires at Mon 10 Sep 2018 00:00:00 PM UTC +Key is valid for? (0) 2y Is this correct? (y/N) y Really create? (y/N) y We need to generate a lot of random bytes. It is a good idea to perform @@ -761,200 +764,145 @@ some other action (type on the keyboard, move the mouse, utilize the disks) during the prime generation; this gives the random number generator a better chance to gain enough entropy. -sec rsa4096/0xFF3E7D88647EBCDB - created: 2017-10-09 expires: never usage: C - trust: ultimate validity: ultimate -ssb rsa4096/0xBECFA3C1AE191D15 - created: 2017-10-09 expires: 2018-10-09 usage: S -ssb rsa4096/0x5912A795E90DD2CF - created: 2017-10-09 expires: 2018-10-09 usage: E -ssb rsa4096/0x3F29127E79649A3D - created: 2017-10-09 expires: 2018-10-09 usage: A -[ultimate] (1). Dr Duh +sec rsa4096/0xF0F2CFEB04341FB5 + created: 2024-01-01 expires: never usage: C + trust: ultimate validity: ultimate +ssb rsa4096/0xB3CD10E502E19637 + created: 2024-01-01 expires: 2026-01-01 usage: S +ssb rsa4096/0x30CBE8C4B085B9F7 + created: 2024-01-01 expires: 2026-01-01 usage: E +ssb rsa4096/0xAD9E24E1B8CB9600 + created: 2024-01-01 expires: 2026-01-01 usage: A +[ultimate] (1). YubiKey User ``` -Finish by saving the keys. +Finish by saving the keys: ```console gpg> save ``` -## Add extra identities +## Extra Identities -(Optional) To add additional email addresses or identities, use `adduid`. +**Optional** To add additional email addresses or identities, use `adduid` + +Edit the identity: -First open the keyring: ```console -$ gpg --expert --edit-key $KEYID +gpg --expert --edit-key $KEYID ``` -Then add the new identity: +Add the new identity: + ```console gpg> adduid -Real name: Dr Duh -Email address: DrDuh@other.org +Real name: YubiKey User +Email address: yubikey@somewhere Comment: You selected this USER-ID: - "Dr Duh " - -sec rsa4096/0xFF3E7D88647EBCDB - created: 2017-10-09 expires: never usage: C - trust: ultimate validity: ultimate -ssb rsa4096/0xBECFA3C1AE191D15 - created: 2017-10-09 expires: never usage: S -ssb rsa4096/0x5912A795E90DD2CF - created: 2017-10-09 expires: never usage: E -ssb rsa4096/0x3F29127E79649A3D - created: 2017-10-09 expires: never usage: A -[ultimate] (1). Dr Duh -[ unknown] (2). Dr Duh + "YubiKey User " -gpg> trust -sec rsa4096/0xFF3E7D88647EBCDB - created: 2017-10-09 expires: never usage: C - trust: ultimate validity: ultimate -ssb rsa4096/0xBECFA3C1AE191D15 - created: 2017-10-09 expires: never usage: S -ssb rsa4096/0x5912A795E90DD2CF - created: 2017-10-09 expires: never usage: E -ssb rsa4096/0x3F29127E79649A3D - created: 2017-10-09 expires: never usage: A -[ultimate] (1). Dr Duh -[ unknown] (2). Dr Duh - -Please decide how far you trust this user to correctly verify other users' keys -(by looking at passports, checking fingerprints from different sources, etc.) - - 1 = I don't know or won't say - 2 = I do NOT trust - 3 = I trust marginally - 4 = I trust fully - 5 = I trust ultimately - m = back to the main menu +Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? o -Your decision? 5 -Do you really want to set this key to ultimate trust? (y/N) y +sec rsa4096/0xF0F2CFEB04341FB5 + created: 2024-01-01 expires: never usage: C + trust: ultimate validity: ultimate +ssb rsa4096/0xB3CD10E502E19637 + created: 2024-01-01 expires: 2026-01-01 usage: S +ssb rsa4096/0x30CBE8C4B085B9F7 + created: 2024-01-01 expires: 2026-01-01 usage: E +ssb rsa4096/0xAD9E24E1B8CB9600 + created: 2024-01-01 expires: 2026-01-01 usage: A +[ultimate] (1) YubiKey User +[ unknown] (2). YubiKey User +``` -sec rsa4096/0xFF3E7D88647EBCDB - created: 2017-10-09 expires: never usage: C - trust: ultimate validity: ultimate -ssb rsa4096/0xBECFA3C1AE191D15 - created: 2017-10-09 expires: never usage: S -ssb rsa4096/0x5912A795E90DD2CF - created: 2017-10-09 expires: never usage: E -ssb rsa4096/0x3F29127E79649A3D - created: 2017-10-09 expires: never usage: A -[ultimate] (1). Dr Duh -[ unknown] (2). Dr Duh - -gpg> uid 1 - -sec rsa4096/0xFF3E7D88647EBCDB -created: 2017-10-09 expires: never usage: C - trust: ultimate validity: ultimate -ssb rsa4096/0xBECFA3C1AE191D15 - created: 2017-10-09 expires: never usage: S -ssb rsa4096/0x5912A795E90DD2CF - created: 2017-10-09 expires: never usage: E -ssb rsa4096/0x3F29127E79649A3D - created: 2017-10-09 expires: never usage: A -[ultimate] (1)* Dr Duh -[ unknown] (2). Dr Duh - -gpg> primary - -sec rsa4096/0xFF3E7D88647EBCDB -created: 2017-10-09 expires: never usage: C - trust: ultimate validity: ultimate -ssb rsa4096/0xBECFA3C1AE191D15 - created: 2017-10-09 expires: never usage: S -ssb rsa4096/0x5912A795E90DD2CF - created: 2017-10-09 expires: never usage: E -ssb rsa4096/0x3F29127E79649A3D - created: 2017-10-09 expires: never usage: A -[ultimate] (1)* Dr Duh -[ unknown] (2) Dr Duh +Configure trust: +```console +gpg> trust +[...] +Your decision? 5 +Do you really want to set this key to ultimate trust? (y/N) y +[...] gpg> save ``` -By default, the last identity added will be the primary user ID - use `primary` to change that. +By default, the latest identity added will be the primary user ID. Select `uid 2` or equivalent and `primary` to change it. # Verify -List the generated secret keys and verify the output: +List available secret keys: ```console -$ gpg -K -/tmp.FLZC0xcM/pubring.kbx -------------------------------------------------------------------------- -sec rsa4096/0xFF3E7D88647EBCDB 2017-10-09 [C] - Key fingerprint = 011C E16B D45B 27A5 5BA8 776D FF3E 7D88 647E BCDB -uid Dr Duh -ssb rsa4096/0xBECFA3C1AE191D15 2017-10-09 [S] [expires: 2018-10-09] -ssb rsa4096/0x5912A795E90DD2CF 2017-10-09 [E] [expires: 2018-10-09] -ssb rsa4096/0x3F29127E79649A3D 2017-10-09 [A] [expires: 2018-10-09] +gpg -K ``` -Add any additional identities or email addresses you wish to associate using the `adduid` command. +Verify output: -**Tip** Verify with a OpenPGP [key best practice checker](https://riseup.net/en/security/message-security/openpgp/best-practices#openpgp-key-checks): +```console +--------------------------------------- +sec rsa4096/0xF0F2CFEB04341FB5 2024-01-01 [C] + Key fingerprint = 4E2C 1FA3 372C BA96 A06A C34A F0F2 CFEB 0434 1FB5 +uid [ultimate] YubiKey User +ssb rsa4096/0xB3CD10E502E19637 2024-01-01 [S] [expires: 2026-01-01] +ssb rsa4096/0x30CBE8C4B085B9F7 2024-01-01 [E] [expires: 2026-01-01] +ssb rsa4096/0xAD9E24E1B8CB9600 2024-01-01 [A] [expires: 2026-01-01] +``` + +**Optional** Verify with a OpenPGP [key best practice checker](https://riseup.net/en/security/message-security/openpgp/best-practices#openpgp-key-checks): ```console -$ gpg --export $KEYID | hokey lint +gpg --export $KEYID | hokey lint ``` -The output will display any problems with your key in red text. If everything is green, your key passes each of the tests. If it is red, your key has failed one of the tests. +hokey may warn (orange text) about cross certification for the authentication key. GnuPG [Signing Subkey Cross-Certification](https://gnupg.org/faq/subkey-cross-certify.html) documentation has more detail on cross certification, and version 2.2.1 notes "subkey does not sign and so does not need to be cross-certified". -> hokey may warn (orange text) about cross certification for the authentication key. GPG's [Signing Subkey Cross-Certification](https://gnupg.org/faq/subkey-cross-certify.html) documentation has more detail on cross certification, and gpg v2.2.1 notes "subkey does not sign and so does not need to be cross-certified". hokey may also indicate a problem (red text) with `Key expiration times: []` on the primary key (see [Note #3](#notes) about not setting an expiry for the primary key). +hokey may also indicate a problem (red text) with `Key expiration times: []` on the primary key - see [Note #3](#notes). # Export secret keys -The master key and sub-keys will be encrypted with your passphrase when exported. - -Save a copy of your keys: +Save a copy of all keys: ```console -$ gpg --armor --export-secret-keys $KEYID > $GNUPGHOME/mastersub.key +gpg --armor --export-secret-keys $KEYID > $GNUPGHOME/certify.key -$ gpg --armor --export-secret-subkeys $KEYID > $GNUPGHOME/sub.key +gpg --armor --export-secret-subkeys $KEYID > $GNUPGHOME/subkeys.key ``` On Windows, note that using any extension other than `.gpg` or attempting IO redirection to a file will garble the secret key, making it impossible to import it again at a later date: ```console -$ gpg -o \path\to\dir\mastersub.gpg --armor --export-secret-keys $KEYID +gpg -o \path\to\dir\certify.gpg --armor --export-secret-keys $KEYID -$ gpg -o \path\to\dir\sub.gpg --armor --export-secret-subkeys $KEYID +gpg -o \path\to\dir\subkeys.gpg --armor --export-secret-subkeys $KEYID ``` # Revocation certificate -Although we will backup and store the master key in a safe place, it is best practice to never rule out the possibility of losing it or having the backup fail. Without the master key, it will be impossible to renew or rotate subkeys or generate a revocation certificate, the PGP identity will be useless. +Although the Certify key may be backed up to a secure place, the possibility of losing it cannot be ruled out. Without the Certify key, it will be impossible to renew or rotate Subkeys or generate a revocation certificate; the PGP identity will be useless. To mitigate this risk, deprecate an orphaned identity with a revocation certificate. -Even worse, we cannot advertise this fact in any way to those that are using our keys. It is reasonable to assume this *will* occur at some point and the only remaining way to deprecate orphaned keys is a revocation certificate. - -To create the revocation certificate: +To create one: ``` console -$ gpg --output $GNUPGHOME/revoke.asc --gen-revoke $KEYID +gpg --output $GNUPGHOME/revoke.asc --gen-revoke $KEYID ``` -The `revoke.asc` certificate file should be stored (or printed) in a (secondary) place that allows retrieval in case the main backup fails. +The `revoke.asc` file should be stored in a secondary location to the primary backup. # Backup -Once keys are moved to YubiKey, they cannot be moved again! Create an **encrypted** backup of the keyring on removable media so you can keep it offline in a safe place. +Create an **encrypted** backup on portable storage to be kept offline in a secure and durable location. -**Tip** The ext2 filesystem (without encryption) can be mounted on both Linux and OpenBSD. Consider using a FAT32/NTFS filesystem for MacOS/Windows compatibility instead. +**Tip** The [ext2](https://en.wikipedia.org/wiki/Ext2) filesystem without encryption can be mounted on Linux and OpenBSD. Use [FAT32](https://en.wikipedia.org/wiki/Fat32) or [NTFS](https://en.wikipedia.org/wiki/Ntfs) filesystem for macOS and Windows compatibility instead. -As an additional backup measure, consider using a [paper copy](https://www.jabberwocky.com/software/paperkey/) of the keys. The [Linux Kernel Maintainer PGP Guide](https://www.kernel.org/doc/html/latest/process/maintainer-pgp-guide.html#back-up-your-master-key-for-disaster-recovery) points out that such printouts *are still password-protected*. It recommends to *write the password on the paper*, since it will be unlikely that you remember the original key password that was used when the paper backup was created. Obviously, you need a really good place to keep such a printout. +As an additional backup measure, use [Paperkey](https://www.jabberwocky.com/software/paperkey/) to make a physical copy of materials. See [Linux Kernel Maintainer PGP Guide](https://www.kernel.org/doc/html/latest/process/maintainer-pgp-guide.html#back-up-your-master-key-for-disaster-recovery) for more information. It is strongly recommended to keep even encrypted OpenPGP private key material offline to deter [key overwriting attacks](https://www.kopenpgp.com/), for example. **Linux** -Attach another external storage device and check its label: +Attach another portable storage device and check its label: ```console $ sudo dmesg | tail @@ -971,7 +919,7 @@ I/O size (minimum/optimal): 512 bytes / 512 bytes Write it with random data to prepare for encryption: ```console -$ sudo dd if=/dev/urandom of=/dev/mmcblk0 bs=4M status=progress +sudo dd if=/dev/urandom of=/dev/mmcblk0 bs=4M status=progress ``` Erase and create a new partition table: @@ -980,11 +928,6 @@ Erase and create a new partition table: $ sudo fdisk /dev/mmcblk0 Welcome to fdisk (util-linux 2.33.1). -Changes will remain in memory only, until you decide to write them. -Be careful before using the write command. - -Device does not contain a recognized partition table. -Created a new DOS disklabel with disk identifier 0x3c1ad14a. Command (m for help): g Created a new GPT disklabel (GUID: 4E7495FD-85A3-3E48-97FC-2DD8D41516C3). @@ -1002,8 +945,6 @@ Create a new partition with a 25 Megabyte size: $ sudo fdisk /dev/mmcblk0 Welcome to fdisk (util-linux 2.36.1). -Changes will remain in memory only, until you decide to write them. -Be careful before using the write command. Command (m for help): n Partition number (1-128, default 1): @@ -1018,57 +959,48 @@ Calling ioctl() to re-read partition table. Syncing disks. ``` -Use [LUKS](https://askubuntu.com/questions/97196/how-secure-is-an-encrypted-luks-filesystem) to encrypt the new partition. Generate a different password which will be used to protect the filesystem: +Use [LUKS](https://askubuntu.com/questions/97196/how-secure-is-an-encrypted-luks-filesystem) to encrypt the new partition. Generate a unique passphrase which will be used to protect the filesystem: ```console -$ sudo cryptsetup luksFormat /dev/mmcblk0p1 - -WARNING! -======== -This will overwrite data on /dev/mmcblk0p1 irrevocably. - -Are you sure? (Type uppercase yes): YES -Enter passphrase for /dev/mmcblk0p1: -Verify passphrase: +sudo cryptsetup luksFormat /dev/mmcblk0p1 ``` Mount the partition: ```console -$ sudo cryptsetup luksOpen /dev/mmcblk0p1 secret -Enter passphrase for /dev/mmcblk0p1: +sudo cryptsetup luksOpen /dev/mmcblk0p1 secret ``` Create an ext2 filesystem: ```console -$ sudo mkfs.ext2 /dev/mapper/secret -L gpg-$(date +%F) +sudo mkfs.ext2 /dev/mapper/secret -L gpg-$(date +%F) ``` Mount the filesystem and copy the temporary GnuPG directory with keyring: ```console -$ sudo mkdir /mnt/encrypted-storage +sudo mkdir /mnt/encrypted-storage -$ sudo mount /dev/mapper/secret /mnt/encrypted-storage +sudo mount /dev/mapper/secret /mnt/encrypted-storage -$ sudo cp -avi $GNUPGHOME /mnt/encrypted-storage/ +sudo cp -avi $GNUPGHOME /mnt/encrypted-storage/ ``` **Optional** Backup the OneRNG package: ```console -$ sudo cp onerng_3.7-1_all.deb /mnt/encrypted-storage/ +sudo cp onerng_3.7-1_all.deb /mnt/encrypted-storage/ ``` -**Note** If you plan on setting up multiple keys, keep the backup mounted or remember to terminate the gpg process before [saving](https://lists.gnupg.org/pipermail/gnupg-users/2016-July/056353.html). +**Note** To set up multiple keys, keep the backup mounted or remember to terminate the GnuPG process before [saving](https://lists.gnupg.org/pipermail/gnupg-users/2016-July/056353.html). Unmount, close and disconnect the encrypted volume: ```console -$ sudo umount /mnt/encrypted-storage/ +sudo umount /mnt/encrypted-storage/ -$ sudo cryptsetup luksClose secret +sudo cryptsetup luksClose secret ``` **OpenBSD** @@ -1083,7 +1015,7 @@ sd2 at scsibus5 targ 1 lun 0: SCSI4 0/direct remov Print the existing partitions to make sure it's the right device: ```console -$ doas disklabel -h sd2 +doas disklabel -h sd2 ``` Initialize the disk by creating an `a` partition with FS type `RAID` and size of 25 Megabytes: @@ -1136,39 +1068,39 @@ $ doas newfs sd3i Mount the filesystem and copy the temporary directory with the keyring: ```console -$ doas mkdir /mnt/encrypted-storage +doas mkdir /mnt/encrypted-storage -$ doas mount /dev/sd3i /mnt/encrypted-storage +doas mount /dev/sd3i /mnt/encrypted-storage -$ doas cp -avi $GNUPGHOME /mnt/encrypted-storage +doas cp -avi $GNUPGHOME /mnt/encrypted-storage ``` -**Note** If you plan on setting up multiple keys, keep the backup mounted or remember to terminate the gpg process before [saving](https://lists.gnupg.org/pipermail/gnupg-users/2016-July/056353.html). +**Note** To set up multiple YubiKeys, keep the backup mounted or remember to terminate GnuPG before [saving](https://lists.gnupg.org/pipermail/gnupg-users/2016-July/056353.html). Otherwise, unmount and disconnect the encrypted volume: ```console -$ doas umount /mnt/encrypted-storage +doas umount /mnt/encrypted-storage -$ doas bioctl -d sd3 +doas bioctl -d sd3 ``` See [OpenBSD FAQ#14](https://www.openbsd.org/faq/faq14.html#softraidCrypto) for more information. # Export public keys -**Important** Without the *public* key, you will not be able to use GPG to encrypt, decrypt, nor sign messages. However, you will still be able to use YubiKey for SSH authentication. +**Important** Without the *public* key, it will **not** be possible to use GnuPG to encrypt, decrypt, nor sign messages. However, YubiKey may still be used for SSH authentication. -Create another partition on the removable storage device to store the public key, or reconnect networking and upload to a key server. +Create another partition on the portable storage device to store the public key, or reconnect networking and upload to a key server. **Linux** +Provision the portable storage device: + ```console $ sudo fdisk /dev/mmcblk0 Welcome to fdisk (util-linux 2.36.1). -Changes will remain in memory only, until you decide to write them. -Be careful before using the write command. Command (m for help): n Partition number (2-128, default 2): @@ -1181,14 +1113,18 @@ Command (m for help): w The partition table has been altered. Calling ioctl() to re-read partition table. Syncing disks. +``` -$ sudo mkfs.ext2 /dev/mmcblk0p2 +Create a filesystem and export the public key to it: -$ sudo mkdir /mnt/public +```console +sudo mkfs.ext2 /dev/mmcblk0p2 -$ sudo mount /dev/mmcblk0p2 /mnt/public/ +sudo mkdir /mnt/public -$ gpg --armor --export $KEYID | sudo tee /mnt/public/gpg-$KEYID-$(date +%F).asc +sudo mount /dev/mmcblk0p2 /mnt/public/ + +gpg --armor --export $KEYID | sudo tee /mnt/public/$KEYID-$(date +%F).asc ``` **OpenBSD** @@ -1203,43 +1139,64 @@ FS type: [swap] 4.2BSD sd2*> w sd2> q No label changes. +``` -$ doas newfs sd2b +Create a filesystem and export the public key to it: -$ doas mkdir /mnt/public +```console +doas newfs sd2b + +doas mkdir /mnt/public -$ doas mount /dev/sd2b /mnt/public +doas mount /dev/sd2b /mnt/public -$ gpg --armor --export $KEYID | doas tee /mnt/public/gpg-$KEYID-$(date +%F).asc +gpg --armor --export $KEYID | doas tee /mnt/public/$KEYID-$(date +%F).asc ``` **Windows** ```console -$ gpg -o \path\to\dir\pubkey.gpg --armor --export $KEYID +gpg -o \path\to\dir\pubkey.gpg --armor --export $KEYID ``` **Keyserver** -(Optional) Upload the public key to a [public keyserver](https://debian-administration.org/article/451/Submitting_your_GPG_key_to_a_keyserver): +**Optional** Upload the public key to a public keyserver: ```console -$ gpg --send-key $KEYID +gpg --send-key $KEYID -$ gpg --keyserver keys.gnupg.net --send-key $KEYID +gpg --keyserver keys.gnupg.net --send-key $KEYID -$ gpg --keyserver hkps://keyserver.ubuntu.com:443 --send-key $KEYID +gpg --keyserver hkps://keyserver.ubuntu.com:443 --send-key $KEYID ``` Or if [uploading to keys.openpgp.org](https://keys.openpgp.org/about/usage): ```console -$ gpg --send-key $KEYID | curl -T - https://keys.openpgp.org +gpg --send-key $KEYID | curl -T - https://keys.openpgp.org +``` + +The public key URL can also be added to YubiKey (based on [Shaw 2003](https://datatracker.ietf.org/doc/html/draft-shaw-openpgp-hkp-00)): + +```console +URL="hkps://keyserver.ubuntu.com:443/pks/lookup?op=get&search=${KEYID}" +``` + +Edit YubiKey with `gpg --edit-card` and the Admin PIN: + +```console +gpg/card> admin + +gpg/card> url +URL to retrieve public key: hkps://keyserver.ubuntu.com:443/pks/lookup?op=get&search=0xFF00000000000000 + +gpg/card> quit ``` -# Configure Smartcard +# Configure YubiKey -Plug in a YubiKey and use GPG to configure it as a smartcard: +Insert YubiKey and use GnuPG to configure it: ```console $ gpg --card-edit @@ -1282,29 +1239,35 @@ Use the [YubiKey Manager](https://developers.yubico.com/yubikey-manager) applica ## Enable KDF -Key Derived Function (KDF) enables YubiKey to store the hash of PIN, preventing the PIN from being passed as plain text. Note that this requires a relatively new version of GnuPG to work, and may not be compatible with other GPG clients (notably mobile clients). These incompatible clients will be unable to use the YubiKey GPG functions as the PIN will always be rejected. If you are not sure you will only be using your YubiKey on supported platforms, it may be better to skip this step. +Key Derived Function (KDF) enables YubiKey to store the hash of PIN, preventing the PIN from being passed as plain text. + +**Note** This feature may not be compatible with older GnuPG versions, especially mobile clients. These incompatible clients will not function because the PIN will always be rejected. ```console gpg/card> kdf-setup ``` +This step must be completed before changing PINs or moving keys or an error will occur: `gpg: error for setup KDF: Conditions of use not satisfied` + ## Change PIN -The [GPG interface](https://developers.yubico.com/PGP/) is separate from other modules on a Yubikey such as the [PIV interface](https://developers.yubico.com/PIV/Introduction/YubiKey_and_PIV.html). The GPG interface has its own *PIN*, *Admin PIN*, and *Reset Code* - these should be changed from default values! +The [PGP interface](https://developers.yubico.com/PGP/) is separate from other modules on YubiKey, such as the [PIV interface](https://developers.yubico.com/PIV/Introduction/YubiKey_and_PIV.html) - the PGP interface has its own *PIN*, *Admin PIN*, and *Reset Code* which must be changed from default values. -Entering the user *PIN* incorrectly three times will cause the PIN to become blocked; it can be unblocked with either the *Admin PIN* or *Reset Code*. +Entering the *PIN* incorrectly three times will cause the PIN to become blocked. It can be unblocked with either the *Admin PIN* or *Reset Code*. -Entering the *Admin PIN* or *Reset Code* incorrectly three times destroys all GPG data on the card. The Yubikey will have to be reconfigured. +Entering the *Admin PIN* or *Reset Code* incorrectly three times destroys all GnuPG data on the card. Name | Default Value | Use -----------|---------------|------------------------------------------------------------- -PIN | `123456` | decrypt and authenticate (SSH) -Admin PIN | `12345678` | reset *PIN*, change *Reset Code*, add keys and owner information -Reset code | _**None**_ | reset *PIN* ([more information](https://forum.yubico.com/viewtopicd01c.html?p=9055#p9055)) +PIN | `123456` | cryptographic operations (decrypt, sign, authenticate) PIN +Admin PIN | `12345678` | reset PIN, change Reset Code, add keys and owner information +Reset Code | None | reset PIN ([more information](https://forum.yubico.com/viewtopicd01c.html?p=9055#p9055)) -Values are valid up to 127 ASCII characters and must be at least 6 (*PIN*) or 8 (*Admin PIN*, *Reset Code*) characters. See the GnuPG documentation on [Managing PINs](https://www.gnupg.org/howtos/card-howto/en/ch03s02.html) for details. +*PIN* values must be at least 6 characters. *Admin PIN* values must be at least 8 characters. -To update the GPG PINs on the Yubikey: +A maximum of 127 ASCII characters are allowed. See the GnuPG documentation on [Managing PINs](https://www.gnupg.org/howtos/card-howto/en/ch03s02.html) for more information. + +Update PINs: ```console gpg/card> passwd @@ -1340,151 +1303,111 @@ Your selection? q **Note** The number of retry attempts can be changed later with the following command, documented [here](https://docs.yubico.com/software/yubikey/tools/ykman/OpenPGP_Commands.html#ykman-openpgp-access-set-retries-options-pin-retries-reset-code-retries-admin-pin-retries): ```bash -$ ykman openpgp access set-retries 5 5 5 -f -a YOUR_ADMIN_PIN +ykman openpgp access set-retries 5 5 5 -f -a YOUR_ADMIN_PIN ``` ## Set information -Some fields are optional. +While still in administrative mode: ```console +gpg/card> list + gpg/card> name -Cardholder's surname: Duh -Cardholder's given name: Dr +Cardholder's surname: User +Cardholder's given name: YubiKey gpg/card> lang Language preferences: en gpg/card> login -Login data (account name): doc@duh.to - -gpg/card> list - -Application ID ...: D2760001240102010006055532110000 -Version ..........: 3.4 -Manufacturer .....: unknown -Serial number ....: 05553211 -Name of cardholder: Dr Duh -Language prefs ...: en -Sex ..............: unspecified -URL of public key : [not set] -Login data .......: doc@duh.to -Private DO 4 .....: [not set] -Signature PIN ....: not forced -Key attributes ...: rsa2048 rsa2048 rsa2048 -Max. PIN lengths .: 127 127 127 -PIN retry counter : 3 0 3 -Signature counter : 0 -KDF setting ......: on -Signature key ....: [none] -Encryption key....: [none] -Authentication key: [none] -General key info..: [none] +Login data (account name): yubikey@example gpg/card> quit ``` # Transfer keys -**Important** Transferring keys to YubiKey using `keytocard` is a destructive, one-way operation only. Make sure you've made a backup before proceeding: `keytocard` converts the local, on-disk key into a stub, which means the on-disk copy is no longer usable to transfer to subsequent security key devices or mint additional keys. +**Important** Transferring keys to YubiKey is a one-way operation. Verify backups were made before proceeding. `keytocard` converts the local, on-disk key into a stub, which means the on-disk copy is no longer usable to transfer to subsequent YubiKeys. -Previous GPG versions required the `toggle` command before selecting keys. The currently selected key(s) are indicated with an `*`. When moving keys only one key should be selected at a time. +The currently selected key(s) are indicated with an `*`. When transferring keys, only one subkey should be selected at a time. ```console -$ gpg --edit-key $KEYID - -Secret key is available. - -sec rsa4096/0xFF3E7D88647EBCDB - created: 2017-10-09 expires: never usage: C - trust: ultimate validity: ultimate -ssb rsa4096/0xBECFA3C1AE191D15 - created: 2017-10-09 expires: 2018-10-09 usage: S -ssb rsa4096/0x5912A795E90DD2CF - created: 2017-10-09 expires: 2018-10-09 usage: E -ssb rsa4096/0x3F29127E79649A3D - created: 2017-10-09 expires: 2018-10-09 usage: A -[ultimate] (1). Dr Duh +gpg --edit-key $KEYID ``` ## Signing -You will be prompted for the master key passphrase and Admin PIN. +The Certify key passphrase and Admin PIN are required for this step. -Select and transfer the signature key. +Select and transfer the signature key - `*` will appear next to the selected subkey (`ssb*`): ```console gpg> key 1 -sec rsa4096/0xFF3E7D88647EBCDB - created: 2017-10-09 expires: never usage: C - trust: ultimate validity: ultimate -ssb* rsa4096/0xBECFA3C1AE191D15 - created: 2017-10-09 expires: 2018-10-09 usage: S -ssb rsa4096/0x5912A795E90DD2CF - created: 2017-10-09 expires: 2018-10-09 usage: E -ssb rsa4096/0x3F29127E79649A3D - created: 2017-10-09 expires: 2018-10-09 usage: A -[ultimate] (1). Dr Duh +sec rsa4096/0xF0F2CFEB04341FB5 + created: 2024-01-01 expires: never usage: C + trust: ultimate validity: ultimate +ssb* rsa4096/0xB3CD10E502E19637 + created: 2024-01-01 expires: 2026-01-01 usage: S +ssb rsa4096/0x30CBE8C4B085B9F7 + created: 2024-01-01 expires: 2026-01-01 usage: E +ssb rsa4096/0xAD9E24E1B8CB9600 + created: 2024-01-01 expires: 2026-01-01 usage: A +[ultimate] (1). YubiKey User gpg> keytocard Please select where to store the key: (1) Signature key (3) Authentication key Your selection? 1 - -You need a passphrase to unlock the secret key for -user: "Dr Duh " -4096-bit RSA key, ID 0xBECFA3C1AE191D15, created 2016-05-24 ``` ## Encryption -Type `key 1` again to de-select and `key 2` to select the next key: +Type `key 1` again to deselect the first key and `key 2` to select the next key: ```console gpg> key 1 gpg> key 2 -sec rsa4096/0xFF3E7D88647EBCDB - created: 2017-10-09 expires: never usage: C - trust: ultimate validity: ultimate -ssb rsa4096/0xBECFA3C1AE191D15 - created: 2017-10-09 expires: 2018-10-09 usage: S -ssb* rsa4096/0x5912A795E90DD2CF - created: 2017-10-09 expires: 2018-10-09 usage: E -ssb rsa4096/0x3F29127E79649A3D - created: 2017-10-09 expires: 2018-10-09 usage: A -[ultimate] (1). Dr Duh +sec rsa4096/0xF0F2CFEB04341FB5 + created: 2024-01-01 expires: never usage: C + trust: ultimate validity: ultimate +ssb rsa4096/0xB3CD10E502E19637 + created: 2024-01-01 expires: 2026-01-01 usage: S +ssb* rsa4096/0x30CBE8C4B085B9F7 + created: 2024-01-01 expires: 2026-01-01 usage: E +ssb rsa4096/0xAD9E24E1B8CB9600 + created: 2024-01-01 expires: 2026-01-01 usage: A +[ultimate] (1). YubiKey User gpg> keytocard Please select where to store the key: (2) Encryption key Your selection? 2 - -[...] ``` ## Authentication -Type `key 2` again to deselect and `key 3` to select the last key: +Type `key 2` again to deselect the second key and `key 3` to select the last key: ```console gpg> key 2 gpg> key 3 -sec rsa4096/0xFF3E7D88647EBCDB - created: 2017-10-09 expires: never usage: C - trust: ultimate validity: ultimate -ssb rsa4096/0xBECFA3C1AE191D15 - created: 2017-10-09 expires: 2018-10-09 usage: S -ssb rsa4096/0x5912A795E90DD2CF - created: 2017-10-09 expires: 2018-10-09 usage: E -ssb* rsa4096/0x3F29127E79649A3D - created: 2017-10-09 expires: 2018-10-09 usage: A -[ultimate] (1). Dr Duh +sec rsa4096/0xF0F2CFEB04341FB5 + created: 2024-01-01 expires: never usage: C + trust: ultimate validity: ultimate +ssb rsa4096/0xB3CD10E502E19637 + created: 2024-01-01 expires: 2026-01-01 usage: S +ssb rsa4096/0x30CBE8C4B085B9F7 + created: 2024-01-01 expires: 2026-01-01 usage: E +ssb* rsa4096/0xAD9E24E1B8CB9600 + created: 2024-01-01 expires: 2026-01-01 usage: A +[ultimate] (1). YubiKey User gpg> keytocard Please select where to store the key: @@ -1500,380 +1423,217 @@ gpg> save # Verify card -Verify the sub-keys have been moved to YubiKey as indicated by `ssb>`: +Verify Subkeys have been moved to YubiKey as indicated by `ssb>` with `gpg -K`, for example: ```console -$ gpg -K -/tmp.FLZC0xcM/pubring.kbx -------------------------------------------------------------------------- -sec rsa4096/0xFF3E7D88647EBCDB 2017-10-09 [C] - Key fingerprint = 011C E16B D45B 27A5 5BA8 776D FF3E 7D88 647E BCDB -uid Dr Duh -ssb> rsa4096/0xBECFA3C1AE191D15 2017-10-09 [S] [expires: 2018-10-09] -ssb> rsa4096/0x5912A795E90DD2CF 2017-10-09 [E] [expires: 2018-10-09] -ssb> rsa4096/0x3F29127E79649A3D 2017-10-09 [A] [expires: 2018-10-09] +sec rsa4096/0xF0F2CFEB04341FB5 2024-01-01 [C] + Key fingerprint = 4E2C 1FA3 372C BA96 A06A C34A F0F2 CFEB 0434 1FB5 +uid [ultimate] YubiKey User +ssb> rsa4096/0xB3CD10E502E19637 2024-01-01 [S] [expires: 2026-01-01] +ssb> rsa4096/0x30CBE8C4B085B9F7 2024-01-01 [E] [expires: 2026-01-01] +ssb> rsa4096/0xAD9E24E1B8CB9600 2024-01-01 [A] [expires: 2026-01-01] ``` # Multiple YubiKeys -To provision additional security keys, restore the master key backup and repeat the [Configure Smartcard](#configure-smartcard) procedure. +To provision additional YubiKeys, restore the Certify key backup and repeat [Configure YubiKey](#configure-yubikey). ```console -$ mv -vi $GNUPGHOME $GNUPGHOME.1 -renamed '/tmp.FLZC0xcM' -> '/tmp.FLZC0xcM.1' +mv -vi $GNUPGHOME $GNUPGHOME.1 -$ cp -avi /mnt/encrypted-storage/tmp.XXX $GNUPGHOME -'/mnt/encrypted-storage/tmp.FLZC0xcM' -> '/tmp.FLZC0xcM' +cp -avi /mnt/encrypted-storage/tmp.XXX $GNUPGHOME -$ cd $GNUPGHOME +cd $GNUPGHOME ``` -## Switching between two or more Yubikeys - -When you add a GPG key to a Yubikey using the *keytocard* command, GPG deletes the key from your keyring and adds a *stub* pointing to that exact Yubikey (the stub identifies the GPG KeyID and the Yubikey's serial number). - -However, when you do this same operation for a second Yubikey, the stub in your keyring is overwritten by the *keytocard* operation and now the stub points to your second Yubikey. Adding more repeats this overwriting operation. - -In other words, the stub will point ONLY to the LAST Yubikey written to. - -When using GPG key operations with the GPG key you placed onto the Yubikeys, GPG will request a specific Yubikey asking that you insert a Yubikey with a given serial number (referenced by the stub). GPG will not recognise another Yubikey with a different serial number without manual intervention. - -You can force GPG to scan the card and re-create the stubs to point to another Yubikey. - -Having created two (or more Yubikeys) with the same GPG key (as described above) where the stubs are pointing to the second Yubikey: - -Insert the first Yubikey (which has a different serial number) and run the following command: - -```console -$ gpg-connect-agent "scd serialno" "learn --force" /bye -``` -GPG will then scan your first Yubikey for GPG keys and recreate the stubs to point to the GPG keyID and Yubikey Serial number of this first Yubikey. - -To return to using the second Yubikey just repeat (insert other Yubikey and re-run command). - -Obviously this command is not easy to remember so it is recommended to either create a script or a shell alias to make this more user friendly. +## Switching between YubiKeys -# Multiple Hosts +When GnuPG key is added to YubiKey using the *keytocard* command, the key is deleted from the keyring and a *stub* is added, pointing to the YubiKey. The stub identifies the GnuPG key ID and YubiKey serial number. -It can be convenient to use your YubiKey on multiple hosts: +However, when the operation is repeated for an additional YubiKey, the stub is overwritten by the *keytocard* operation and now will point to the latest YubiKey. -* a desktop plus a laptop -* home and work computers -* an environment like [Tails](https://tails.boum.org) +GnuPG will request a specific YubiKey by serial number, as referenced by the stub, and will not recognize another YubiKey with a different serial number without manual intervention. -The simplest way to set up a second host is to begin by exporting your public key and trust settings on the host where your YubiKey is already working: +Insert the first YubiKey (which has a different serial number) and run the following command: -``` console -$ gpg --armor --export $KEYID > gpg-public-key-$KEYID.asc -$ gpg --export-ownertrust > gpg-owner-trust.txt +```console +gpg-connect-agent "scd serialno" "learn --force" /bye ``` -Move both files to the second host. Then, on the second host: - -1. Define your KEYID. For example: - - ``` console - $ export KEYID=0xFF3E7D88647EBCDB - ``` - -2. Import your public key: - - ``` console - $ gpg --import gpg-public-key-$KEYID.asc - ``` - -3. Import the trust settings: - - ``` console - $ gpg --import-ownertrust < gpg-owner-trust.txt - ``` - -4. Insert your YubiKey into a USB port. -5. Import the private key stubs from the YubiKey: - - ``` console - $ gpg --card-status - ``` +GnuPG will scan the first YubiKey for keys and recreate the stubs to point to the key ID and YubiKey serial number of the first YubiKey. -If you need to set up a second host when you are travelling and don't have ready access to your primary host, you can import your public key from a key-server and set trust manually: +To use the second YubiKey, repeat the command. -1. Define your KEYID. For example: - ``` console - $ export KEYID=0xFF3E7D88647EBCDB - ``` +# Finish -2. Fetch the public key from a key-server. For example: +Before completing setup, verify the following: - ``` console - $ gpg --keyserver hkps://keyserver.ubuntu.com:443 --recv $KEYID - ``` +- [ ] Saved encryption, signing and authentication Subkeys to YubiKey (`gpg -K` will show `ssb>` for Subkeys) +- [ ] Saved YubiKey user and admin PINs, which are unique and were changed from default values +- [ ] Saved Certify key passphrase to a secure and durable location +- [ ] Saved Certify key, Subkeys and revocation certificate on encrypted portable storage, to be kept offline +- [ ] Saved passphrase to encrypted volume on portable storage +- [ ] Saved copy of public key where is can be easily accessed later -3. Set ultimate trust: +Reboot to finish. - ``` console - $ gpg --edit-key $KEYID - gpg> trust - Your decision? 5 - Do you really want to set this key to ultimate trust? (y/N) y - gpg> quit - ``` - -4. Insert your YubiKey into a USB port. -5. Import the private key stubs from the YubiKey: - - ``` console - $ gpg --card-status - ``` - -Another approach is to add the URL of your public key to your YubiKey: - -1. Define your KEYID. For example: - - ``` console - $ KEYID=0xFF3E7D88647EBCDB - ``` - -2. Construct the URL (based on [Shaw 2003](https://datatracker.ietf.org/doc/html/draft-shaw-openpgp-hkp-00)): - - ``` console - $ [[ ! "$KEYID" =~ ^"0x" ]] && KEYID="0x${KEYID}" - $ URL="hkps://keyserver.ubuntu.com:443/pks/lookup?op=get&search=${KEYID}" - $ echo $URL - hkps://keyserver.ubuntu.com:443/pks/lookup?op=get&search=0xFF3E7D88647EBCDB - ``` - -3. Insert your YubiKey into a USB port. -4. Add the URL to your YubiKey (will prompt for your YubiKey's admin PIN): - - ``` console - $ gpg --edit-card - gpg/card> admin - gpg/card> url - URL to retrieve public key: hkps://keyserver.ubuntu.com:443/pks/lookup?op=get&search=0xFF3E7D88647EBCDB - gpg/card> quit - ``` - - Note: - - * You do not have to use a *keyserver* URL. You can export your public key as an armored ASCII file and upload it to any place on the web where it can be downloaded using HTTP/HTTPS. - -Once the URL of your public key is present on your YubiKey, setting up a new host becomes: - -1. Insert your YubiKey into a USB port. - -2. Use the `fetch` sub-command to retrieve your public key using the URL stored on the card: - - ``` console - $ gpg --edit-card - - gpg/card> fetch - gpg: requesting key from 'hkps://keyserver.ubuntu.com:443/pks/lookup?op=get&search=0xFF3E7D88647EBCDB' - gpg: /home/pi/.gnupg/trustdb.gpg: trustdb created - gpg: key FF3E7D88647EBCDB: public key "Dr Duh " imported - gpg: Total number processed: 1 - gpg: imported: 1 - - gpg/card> quit - ``` - - This step also imports the private key stubs from the YubiKey. - -3. Define your KEYID (which appears in the output in the previous step): - - ``` console - $ export KEYID=0xFF3E7D88647EBCDB - ``` - -4. Set ultimate trust: - - ``` console - $ gpg --edit-key $KEYID - gpg> trust - Your decision? 5 - Do you really want to set this key to ultimate trust? (y/N) y - gpg> quit - ``` - -# Cleanup - -Before finishing the setup, ensure you have done the following: - -* Saved encryption, signing and authentication sub-keys to YubiKey (`gpg -K` should show `ssb>` for sub-keys). -* Saved the YubiKey user and admin PINs which are different and were changed from default values. -* Saved the password to the GPG master key in a secure, long-term location. -* Saved a copy of the master key, sub-keys and revocation certificate on an encrypted volume, to be stored offline. -* Saved the password to that LUKS-encrypted volume in a secure, long-term location (separate from the device itself). -* Saved a copy of the public key somewhere easily accessible later. - -Now reboot or [securely delete](http://srm.sourceforge.net/) `$GNUPGHOME` and remove the secret keys from the GPG keyring: +If an ephemeral environment was not used for setup, delete secret keys from the keyring and [securely delete](https://srm.sourceforge.net/) `$GNUPGHOME`. ```console -$ gpg --delete-secret-key $KEYID +gpg --delete-secret-key $KEYID -$ sudo srm -r $GNUPGHOME || sudo rm -rf $GNUPGHOME +sudo srm -r $GNUPGHOME || sudo rm -rf $GNUPGHOME -$ unset GNUPGHOME +unset GNUPGHOME ``` -**Important** Make sure you have securely erased all generated keys and revocation certificates if an ephemeral enviroment was not used! - # Using keys -The following command creates and initialises the `~/.gnupg` if it does not exist already: +Initialize GnuPG: ```console -$ gpg -k +gpg -k ``` -Change your working directory: +Change the working directory: ```console -$ cd ~/.gnupg +cd ~/.gnupg ``` Download [drduh/config/gpg.conf](https://github.com/drduh/config/blob/master/gpg.conf): ```console -$ wget https://raw.githubusercontent.com/drduh/config/master/gpg.conf +wget https://raw.githubusercontent.com/drduh/config/master/gpg.conf -$ chmod 600 gpg.conf +chmod 600 gpg.conf ``` Set the following option. This avoids the problem where GnuPG will prompt, repeatedly, for the insertion of an already-inserted YubiKey: ```console -$ echo "disable-ccid" >>scdaemon.conf +touch scdaemon.conf + +echo "disable-ccid" >>scdaemon.conf ``` -> The `disable-ccid` option is only required for GnuPG versions 2.3 or later. However, setting this option does not appear to interfere with the operation of earlier versions of GnuPG so it is recommended for all installations. +> The `disable-ccid` option is only required for GnuPG versions 2.3 or later. However, setting this option does not appear to interfere with the operation of earlier versions of GnuPG so it is recommended for all installations. Install the required packages and mount the non-encrypted volume created earlier: **Linux** ```console -$ sudo apt update && sudo apt install -y gnupg2 gnupg-agent gnupg-curl scdaemon pcscd +sudo apt update + +sudo apt install -y gnupg2 gnupg-agent gnupg-curl scdaemon pcscd -$ sudo mount /dev/mmcblk0p2 /mnt +sudo mount /dev/mmcblk0p2 /mnt ``` **OpenBSD** ```console -$ doas pkg_add gnupg pcsc-tools +doas pkg_add gnupg pcsc-tools -$ doas mount /dev/sd2b /mnt +doas mount /dev/sd2b /mnt ``` Import the public key file: ```console -$ gpg --import /mnt/gpg-0x*.asc -gpg: key 0xFF3E7D88647EBCDB: public key "Dr Duh " imported -gpg: Total number processed: 1 -gpg: imported: 1 +gpg --import /mnt/gpg-0x*.asc ``` Or download the public key from a keyserver: ```console -$ gpg --recv $KEYID -gpg: requesting key 0xFF3E7D88647EBCDB from hkps server hkps.pool.sks-keyservers.net -[...] -gpg: key 0xFF3E7D88647EBCDB: public key "Dr Duh " imported -gpg: Total number processed: 1 -gpg: imported: 1 +gpg --recv $KEYID +``` + +Or with the URL on YubiKey, retrieve the public key: + +```console +gpg/card> fetch + +gpg/card> quit ``` -Edit the master key to assign it ultimate trust by selecting `trust` and `5`: +Edit the Certify key: ```console -$ export KEYID=0xFF3E7D88647EBCDB +export KEYID=0xF0F2CFEB04341FB5 -$ gpg --edit-key $KEYID +gpg --edit-key $KEYID +``` + +Assign ultimate trust by tying `trust` and selecting option `5`: +```console gpg> trust -pub 4096R/0xFF3E7D88647EBCDB created: 2016-05-24 expires: never usage: C - trust: unknown validity: unknown -sub 4096R/0xBECFA3C1AE191D15 created: 2017-10-09 expires: 2018-10-09 usage: S -sub 4096R/0x5912A795E90DD2CF created: 2017-10-09 expires: 2018-10-09 usage: E -sub 4096R/0x3F29127E79649A3D created: 2017-10-09 expires: 2018-10-09 usage: A -[ unknown] (1). Dr Duh - -Please decide how far you trust this user to correctly verify other users' keys -(by looking at passports, checking fingerprints from different sources, etc.) - - 1 = I don't know or won't say - 2 = I do NOT trust - 3 = I trust marginally - 4 = I trust fully - 5 = I trust ultimately - m = back to the main menu Your decision? 5 Do you really want to set this key to ultimate trust? (y/N) y -pub 4096R/0xFF3E7D88647EBCDB created: 2016-05-24 expires: never usage: C - trust: ultimate validity: unknown -sub 4096R/0xBECFA3C1AE191D15 created: 2017-10-09 expires: 2018-10-09 usage: S -sub 4096R/0x5912A795E90DD2CF created: 2017-10-09 expires: 2018-10-09 usage: E -sub 4096R/0x3F29127E79649A3D created: 2017-10-09 expires: 2018-10-09 usage: A -[ unknown] (1). Dr Duh - gpg> quit ``` -Remove and re-insert YubiKey and verify the status: +Remove and re-insert YubiKey. + +Verify the status with `gpg --card-status` which should be similar to: ```console -$ gpg --card-status Reader ...........: Yubico YubiKey OTP FIDO CCID 00 00 Application ID ...: D2760001240102010006055532110000 +Application type .: OpenPGP Version ..........: 3.4 Manufacturer .....: Yubico Serial number ....: 05553211 -Name of cardholder: Dr Duh +Name of cardholder: YubiKey User Language prefs ...: en -Sex ..............: unspecified +Salutation .......: URL of public key : [not set] -Login data .......: doc@duh.to +Login data .......: yubikey@example Signature PIN ....: not forced Key attributes ...: rsa4096 rsa4096 rsa4096 Max. PIN lengths .: 127 127 127 PIN retry counter : 3 3 3 Signature counter : 0 KDF setting ......: on -Signature key ....: 07AA 7735 E502 C5EB E09E B8B0 BECF A3C1 AE19 1D15 - created ....: 2016-05-24 23:22:01 -Encryption key....: 6F26 6F46 845B BEB8 BDF3 7E9B 5912 A795 E90D D2CF - created ....: 2016-05-24 23:29:03 -Authentication key: 82BE 7837 6A3F 2E7B E556 5E35 3F29 127E 7964 9A3D - created ....: 2016-05-24 23:36:40 -General key info..: pub 4096R/0xBECFA3C1AE191D15 2016-05-24 Dr Duh -sec# 4096R/0xFF3E7D88647EBCDB created: 2016-05-24 expires: never -ssb> 4096R/0xBECFA3C1AE191D15 created: 2017-10-09 expires: 2018-10-09 - card-no: 0006 05553211 -ssb> 4096R/0x5912A795E90DD2CF created: 2017-10-09 expires: 2018-10-09 - card-no: 0006 05553211 -ssb> 4096R/0x3F29127E79649A3D created: 2017-10-09 expires: 2018-10-09 - card-no: 0006 05553211 +Signature key ....: CF5A 305B 808B 7A0F 230D A064 B3CD 10E5 02E1 9637 + created ....: 2024-01-01 12:00:00 +Encryption key....: A5FA A005 5BED 4DC9 889D 38BC 30CB E8C4 B085 B9F7 + created ....: 2024-01-01 12:00:00 +Authentication key: 570E 1355 6D01 4C04 8B6D E2A3 AD9E 24E1 B8CB 9600 + created ....: 2024-01-01 12:00:00 +General key info..: sub rsa4096/0xB3CD10E502E19637 2024-01-01 YubiKey User +sec# rsa4096/0xF0F2CFEB04341FB5 created: 2024-01-01 expires: never +ssb> rsa4096/0xB3CD10E502E19637 created: 2024-01-01 expires: 2026-01-01 + card-no: 0006 05553211 +ssb> rsa4096/0x30CBE8C4B085B9F7 created: 2024-01-01 expires: 2026-01-01 + card-no: 0006 05553211 +ssb> rsa4096/0xAD9E24E1B8CB9600 created: 2024-01-01 expires: 2026-01-01 + card-no: 0006 05553211 ``` -`sec#` indicates the master key is not available (as it should be stored encrypted offline). +`sec#` indicates the corresponding key is not available. -**Note** If you see `General key info..: [none]` in the output instead - go back and import the public key using the previous step. +**Note** If `General key info..: [none]` appears in the output instead - go back and import the public key using the previous step. -Encrypt a message to your own key (useful for storing password credentials and other data): +Encrypt a message to yourself (useful for storing credentials): ```console -$ echo "test message string" | gpg --encrypt --armor --recipient $KEYID -o encrypted.txt +echo "test message string" | gpg --encrypt --armor --recipient $KEYID -o encrypted.txt ``` -To encrypt to multiple recipients (or to multiple keys): +To encrypt to multiple recipients or keys (the preferred key ID should be last): ```console -$ echo "test message string" | gpg --encrypt --armor --recipient $KEYID_0 --recipient $KEYID_1 --recipient $KEYID_2 -o encrypted.txt +echo "test message string" | \ + gpg --encrypt --armor \ + --recipient $KEYID_0 --recipient $KEYID_1 --recipient $KEYID_2 \ + -o encrypted.txt ``` Decrypt the message: @@ -1889,18 +1649,18 @@ test message string Sign a message: ```console -$ echo "test message string" | gpg --armor --clearsign > signed.txt +echo "test message string" | gpg --armor --clearsign > signed.txt ``` Verify the signature: ```console $ gpg --verify signed.txt -gpg: Signature made Wed 25 May 2016 00:00:00 AM UTC -gpg: using RSA key 0xBECFA3C1AE191D15 -gpg: Good signature from "Dr Duh " [ultimate] -Primary key fingerprint: 011C E16B D45B 27A5 5BA8 776D FF3E 7D88 647E BCDB - Subkey fingerprint: 07AA 7735 E502 C5EB E09E B8B0 BECF A3C1 AE19 1D15 +gpg: Signature made Mon 01 Jan 2024 12:00:00 PM UTC +gpg: using RSA key CF5A305B808B7A0F230DA064B3CD10E502E19637 +gpg: Good signature from "YubiKey User " [ultimate] +Primary key fingerprint: 4E2C 1FA3 372C BA96 A06A C34A F0F2 CFEB 0434 1FB5 + Subkey fingerprint: CF5A 305B 808B 7A0F 230D A064 B3CD 10E5 02E1 9637 ``` Use a [shell function](https://github.com/drduh/config/blob/master/zshrc) to make encrypting files easier: @@ -1922,7 +1682,7 @@ $ secret document.pdf document.pdf -> document.pdf.1580000000.enc $ reveal document.pdf.1580000000.enc -gpg: anonymous recipient; trying secret key 0xFF3E7D88647EBCDB ... +gpg: anonymous recipient; trying secret key 0xF0F2CFEB04341FB5 ... gpg: okay, we are the anonymous recipient. gpg: encrypted with RSA key, ID 0x0000000000000000 document.pdf.1580000000.enc -> document.pdf @@ -1930,19 +1690,21 @@ document.pdf.1580000000.enc -> document.pdf # Rotating keys -PGP does not provide forward secrecy - a compromised key may be used to decrypt all past messages. Although keys stored on YubiKey are difficult to steal, it is not impossible - the key and PIN could be taken, or a vulnerability may be discovered in key hardware or the random number generator used to create them, for example. Therefore, it is good practice to occassionally rotate sub-keys. +PGP does not provide [forward secrecy](https://en.wikipedia.org/wiki/Forward_secrecy) - a compromised key may be used to decrypt all past messages. Although keys stored on YubiKey are difficult to exploit, it is not impossible; the key and PIN could be physically compromised, or a vulnerability may be discovered in firmware or in the random number generator used to create keys, for example. Therefore, it is good practice to rotate Subkeys periodically. -When a sub-key expires, it can either be renewed or replaced. Both actions require access to the offline master key. Renewing sub-keys by updating their expiration date indicates you are still in possession of the offline master key and is more convenient. +When a Subkey expires, it can either be renewed or replaced. Both actions require access to the Certify key. -Replacing keys, on the other hand, is less convenient but more secure: the new sub-keys will **not** be able to decrypt previous messages, authenticate with SSH, etc. Contacts will need to receive the updated public key and any encrypted secrets need to be decrypted and re-encrypted to new sub-keys to be usable. This process is functionally equivalent to "losing" the YubiKey and provisioning a new one. However, you will always be able to decrypt previous messages using the offline encrypted backup of the original keys. +- Renewing Subkeys by updating expiration indicates continued possession of the Certify key and is more convenient. -Neither rotation method is superior and it's up to personal philosophy on identity management and individual threat model to decide which one to use, or whether to expire sub-keys at all. Ideally, sub-keys would be ephemeral: used only once for each encryption, signing and authentication event, however in practice that is not really feasible nor worthwhile with YubiKey. Advanced users may want to dedicate an offline device for more frequent key rotations and ease of provisioning. +- Replacing Subkeys is less convenient but potentially more secure: the new Subkeys will **not** be able to decrypt previous messages, authenticate with SSH, etc. Contacts will need to receive the updated public key and any encrypted secrets need to be decrypted and re-encrypted to new Subkeys to be usable. This process is functionally equivalent to losing the YubiKey and provisioning a new one. + +Neither rotation method is superior and it is up to personal philosophy on identity management and individual threat modeling to decide which one to use, or whether to expire Subkeys at all. Ideally, Subkeys would be ephemeral: used only once for each unique encryption, signing and authentication event, however in practice that is not really practical nor worthwhile with YubiKey. Advanced users may dedicate an air-gapped machine for frequent credential rotation. ## Setup environment -To renew or rotate sub-keys, follow the same process as generating keys: boot to a secure environment, install required software and disconnect networking. +To renew or rotate Subkeys, follow the same process as generating keys: boot to a secure environment, install required software and disconnect networking. -Connect the offline secret storage device with the master keys and identify the disk label: +Connect the portable storage device with the Certify key and identify the disk label: ```console $ sudo dmesg | tail @@ -1951,105 +1713,66 @@ mmcblk0: mmc0:a001 SS16G 14.8 GiB (ro) mmcblk0: p1 p2 ``` -Decrypt and mount the offline volume: +Decrypt and mount the encrypted volume: ```console -$ sudo cryptsetup luksOpen /dev/mmcblk0p1 secret -Enter passphrase for /dev/mmcblk0p1: +sudo cryptsetup luksOpen /dev/mmcblk0p1 secret -$ sudo mount /dev/mapper/secret /mnt/encrypted-storage +sudo mount /dev/mapper/secret /mnt/encrypted-storage ``` -Import the master key and configuration to a temporary working directory. Note that Windows users should import mastersub.gpg: +Import the Certify key and configuration to a temporary working directory. + +Note that Windows users should import certify.gpg: ```console -$ export GNUPGHOME=$(mktemp -d -t gnupg_$(date +%Y%m%d%H%M)_XXX) +export GNUPGHOME=$(mktemp -d -t gnupg_$(date +%Y%m%d%H%M)_XXX) -$ gpg --import /mnt/encrypted-storage/tmp.XXX/mastersub.key +gpg --import /mnt/encrypted-storage/tmp.XXX/certify.key -$ cp -v /mnt/encrypted-storage/tmp.XXX/gpg.conf $GNUPGHOME +cp -v /mnt/encrypted-storage/tmp.XXX/gpg.conf $GNUPGHOME ``` -Edit the master key: +Edit the Certify key: ```console -$ export KEYID=0xFF3E7D88647EBCDB +export KEYID=0xF0F2CFEB04341FB5 -$ gpg --expert --edit-key $KEYID - -Secret key is available -[...] +gpg --expert --edit-key $KEYID ``` -## Renewing sub-keys +## Renewing Subkeys -Renewing sub-keys is simpler: you do not need to generate new keys, move keys to the YubiKey, or update any SSH public keys linked to the GPG key. All you need to do is to change the expiry time associated with the public key (which requires access to the master key you just loaded) and then to export that public key and import it on any computer where you wish to use the **GPG** (as distinct from the SSH) key. +To renew Subkeys, the expiry time associated with the corresponding public key will need to be updated, which will require access to the Certify key. -To change the expiration date of all sub-keys, start by selecting all keys: +Start by editing the identity: ```console -$ gpg --edit-key $KEYID - -Secret key is available. +gpg --edit-key $KEYID +``` -sec rsa4096/0xFF3E7D88647EBCDB - created: 2017-10-09 expires: never usage: C - trust: ultimate validity: ultimate -ssb rsa4096/0xBECFA3C1AE191D15 - created: 2017-10-09 expires: 2018-10-09 usage: S -ssb rsa4096/0x5912A795E90DD2CF - created: 2017-10-09 expires: 2018-10-09 usage: E -ssb rsa4096/0x3F29127E79649A3D - created: 2017-10-09 expires: 2018-10-09 usage: A -[ultimate] (1). Dr Duh +Select all expired keys: +```console gpg> key 1 -Secret key is available. - -sec rsa4096/0xFF3E7D88647EBCDB - created: 2017-10-09 expires: never usage: C - trust: ultimate validity: ultimate -ssb* rsa4096/0xBECFA3C1AE191D15 - created: 2017-10-09 expires: 2018-10-09 usage: S -ssb rsa4096/0x5912A795E90DD2CF - created: 2017-10-09 expires: 2018-10-09 usage: E -ssb rsa4096/0x3F29127E79649A3D - created: 2017-10-09 expires: 2018-10-09 usage: A -[ultimate] (1). Dr Duh - gpg> key 2 -Secret key is available. - -sec rsa4096/0xFF3E7D88647EBCDB - created: 2017-10-09 expires: never usage: C - trust: ultimate validity: ultimate -ssb* rsa4096/0xBECFA3C1AE191D15 - created: 2017-10-09 expires: 2018-10-09 usage: S -ssb* rsa4096/0x5912A795E90DD2CF - created: 2017-10-09 expires: 2018-10-09 usage: E -ssb rsa4096/0x3F29127E79649A3D - created: 2017-10-09 expires: 2018-10-09 usage: A -[ultimate] (1). Dr Duh - gpg> key 3 -Secret key is available. - -sec rsa4096/0xFF3E7D88647EBCDB - created: 2017-10-09 expires: never usage: C - trust: ultimate validity: ultimate -ssb* rsa4096/0xBECFA3C1AE191D15 - created: 2017-10-09 expires: 2018-10-09 usage: S -ssb* rsa4096/0x5912A795E90DD2CF - created: 2017-10-09 expires: 2018-10-09 usage: E -ssb* rsa4096/0x3F29127E79649A3D - created: 2017-10-09 expires: 2018-10-09 usage: A -[ultimate] (1). Dr Duh +sec rsa4096/0xF0F2CFEB04341FB5 + created: 2024-01-01 expires: never usage: C + trust: ultimate validity: ultimate +ssb* rsa4096/0xB3CD10E502E19637 + created: 2024-01-01 expires: 2026-01-01 usage: S +ssb* rsa4096/0x30CBE8C4B085B9F7 + created: 2024-01-01 expires: 2026-01-01 usage: E +ssb* rsa4096/0xAD9E24E1B8CB9600 + created: 2024-01-01 expires: 2026-01-01 usage: A +[ultimate] (1). YubiKey User ``` -Then, use the `expire` command to set a new expiration date. (Despite the name, this will not cause currently valid keys to become expired.) +Use `expire` to configure the expiration date. This will **not** expire valid keys. ```console gpg> expire @@ -2062,142 +1785,136 @@ Please specify how long the key should be valid. y = key expires in n years Key is valid for? (0) ``` -Follow these prompts to set a new expiration date, then `save` to save your changes. -Next, [export the public key](#export-public-keys): +Set the expiration date, then `save` + +Next, [Export public keys](#export-public-keys): ```console -$ gpg --armor --export $KEYID > gpg-$KEYID-$(date +%F).asc +gpg --armor --export $KEYID > gpg-$KEYID-$(date +%F).asc ``` -Transfer that public key to the computer from which you use your GPG key, and then import it with: +Transfer the public key to the destination host, and then import it: ```console -$ gpg --import gpg-0x*.asc +gpg --import gpg-0x*.asc ``` -Alternatively, use a public key server (it will update the key if already on the server): +Alternatively, publish to a public key server to update the expiration: ```console -$ gpg --send-key $KEYID +gpg --send-key $KEYID ``` -and import the newly updated key on any computer where you wish to use it (it will update the key if previously imported): +Download the public key with updated expiration: ```console -$ gpg --recv $KEYID +gpg --recv $KEYID ``` -This will extend the validity of your GPG key and will allow you to use it for SSH authorization. Note that you do _not_ need to update the SSH public key located on remote servers. +The validity of the GnuPG identity will be extended, allowing it to be used again for encryption, signing and authentication operations. The SSH public key does **not** need to be updated on remote hosts. ## Rotating keys -Rotating keys is more a bit more involved. First, follow the original steps to generate each sub-key. Previous sub-keys may be kept or deleted from the identity. +Follow the original steps to generate and add each Subkey. + +Previous Subkeys may be kept or deleted from the identity. Finish by exporting new keys: ```console -$ gpg --armor --export-secret-keys $KEYID > $GNUPGHOME/mastersub.key +gpg --armor --export-secret-keys $KEYID > $GNUPGHOME/certify.key -$ gpg --armor --export-secret-subkeys $KEYID > $GNUPGHOME/sub.key +gpg --armor --export-secret-subkeys $KEYID > $GNUPGHOME/subkeys.key ``` -Copy the **new** temporary working directory to encrypted offline storage, which should still be mounted: +Copy the **new** temporary working directory to encrypted storage, which should still be mounted: ```console -$ sudo cp -avi $GNUPGHOME /mnt/encrypted-storage +sudo cp -avi $GNUPGHOME /mnt/encrypted-storage ``` -There should now be at least two versions of the master and sub-keys backed up: +There should now be at least two versions of the Certify and Subkeys: ```console -$ ls /mnt/encrypted-storage -lost+found tmp.ykhTOGjR36 tmp.2gyGnyCiHs +ls /mnt/encrypted-storage ``` Unmount and close the encrypted volume: ```console -$ sudo umount /mnt/encrypted-storage +sudo umount /mnt/encrypted-storage -$ sudo cryptsetup luksClose /dev/mapper/secret +sudo cryptsetup luksClose /dev/mapper/secret ``` Export the updated public key: ```console -$ sudo mkdir /mnt/public +sudo mkdir /mnt/public -$ sudo mount /dev/mmcblk0p2 /mnt/public +sudo mount /dev/mmcblk0p2 /mnt/public -$ gpg --armor --export $KEYID | sudo tee /mnt/public/$KEYID-$(date +%F).asc +gpg --armor --export $KEYID | sudo tee /mnt/public/$KEYID-$(date +%F).asc -$ sudo umount /mnt/public +sudo umount /mnt/public ``` -Disconnect the storage device and follow the original steps to transfer new keys (4, 5 and 6) to the YubiKey, replacing existing ones. Reboot or securely erase the GPG temporary working directory. +Disconnect the storage device and follow the original steps to transfer new Subkeys (4, 5 and 6) to YubiKey, replacing existing ones. Reboot or securely erase the GnuPG temporary working directory. # Adding notations -Notations can be added to user ID(s) and can be used in conjunction with [Keyoxide](https://keyoxide.org) to create [OpenPGP identity proofs](https://keyoxide.org/guides/openpgp-proofs). - -Adding notations requires access to the master key so we can follow the setup instructions taken from this [section](#setup-environment) of this guide. +Notations can be added to user ID(s) and can be used in conjunction with [Keyoxide](https://keyoxide.org) to create [OpenPGP identity proofs](https://docs.keyoxide.org/wiki/identity-proof-formats/). -Please note that there is no need to connect the Yubikey to the setup environment and that we do not need to generate new keys, move keys to the YubiKey, or update any SSH public keys linked to the GPG key. +Adding notations requires access to the Certify key. -After having completed the environment setup, it is possible to follow any of the guides listed under "Adding proofs" in the Keyoxide ["Guides"](https://keyoxide.org/guides/) page __up until the notation is saved using the `save` command__. +After configuring the environment, follow any of the guides listed under "Adding proofs" in the Keyoxide ["Guides"](https://keyoxide.org/guides/) page up until the notation is saved using the `save` command. -At this point the public key can be exported: +Export the public key: ```console -$ gpg --export $KEYID > pubkey.asc +gpg --export $KEYID > pubkey.asc ``` -The public key can now be transferred to the computer where the GPG key is used and it is imported with: +Transfer the public key and import it: ```console -$ gpg --import pubkey.asc +gpg --import pubkey.asc ``` -N.B.: The `showpref` command can be issued to ensure that the notions were correctly added. +Use `showpref` to verify notions were correctly added. # SSH -**Tip** If you want to use a YubiKey for SSH only (and don't really care about PGP/GPG), then [since OpenSSH v8.2](https://www.openssh.com/txt/release-8.2) you alternatively can simply `ssh-keygen -t ed25519-sk` (without requiring anything else from this guide!), as explained [in this guide](https://github.com/vorburger/vorburger.ch-Notes/blob/develop/security/ed25519-sk.md). Yubico also recently announced support for resident ssh keys under OpenSSH 8.2+ on their blue "security key 5 nfc" as mentioned in their [blog post](https://www.yubico.com/blog/github-now-supports-ssh-security-keys/)._ +**Tip** YubiKey can be used directly for SSH only, without GnuPG features, starting in [OpenSSH v8.2](https://www.openssh.com/txt/release-8.2). For more information, see [ed25519-sk.md](https://github.com/vorburger/vorburger.ch-Notes/blob/develop/security/ed25519-sk.md) and [Yubico - GitHub now supports SSH security keys](https://www.yubico.com/blog/github-now-supports-ssh-security-keys/). -[gpg-agent](https://wiki.archlinux.org/index.php/GnuPG#SSH_agent) supports the OpenSSH ssh-agent protocol (`enable-ssh-support`), as well as Putty's Pageant on Windows (`enable-putty-support`). This means it can be used instead of the traditional ssh-agent / pageant. There are some differences from ssh-agent, notably that gpg-agent does not _cache_ keys rather it converts, encrypts and stores them - persistently - as GPG keys and then makes them available to ssh clients. Any existing ssh private keys that you'd like to keep in `gpg-agent` should be deleted after they've been imported to the GPG agent. +[gpg-agent](https://wiki.archlinux.org/title/GnuPG#SSH_agent) supports the OpenSSH ssh-agent protocol (`enable-ssh-support`) as well as PuTTy's Pageant on Windows (`enable-putty-support`). This means it can be used instead of the traditional ssh-agent / pageant. There are some differences from ssh-agent, notably that gpg-agent does not _cache_ keys rather it converts, encrypts and stores them persistently as keys, then makes them available to ssh clients. Any existing ssh private keys should be deleted after importing to GnuPG agent. -When importing the key to `gpg-agent`, you'll be prompted for a passphrase to protect that key within GPG's key store - you may want to use the same passphrase as the original's ssh version. GPG can both cache passphrases for a determined period (ref. `gpg-agent`'s various `cache-ttl` options), and since version 2.1 can store and fetch passphrases via the macOS keychain. Note than when removing the old private key after importing to `gpg-agent`, keep the `.pub` key file around for use in specifying ssh identities (e.g. `ssh -i /path/to/identity.pub`). +When importing the key to `gpg-agent`, a passphrase will be required to encrypt within the key store. GnuPG can cache both passphrases with `cache-ttl` options. Note than when removing the old private key after importing to `gpg-agent`, keep the `.pub` key file around for use in specifying ssh identities (e.g. `ssh -i /path/to/identity.pub`). -Probably the biggest thing missing from `gpg-agent`'s ssh agent support is being able to remove keys. `ssh-add -d/-D` have no effect. Instead, you need to use the `gpg-connect-agent` utility to lookup a key's keygrip, match that with the desired ssh key fingerprint (as an MD5) and then delete that keygrip. The [gnupg-users mailing list](https://lists.gnupg.org/pipermail/gnupg-users/2016-August/056499.html) has more information. +Missing from `gpg-agent` ssh agent support is the ability to remove keys. `ssh-add -d/-D` have no effect. Instead, use the `gpg-connect-agent` utility to lookup a keygrip, match it with the desired ssh key fingerprint (as an MD5) and then delete that keygrip. The [gnupg-users mailing list](https://lists.gnupg.org/pipermail/gnupg-users/2016-August/056499.html) has more information. ## Create configuration Create a hardened configuration for gpg-agent by downloading [drduh/config/gpg-agent.conf](https://github.com/drduh/config/blob/master/gpg-agent.conf): ```console -$ cd ~/.gnupg +cd ~/.gnupg -$ wget https://raw.githubusercontent.com/drduh/config/master/gpg-agent.conf - -$ grep -ve "^#" gpg-agent.conf -enable-ssh-support -default-cache-ttl 60 -max-cache-ttl 120 -pinentry-program /usr/bin/pinentry-curses +wget https://raw.githubusercontent.com/drduh/config/master/gpg-agent.conf ``` -**Important** The `cache-ttl` options do **NOT** apply when using a YubiKey as a smartcard as the PIN is [cached by the smartcard itself](https://dev.gnupg.org/T3362). Therefore, in order to clear the PIN from cache (smartcard equivalent to `default-cache-ttl` and `max-cache-ttl`), you need to unplug the YubiKey, or set the `forcesig` flag when editing the card to be prompted for the PIN each time. +**Important** The `cache-ttl` options do **not** apply when using YubiKey as a smart card, because the PIN is [cached by the smart card itself](https://dev.gnupg.org/T3362). To clear the PIN from cache (equivalent to `default-cache-ttl` and `max-cache-ttl`), unplug YubiKey, or set `forcesig` when editing the card to be prompted for the PIN each time. -**Tip** Set `pinentry-program /usr/bin/pinentry-gnome3` for a GUI-based prompt. If the _pinentry_ graphical dialog doesn't show and you get this error: `sign_and_send_pubkey: signing failed: agent refused operation`, you may need to install the `dbus-user-session` package and restart the computer for the `dbus` user session to be fully inherited; this is because behind the scenes, `pinentry` complains about `No $DBUS_SESSION_BUS_ADDRESS found`, falls back to `curses` but doesn't find the expected `tty`. +**Tip** Set `pinentry-program /usr/bin/pinentry-gnome3` for a GUI-based prompt. If the _pinentry_ graphical dialog doesn't show and this error appears: `sign_and_send_pubkey: signing failed: agent refused operation`, install the `dbus-user-session` package and restart the computer for the `dbus` user session to be fully inherited; this is because behind the scenes, `pinentry` complains about `No $DBUS_SESSION_BUS_ADDRESS found`, falls back to `curses` but doesn't find the expected `tty`. -On macOS, use `brew install pinentry-mac` and set the program path to `pinentry-program /usr/local/bin/pinentry-mac` for Intel Macs, `/opt/homebrew/bin/pinentry-mac` for ARM/Apple Silicon Macs or `pinentry-program /usr/local/MacGPG2/libexec/pinentry-mac.app/Contents/MacOS/pinentry-mac` if using MacGPG Suite. For the configuration to take effect you have to run `gpgconf --kill gpg-agent`. +On macOS, use `brew install pinentry-mac` and set the program path to `pinentry-program /usr/local/bin/pinentry-mac` for Intel Macs, `/opt/homebrew/bin/pinentry-mac` for ARM/Apple Silicon Macs or `pinentry-program /usr/local/MacGPG2/libexec/pinentry-mac.app/Contents/MacOS/pinentry-mac` if using MacGPG Suite. For the configuration to take effect, run `gpgconf --kill gpg-agent` ## Replace agents To launch `gpg-agent` for use by SSH, use the `gpg-connect-agent /bye` or `gpgconf --launch gpg-agent` commands. -Add these to the shell `rc` file: +Add the following to the shell rc file: ```console export GPG_TTY="$(tty)" @@ -2213,20 +1930,21 @@ export SSH_AUTH_SOCK=$(gpgconf --list-dirs agent-ssh-socket) gpgconf --launch gpg-agent ``` -If you use fish, the correct lines for your `config.fish` would look like this (consider putting them into the `is-interactive` block depending on your use case): +For fish, `config.fish` should look like this (consider putting them into the `is-interactive` block): + ```fish set -x GPG_TTY (tty) set -x SSH_AUTH_SOCK (gpgconf --list-dirs agent-ssh-socket) gpgconf --launch gpg-agent ``` -Note that if you use `ForwardAgent` for ssh-agent forwarding, `SSH_AUTH_SOCK` only needs to be set on the *local* laptop (workstation), where the YubiKey is plugged in. On the *remote* server that we SSH into, `ssh` will automatically set `SSH_AUTH_SOCK` to something like `/tmp/ssh-mXzCzYT2Np/agent.7541` when we connect. We therefore do **NOT** manually set `SSH_AUTH_SOCK` on the server - doing so would break [SSH Agent Forwarding](#remote-machines-ssh-agent-forwarding). +When using `ForwardAgent` for ssh-agent forwarding, `SSH_AUTH_SOCK` only needs to be set on the *local* host, where YubiKey is connected. On the *remote* host, `ssh` will set `SSH_AUTH_SOCK` to something like `/tmp/ssh-mXzCzYT2Np/agent.7541` upon connection. Do **not** set `SSH_AUTH_SOCK` on the remote host - doing so will break [SSH Agent Forwarding](#remote-machines-ssh-agent-forwarding). -If you use `S.gpg-agent.ssh` (see [SSH Agent Forwarding](#remote-machines-ssh-agent-forwarding) for more info), `SSH_AUTH_SOCK` should also be set on the *remote*. However, `GPG_TTY` should not be set on the *remote*, explanation specified in that section. +For `S.gpg-agent.ssh` (see [SSH Agent Forwarding](#remote-machines-ssh-agent-forwarding) for more info), `SSH_AUTH_SOCK` should also be set on the *remote*. However, `GPG_TTY` should not be set on the *remote*, explanation specified in that section. ## Copy public key -**Note** It is **not** necessary to import the corresponding GPG public key in order to use SSH. +**Note** It is **not** necessary to import the GnuPG public key in order to use SSH. Copy and paste the output from `ssh-add` to the server's `authorized_keys` file: @@ -2237,19 +1955,19 @@ ssh-rsa AAAAB4NzaC1yc2EAAAADAQABAAACAz[...]zreOKM+HwpkHzcy9DQcVG2Nw== cardno:000 ## (Optional) Save public key for identity file configuration -By default, SSH attempts to use all the identities available via the agent. It's often a good idea to manage exactly which keys SSH will use to connect to a server, for example to separate different roles or [to avoid being fingerprinted by untrusted ssh servers](https://blog.filippo.io/ssh-whoami-filippo-io/). To do this you'll need to use the command line argument `-i [identity_file]` or the `IdentityFile` and `IdentitiesOnly` options in `.ssh/config`. +By default, SSH attempts to use all the identities available via the agent. It's often a good idea to manage exactly which keys SSH will use to connect to a server, for example to separate different roles or [to avoid being fingerprinted by untrusted ssh servers](https://words.filippo.io/ssh-whoami-filippo-io/). To do this you'll need to use the command line argument `-i [identity_file]` or the `IdentityFile` and `IdentitiesOnly` options in `.ssh/config`. -The argument provided to `IdentityFile` is traditionally the path to the _private_ key file (for example `IdentityFile ~/.ssh/id_rsa`). For the YubiKey - indeed, in general for keys stored in an ssh agent - `IdentityFile` should point to the _public_ key file, `ssh` will select the appropriate private key from those available via the ssh agent. To prevent `ssh` from trying all keys in the agent use the `IdentitiesOnly yes` option along with one or more `-i` or `IdentityFile` options for the target host. +The argument provided to `IdentityFile` is traditionally the path to the _private_ key file (for example `IdentityFile ~/.ssh/id_rsa`). For YubiKey, `IdentityFile` must point to the _public_ key file, and `ssh` will select the appropriate private key from those available via ssh-agent. To prevent `ssh` from trying all keys in the agent, use `IdentitiesOnly yes` along with one or more `-i` or `IdentityFile` options for the target host. -To reiterate, with `IdentitiesOnly yes`, `ssh` will not automatically enumerate public keys loaded into `ssh-agent` or `gpg-agent`. This means `publickey` authentication will not proceed unless explicitly named by `ssh -i [identity_file]` or in `.ssh/config` on a per-host basis. +To reiterate, with `IdentitiesOnly yes`, `ssh` will not enumerate public keys loaded into `ssh-agent` or `gpg-agent`. This means public-key authentication will not proceed unless explicitly named by `ssh -i [identity_file]` or in `.ssh/config` on a per-host basis. In the case of YubiKey usage, to extract the public key from the ssh agent: ```console -$ ssh-add -L | grep "cardno:000605553211" > ~/.ssh/id_rsa_yubikey.pub +ssh-add -L | grep "cardno:000605553211" > ~/.ssh/id_rsa_yubikey.pub ``` -Then you can explicitly associate this YubiKey-stored key for used with a host, `github.com` for example, as follows: +Then explicitly associate this YubiKey-stored key for used with a host, `github.com` for example, as follows: ```console $ cat << EOF >> ~/.ssh/config @@ -2282,11 +2000,11 @@ debug1: Authentication succeeded (publickey). [...] ``` -**Tip** To make multiple connections or securely transfer many files, consider using the [ControlMaster](https://en.wikibooks.org/wiki/OpenSSH/Cookbook/Multiplexing) ssh option. Also see [drduh/config/ssh_config](https://github.com/drduh/config/blob/master/ssh_config). +**Tip** To make multiple connections or securely transfer many files, use the [ControlMaster](https://en.wikibooks.org/wiki/OpenSSH/Cookbook/Multiplexing) ssh option. ## Import SSH keys -If there are existing SSH keys that you wish to make available via `gpg-agent`, you'll need to import them. You should then remove the original private keys. When importing the key, `gpg-agent` uses the key's filename as the key's label; this makes it easier to follow where the key originated from. In this example, we're starting with just the YubiKey's key in place and importing `~/.ssh/id_rsa`: +If there are existing SSH keys to make available via `gpg-agent`, they will need to be imported. Then, remove the original private keys. When importing the key, `gpg-agent` uses the key filename as the label - this makes it easier to follow where the key originated from. In this example, we're starting with just the YubiKey in place and importing `~/.ssh/id_rsa`: ```console $ ssh-add -l @@ -2295,7 +2013,7 @@ $ ssh-add -l $ ssh-add ~/.ssh/id_rsa && rm ~/.ssh/id_rsa ``` -When invoking `ssh-add`, it will prompt for the SSH key's passphrase if present, then the `pinentry` program will prompt and confirm for a new passphrase to use to encrypt the converted key within the GPG key store. +When invoking `ssh-add`, a prompt for the SSH key passphrase will appear, then the `pinentry` program will prompt and confirm a new passphrase to encrypt the converted key within the GnuPG key store. The migrated key will be listed in `ssh-add -l`: @@ -2305,7 +2023,7 @@ $ ssh-add -l 2048 SHA256:... /Users/username/.ssh/id_rsa (RSA) ``` -Or to show the keys with MD5 fingerprints, as used by `gpg-connect-agent`'s `KEYINFO` and `DELETE_KEY` commands: +To show the keys with MD5 fingerprints, as used by `gpg-connect-agent`'s `KEYINFO` and `DELETE_KEY` commands: ```console $ ssh-add -E md5 -l @@ -2313,7 +2031,7 @@ $ ssh-add -E md5 -l 2048 MD5:... /Users/username/.ssh/id_rsa (RSA) ``` -When using the key `pinentry` will be invoked to request the key's passphrase. The passphrase will be cached for up to 10 minutes idle time between uses, to a maximum of 2 hours. +When using the key `pinentry` will be invoked to request the key passphrase. The passphrase will be cached for up to 10 idle minutes between uses, up to a maximum of 2 hours. ## Remote Machines (SSH Agent Forwarding) @@ -2323,13 +2041,11 @@ There are two methods for ssh-agent forwarding, one is provided by OpenSSH and t The latter one may be more insecure as raw socket is just forwarded (not like `S.gpg-agent.extra` with only limited functionality; if `ForwardAgent` implemented by OpenSSH is just forwarding the raw socket, then they are insecure to the same degree). But for the latter one, one convenience is that one may forward once and use this agent everywhere in the remote. So again, proceed with caution! -For example, `tmux` does not have some environment variables like `$SSH_AUTH_SOCK` when you ssh into remote and attach an old `tmux` session. In this case if you use `ForwardAgent`, you need to find the socket manually and `export SSH_AUTH_SOCK=/tmp/ssh-agent-xxx/xxxx.socket` for each shell. But with `S.gpg-agent.ssh` in fixed place, one can just use it as ssh-agent in their shell rc file. +For example, tmux does not have environment variables such as `$SSH_AUTH_SOCK` when connecting to remote hosts and attaching an existing session. For each shell, find the socket and `export SSH_AUTH_SOCK=/tmp/ssh-agent-xxx/xxxx.socket`. However, with `S.gpg-agent.ssh` in a fixed place, it can be used as the ssh-agent in shell rc files. ### Use ssh-agent -In the above steps, you have successfully configured a local ssh-agent. - -You should now be able to use `ssh -A remote` on the _local_ machine to log into _remote_, and should then be able to use YubiKey as if it were connected to the remote machine. For example, using e.g. `ssh-add -l` on that remote machine should show the public key from the YubiKey (note `cardno:`). (If you don't want to have to remember to use `ssh -A`, you can use `ForwardAgent yes` in `~/.ssh/config`. As a security best practice, always use `ForwardAgent yes` only for a single `Hostname`, never for all servers.) +You should now be able to use `ssh -A remote` on the _local_ host to log into _remote_ host, and should then be able to use YubiKey as if it were connected to the remote host. For example, using e.g. `ssh-add -l` on that remote host should show the public key from the YubiKey (note `cardno:`). (If you don't want to have to remember to use `ssh -A`, you can use `ForwardAgent yes` in `~/.ssh/config`. As a security best practice, always use `ForwardAgent yes` only for a single `Hostname`, never for all servers.) ### Use S.gpg-agent.ssh @@ -2341,9 +2057,9 @@ You may use the command: $ gpgconf --list-dirs agent-ssh-socket ``` -Then in your `.ssh/config` add one sentence for that remote +Edit `.ssh/config` to add the remote host: -``` +```console Host Hostname remote-host.tld StreamLocalBindUnlink yes @@ -2352,7 +2068,7 @@ Host # Note that ForwardAgent is not wanted here! ``` -After successfully ssh into the remote, you should check that you have `/run/user/1000/gnupg/S.gpg-agent.ssh` lying there. +After successfully ssh into the remote host, confirm `/run/user/1000/gnupg/S.gpg-agent.ssh` exists. Then in the *remote* you can type in command line or configure in the shell rc file with: @@ -2360,11 +2076,11 @@ Then in the *remote* you can type in command line or configure in the shell rc f export SSH_AUTH_SOCK="/run/user/$UID/gnupg/S.gpg-agent.ssh" ``` -After typing or sourcing your shell rc file, with `ssh-add -l` you should find your ssh public key now. +After sourcing the shell rc file, `ssh-add -l` will return the correct public key. **Note** In this process no gpg-agent in the remote is involved, hence `gpg-agent.conf` in the remote is of no use. Also pinentry is invoked locally. -### Chained SSH Agent Forwarding +### Chained SSH agent forwarding If you use `ssh-agent` provided by OpenSSH and want to forward it into a *third* box, you can just `ssh -A third` on the *remote*. @@ -2379,27 +2095,27 @@ Host third # Note that ForwardAgent is not wanted here! ``` -You should change the path according to `gpgconf --list-dirs agent-ssh-socket` on *remote* and *third*. +The path must be set according to `gpgconf --list-dirs agent-ssh-socket` on *remote* and *third* hosts. ## GitHub -You can use YubiKey to sign GitHub commits and tags. It can also be used for GitHub SSH authentication, allowing you to push, pull, and commit without a password. - -Login to GitHub and upload SSH and PGP public keys in Settings. +YubiKey can be used to sign commits and tags, and authenticate SSH to GitHub. -To configure a signing key: +Manage SSH and PGP keys in [Settings](https://github.com/settings/keys). - > git config --global user.signingkey $KEYID +Configure a signing key: -Make sure the user.email option matches the email address associated with the PGP identity. +```console +git config --global user.signingkey $KEYID +``` -Now, to sign commits or tags simply use the `-S` option. GPG will automatically query YubiKey and prompt you for a PIN. +The `user.email` option must match the email address associated with the PGP identity. -To authenticate: +To sign commits or tags, use the `-S` option. **Windows** -Run the following commands: +To configure authentication: ```console git config --global core.sshcommand "plink -agent" @@ -2407,125 +2123,138 @@ git config --global core.sshcommand "plink -agent" git config --global gpg.program 'C:\Program Files (x86)\GnuPG\bin\gpg.exe' ``` -You can then change the repository URL to `git@github.com:USERNAME/repository` and any authenticated commands will be authorized by YubiKey. +Update the repository URL to `git@github.com:USERNAME/repository` and any authenticated commands will be authorized by YubiKey. -**Note** If you encounter the error `gpg: signing failed: No secret key` - run `gpg --card-status` with YubiKey plugged in and try the git command again. +**Note** For the error `gpg: signing failed: No secret key` - run `gpg --card-status` with YubiKey plugged in and try the git command again. ## OpenBSD Install and enable tools for use with PC/SC drivers, cards, readers, then reboot to recognize YubiKey: ```console -$ doas pkg_add pcsc-tools +doas pkg_add pcsc-tools -$ doas rcctl enable pcscd +doas rcctl enable pcscd -$ doas reboot +doas reboot ``` ## Windows -Windows can already have some virtual smartcard readers installed, like the one provided for Windows Hello. To ensure your YubiKey is the correct one used by scdaemon, you should add it to its configuration. You will need your device's full name. To find your device's full name, plug in your YubiKey and open PowerShell to run the following command: +Windows can already have some virtual smart card readers installed, like the one provided for Windows Hello. To verify YubiKey is the correct one used by scdaemon, add it to its configuration. -``` powershell +Find the YubiKey label using PowerShell: + +```powershell PS C:\WINDOWS\system32> Get-PnpDevice -Class SoftwareDevice | Where-Object {$_.FriendlyName -like "*YubiKey*"} | Select-Object -ExpandProperty FriendlyName Yubico YubiKey OTP+FIDO+CCID 0 ``` -The name slightly differs according to the model. Thanks to [Scott Hanselman](https://www.hanselman.com/blog/HowToSetupSignedGitCommitsWithAYubiKeyNEOAndGPGAndKeybaseOnWindows.aspx) for sharing this information. +See [How to setup Signed Git Commits with a YubiKey NEO and GPG and Keybase on Windows (2018)](https://www.hanselman.com/blog/HowToSetupSignedGitCommitsWithAYubiKeyNEOAndGPGAndKeybaseOnWindows.aspx) for more information. -* Create or edit `%APPDATA%/gnupg/scdaemon.conf` to add: +Edit `%APPDATA%/gnupg/scdaemon.conf` to add: -``` -reader-port +```console +reader-port ``` -* Create or edit `%APPDATA%/gnupg/gpg-agent.conf` to add: +Edit `%APPDATA%/gnupg/gpg-agent.conf` to add: -``` +```console enable-ssh-support enable-putty-support ``` -* Open a command console, restart the agent: +Restart the agent: +```console +gpg-connect-agent killagent /bye +gpg-connect-agent /bye +``` + +Verify YubiKey details: + +```console +gpg --card-status ``` -> gpg-connect-agent killagent /bye -> gpg-connect-agent /bye + +Import the public key and set ultimate trust: + +```console +gpg --import ``` -* Enter `> gpg --card-status` to see YubiKey details. -* Import the [public key](#export-public-key): `> gpg --import ` -* [Trust the master key](#trust-master-key) -* Retrieve the public key id: `> gpg --list-public-keys` -* Export the SSH key from GPG: `> gpg --export-ssh-key ` +Retrieve the public key id: -Copy this key to a file for later use. It represents the public SSH key corresponding to the secret key on the YubiKey. You can upload this key to any server you wish to SSH into. +```console +gpg --list-public-keys +``` -Create a shortcut that points to `gpg-connect-agent /bye` and place it in the startup folder `shell:startup` to make sure the agent starts after a system shutdown. Modify the shortcut properties so it starts in a "Minimized" window, to avoid unnecessary noise at startup. +Export the SSH public key: -Now you can use PuTTY for public key SSH authentication. When the server asks for public key verification, PuTTY will forward the request to GPG, which will prompt you for a PIN and authorize the login using YubiKey. +```console +gpg --export-ssh-key +``` -### WSL +Copy the public SSH key to a file - it corresponds to the secret key on YubiKey and can be copied to SSH destination hosts. -The goal here is to make the SSH client inside WSL work together with the Windows agent you are using (gpg-agent.exe in our case). Here is what we are going to achieve: -![WSL agent architecture](media/schema_gpg.png) +Create a shortcut that points to `gpg-connect-agent /bye` and place it in the startup folder `shell:startup` to make sure the agent starts after reboot. Modify the shortcut properties so it starts in a "Minimized" window. -**Note** this works only for SSH agent forwarding. Real GPG forwarding (encryption/decryption) is actually not supported. See [weasel-pageant](https://github.com/vuori/weasel-pageant) for further information or consider using [wsl2-ssh-pageant](https://github.com/BlackReloaded/wsl2-ssh-pageant) which supports both SSH and GPG agent forwarding. +PuTTY can now be used for public-key SSH authentication. When the server asks for public-key verification, PuTTY will forward the request to GnuPG, which will prompt for a PIN to authorize the operation. -#### Use ssh-agent or use S.weasel-pageant +### WSL + +The goal is to configure SSH client inside WSL work together with the Windows agent, such as gpg-agent.exe. -One way to forward is just `ssh -A` (still need to eval weasel to setup local ssh-agent), and only relies on OpenSSH. In this track, `ForwardAgent` and `AllowAgentForwarding` in ssh/sshd config may be involved; However, if you use the other way (gpg ssh socket forwarding), you should not enable `ForwardAgent` in ssh config. See [SSH Agent Forwarding](#remote-machines-ssh-agent-forwarding) for more info. +![WSL agent architecture](media/schema_gpg.png) -Another way is to forward the gpg ssh socket, as described below. +**Note** this works only for SSH agent forwarding. GnuPG forwarding for cryptographic operations is not supported. See [vuori/weasel-pageant](https://github.com/vuori/weasel-pageant) for more information. -#### Prerequisites +One way to forward is just `ssh -A` (still need to eval weasel to setup local ssh-agent), and only relies on OpenSSH. In this track, `ForwardAgent` and `AllowAgentForwarding` in ssh/sshd config may be involved. However, when using ssh socket forwarding, do not enable `ForwardAgent` in ssh config. See [SSH Agent Forwarding](#remote-machines-ssh-agent-forwarding) for more information. This requires: * Ubuntu 16.04 or newer for WSL * Kleopatra * [Windows configuration](#windows) -#### WSL configuration +Download [vuori/weasel-pageant](https://github.com/vuori/weasel-pageant). -Download or clone [weasel-pageant](https://github.com/vuori/weasel-pageant). - -Add `eval $(/mnt/c//weasel-pageant -r -a /tmp/S.weasel-pageant)` to shell rc file. Use a named socket here so it can be used in the `RemoteForward` directive of `~/.ssh/config`. Source it with `source ~/.bashrc`. +Add `eval $(/mnt/c//weasel-pageant -r -a /tmp/S.weasel-pageant)` to the shell rc file. Use a named socket here so it can be used in the `RemoteForward` directive of `~/.ssh/config`. Source it with `source ~/.bashrc`. Display the SSH key with `$ ssh-add -l` -Edit `~/.ssh/config` to add the following for each host you want to use agent forwarding: +Edit `~/.ssh/config` to add the following for each agent forwarding host: -``` +```console RemoteForward /tmp/S.weasel-pageant ``` **Note** The remote SSH socket path can be found with `gpgconf --list-dirs agent-ssh-socket` -#### Remote host configuration - -You may have to add the following to the shell rc file. +Add the following to the shell rc file: -``` +```console export SSH_AUTH_SOCK=$(gpgconf --list-dirs agent-ssh-socket) ``` Add the following to `/etc/ssh/sshd_config`: -``` +```console StreamLocalBindUnlink yes ``` -And reload the SSH daemon (e.g., `sudo service sshd reload`). +Reload SSH daemon: -Unplug YubiKey, disconnect or reboot. Log back into Windows, open a WSL console and enter `ssh-add -l` - you should see nothing. +```console +sudo service sshd reload +``` -Plug in YubiKey, enter the same command to display the ssh key. +Unplug YubiKey, disconnect or reboot. Log back into Windows, open a WSL console and enter `ssh-add -l` - no output should appear. -Log into the remote host, you should have the pinentry dialog asking for the YubiKey pin. +Plug in YubiKey, enter the same command to display the ssh key. -On the remote host, type `ssh-add -l` - if you see the ssh key, that means forwarding works! +Connect to the remote host and use `ssh-add -l` to confirm forwarding works. -**Note** Agent forwarding may be chained through multiple hosts - just follow the same [protocol](#remote-host-configuration) to configure each host. You may also read this part on [chained ssh agent forwarding](#chained-ssh-agent-forwarding). +Agent forwarding may be chained through multiple hosts. Follow the same [protocol](#remote-host-configuration) to configure each host. ## macOS @@ -2583,53 +2312,45 @@ Create `$HOME/Library/LaunchAgents/gnupg.gpg-agent-symlink.plist` with the follo launchctl load $HOME/Library/LaunchAgents/gnupg.gpg-agent-symlink.plist ``` -You will need to either reboot, or log out and log back in, in order to activate these changes. +Reboot or log out and log back in to activate these changes. # Remote Machines (GPG Agent Forwarding) -This section is different from ssh-agent forwarding in [SSH](#ssh) as gpg-agent forwarding has a broader usage, not only limited to ssh. - -To use YubiKey to sign a git commit on a remote host, or signing email/decrypt files on a remote host, configure and use GPG Agent Forwarding. To ssh through another network, especially to push to/pull from GitHub using ssh, see [Remote Machines (SSH Agent forwarding)](#remote-machines-ssh-agent-forwarding) for more info. - -To do this, you need access to the remote machine and the YubiKey has to be set up on the host machine. - -After gpg-agent forwarding, it is nearly the same as if YubiKey was inserted in the remote. Hence configurations except `gpg-agent.conf` for the remote can be the same as those for the local. +YubiKey can be used sign git commits and decrypt files on remote hosts with GPG Agent Forwarding. To ssh through another network, especially to push to/pull from GitHub using ssh, see [Remote Machines (SSH Agent forwarding)](#remote-machines-ssh-agent-forwarding). -**Important** `gpg-agent.conf` for the remote is of no use, hence `$GPG_TTY` is of no use too for the remote. The mechanism is that after forwarding, remote `gpg` directly communicates with `S.gpg-agent` without *starting* `gpg-agent` on the remote. +`gpg-agent.conf` is not needed on the remote host; after forwarding, remote GnuPG directly communicates with `S.gpg-agent` without starting `gpg-agent` on the remote host. -On the remote machine, edit `/etc/ssh/sshd_config` to set `StreamLocalBindUnlink yes` +On the remote host, edit `/etc/ssh/sshd_config` to set `StreamLocalBindUnlink yes` -**Optional** If you do not have root access to the remote machine to edit `/etc/ssh/sshd_config`, you will need to remove the socket (located at `gpgconf --list-dir agent-socket`) on the remote machine before forwarding works. For example, `rm /run/user/1000/gnupg/S.gpg-agent`. Further information can be found on the [AgentForwarding GNUPG wiki page](https://wiki.gnupg.org/AgentForwarding). +**Optional** Without root access on the remote host to edit `/etc/ssh/sshd_config`, socket located at `gpgconf --list-dir agent-socket` on the remote host will need to be removed before forwarding works. See [AgentForwarding GNUPG wiki page](https://wiki.gnupg.org/AgentForwarding) for more information. -Import public keys to the remote machine. This can be done by fetching from a keyserver. On the local machine, copy the public keyring to the remote machine: +Import public keys on the remote host. On the local host, copy the public keyring to the remote host: ```console -$ scp ~/.gnupg/pubring.kbx remote:~/.gnupg/ +scp ~/.gnupg/pubring.kbx remote:~/.gnupg/ ``` -On modern distributions, such as Fedora 30, there is typically no need to also set `RemoteForward` in `~/.ssh/config` as detailed in the next chapter, because the right thing happens automatically. - -If any error happens (or there is no `gpg-agent.socket` in the remote) for modern distributions, you may go through the configuration steps in the next section. +On modern distributions such as Fedora 30, there is no need to set `RemoteForward` in `~/.ssh/config` ## Steps for older distributions -On the local machine, run: +On the local host, run: ```console -$ gpgconf --list-dirs agent-extra-socket +gpgconf --list-dirs agent-extra-socket ``` This should return a path to agent-extra-socket - `/run/user/1000/gnupg/S.gpg-agent.extra` - though on older Linux distros (and macOS) it may be `/home//.gnupg/S/gpg-agent.extra` -Find the agent socket on the **remote** machine: +Find the agent socket on the **remote** host: ```console -$ gpgconf --list-dirs agent-socket +gpgconf --list-dirs agent-socket ``` This should return a path such as `/run/user/1000/gnupg/S.gpg-agent` -Finally, enable agent forwarding for a given machine by adding the following to the local machine's ssh config file `~/.ssh/config` (your agent sockets may be different): +Finally, enable agent forwarding for a given host by adding the following to the local host's `~/.ssh/config` (agent sockets may differ): ``` Host @@ -2639,20 +2360,20 @@ Host # RemoteForward [remote socket] [local socket] ``` -If you're still having problems, it may be necessary to edit `gpg-agent.conf` file on the *local* machines to add the following information: +It may be necessary to edit `gpg-agent.conf` on the *local* host to add the following information: ``` pinentry-program /usr/bin/pinentry-gtk-2 extra-socket /run/user/1000/gnupg/S.gpg-agent.extra ``` -**Note** The pinentry program starts on *local* machine, not remote. Hence when there are needs to enter the pin you need to find the prompt on the local machine. +**Note** The pinentry program starts on the *local* host, not remote. -**Important** Any pinentry program except `pinentry-tty` or `pinentry-curses` may be used. This is because local `gpg-agent` may start headlessly (By systemd without `$GPG_TTY` set locally telling which tty it is on), thus failed to obtain the pin. Errors on the remote may be misleading saying that there is *IO Error*. (Yes, internally there is actually an *IO Error* since it happens when writing to/reading from tty while finding no tty to use, but for end users this is not friendly.) +**Important** Any pinentry program except `pinentry-tty` or `pinentry-curses` may be used. This is because local `gpg-agent` may start headlessly (by systemd without `$GPG_TTY` set locally telling which tty it is on), thus failed to obtain the pin. Errors on the remote may be misleading saying that there is *IO Error*. (Yes, internally there is actually an *IO Error* since it happens when writing to/reading from tty while finding no tty to use, but for end users this is not friendly.) See [Issue #85](https://github.com/drduh/YubiKey-Guide/issues/85) for more information and troubleshooting. -## Chained GPG Agent Forwarding +## Chained GnuPG agent forwarding Assume you have gone through the steps above and have `S.gpg-agent` on the *remote*, and you would like to forward this agent into a *third* box, first you may need to configure `sshd_config` of *third* in the same way as *remote*, then in the ssh config of *remote*, add the following lines: @@ -2666,20 +2387,20 @@ Host third You should change the path according to `gpgconf --list-dirs agent-socket` on *remote* and *third*. -**Note** On *local* you have `S.gpg-agent.extra` whereas on *remote* and *third*, you only have `S.gpg-agent`. +**Note** On *local* you have `S.gpg-agent.extra` whereas on *remote* and *third*, you only have `S.gpg-agent` # Using Multiple Keys To use a single identity with multiple YubiKeys - or to replace a lost card with another - issue this command to switch keys: ```console -$ gpg-connect-agent "scd serialno" "learn --force" /bye +gpg-connect-agent "scd serialno" "learn --force" /bye ``` Alternatively, use a script to delete the GnuPG shadowed key, where the card serial number is stored (see [GnuPG #T2291](https://dev.gnupg.org/T2291)): ```console -$ cat >> ~/scripts/remove-keygrips.sh <> ~/scripts/remove-keygrips.sh <&2; exit 1; } KEYGRIPS=$(gpg --with-keygrip --list-secret-keys "$@" | awk '/Keygrip/ { print $3 }') @@ -2691,22 +2412,20 @@ done gpg --card-status EOF -$ chmod +x ~/scripts/remove-keygrips.sh +chmod +x ~/scripts/remove-keygrips.sh -$ ~/scripts/remove-keygrips.sh $KEYID +~/scripts/remove-keygrips.sh $KEYID ``` See discussion in Issues [#19](https://github.com/drduh/YubiKey-Guide/issues/19) and [#112](https://github.com/drduh/YubiKey-Guide/issues/112) for more information and troubleshooting steps. # Adding an identity -You may need to add an identity after you've created, backed up, and moved your keys to your YubiKey. To do so, you'll need to first add the identity to your master key, and then reset your YubiKey and use `keytocard` to move the subkeys to your card again. - -## Add an identity to your master key +To add an identity after creating and backing up a YubiKey, first add the identity to the Certify key, and then reset YubiKey and use `keytocard` to move the Subkeys to the card again. -To add another identity to your GPG key, follow the same process as generating keys: boot to a secure environment, install required software and disconnect networking. +Follow the same process as generating keys: boot to a secure environment, install required software and disconnect networking. -Connect the offline secret storage device with the master keys and identify the disk label: +Connect the portable storage device with the Certify key and identify the disk label: ```console $ sudo dmesg | tail @@ -2715,191 +2434,146 @@ mmcblk0: mmc0:a001 SS16G 14.8 GiB (ro) mmcblk0: p1 p2 ``` -Decrypt and mount the offline volume: +Decrypt and mount the encrypted volume: ```console -$ sudo cryptsetup luksOpen /dev/mmcblk0p1 secret -Enter passphrase for /dev/mmcblk0p1: +sudo cryptsetup luksOpen /dev/mmcblk0p1 secret -$ sudo mount /dev/mapper/secret /mnt/encrypted-storage +sudo mount /dev/mapper/secret /mnt/encrypted-storage ``` -Restore your backup to a temporary directory: +Restore the backup to a temporary directory: ```console -$ export GNUPGHOME=$(mktemp -d -t gnupg_$(date +%Y%m%d%H%M)_XXX) +export GNUPGHOME=$(mktemp -d -t gnupg_$(date +%Y%m%d%H%M)_XXX) -$ cp -avi /mnt/encrypted-storage/tmp.XXX/* $GNUPGHOME +cp -avi /mnt/encrypted-storage/tmp.XXX/* $GNUPGHOME ``` -Edit your master key to add your new identity: +Edit the Certify key: ```console -$ KEYID=«your keyID» -$ gpg --expert --edit-key $KEYID +gpg --expert --edit-key $KEYID +``` -gpg> adduid -Real name: «your name» -Email address: «user@domain.tld» -Comment: «something» -You selected this USER-ID: - "«your name» («something») <«user@domain.tld»>" +Add the identity and set ultimate trust: -Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? O +```console +gpg> adduid gpg> trust - -Please decide how far you trust this user to correctly verify other users' keys -(by looking at passports, checking fingerprints from different sources, etc.) - - 1 = I don't know or won't say - 2 = I do NOT trust - 3 = I trust marginally - 4 = I trust fully - 5 = I trust ultimately - m = back to the main menu - Your decision? 5 -Do you really want to set this key to ultimate trust? (y/N) y gpg> save ``` -Now, re-export your master and sub keys: +Export Certify and Subkeys again: ```console -$ gpg --armor --export-secret-keys $KEYID > $GNUPGHOME/mastersub.key +gpg --armor --export-secret-keys $KEYID > $GNUPGHOME/certify.key -$ gpg --armor --export-secret-subkeys $KEYID > $GNUPGHOME/sub.key +gpg --armor --export-secret-subkeys $KEYID > $GNUPGHOME/subkeys.key ``` -And your public key: +Export the public key: ```console -$ gpg --armor --export $KEYID | sudo tee /mnt/public/gpg-$KEYID-$(date +%F).asc +gpg --armor --export $KEYID | sudo tee /mnt/public/gpg-$KEYID-$(date +%F).asc ``` -As before, on Windows, note that using any extension other than `.gpg` or attempting IO redirection to a file will garble the secret key, making it impossible to import it again at a later date: +**Note** On Windows, using an extension other than `.gpg` or attempting IO redirection to a file will result in a nonfunctional private key. ```console -$ gpg -o \path\to\dir\mastersub.gpg --armor --export-secret-keys $KEYID +gpg -o \path\to\dir\certify.gpg --armor --export-secret-keys $KEYID -$ gpg -o \path\to\dir\sub.gpg --armor --export-secret-subkeys $KEYID +gpg -o \path\to\dir\subkeys.gpg --armor --export-secret-subkeys $KEYID -$ gpg -o \path\to\dir\pubkey.gpg --armor --export $KEYID +gpg -o \path\to\dir\pubkey.gpg --armor --export $KEYID ``` -Copy the **new** temporary working directory to encrypted offline storage, which should still be mounted: +Copy the **new** working directory to encrypted storage, which should still be mounted: ```console -$ sudo cp -avi $GNUPGHOME /mnt/encrypted-storage -``` - -There should now be at least two versions of the master and sub-keys backed up: - -```console -$ ls /mnt/encrypted-storage -lost+found tmp.ykhTOGjR36 tmp.2gyGnyCiHs +sudo cp -avi $GNUPGHOME /mnt/encrypted-storage ``` Unmount and close the encrypted volume: ```console -$ sudo umount /mnt/encrypted-storage +sudo umount /mnt/encrypted-storage -$ sudo cryptsetup luksClose /dev/mapper/secret +sudo cryptsetup luksClose /dev/mapper/secret ``` -## Updating your YubiKey +## Updating YubiKey -Now that your keys have been updated with your new identity, you have to move them onto your YubiKey. To do so, you need to first [reset](#reset) the OpenPGP applet on your YubiKey, and then follow the steps to [configure your smartcard](#configure-smartcard) again. +Now that keys have been updated with the new identity, they will need to be loaded to YubiKey. -Now you can [transfer the keys](#transfer-keys) to your YubiKey. Once you've done so, be sure to reboot or securely erase the GPG temporary working directory, and `unset GNUPGHOME`. +First, [Reset](#reset) the OpenPGP applet, then follow the steps to [Configure YubiKey](#configure-yubikey) again. -Finally, re-import the public key, as described in the [using keys](#using-keys) section. +Next, [Transfer Keys](#transfer-keys) and reboot or securely erase the temporary working directory. -Run `gpg -K` to confirm that your new identity is listed. +Finally, re-import the public key, as described in [Using Keys](#using-keys). + +Use `gpg -K` to verify the identity is listed. # Require touch **Note** This is not possible on YubiKey NEO. -By default, YubiKey will perform encryption, signing and authentication operations without requiring any action from the user, after the key is plugged in and first unlocked with the PIN. +By default, YubiKey will perform encryption, signing and authentication operations without requiring any action from the user after the key is plugged in and unlocked once with the PIN. To require a touch for each key operation, install [YubiKey Manager](https://developers.yubico.com/yubikey-manager/) and recall the Admin PIN: -**Note** Older versions of YubiKey Manager use `touch` instead of `set-touch` in the following commands. - Authentication: ```console -$ ykman openpgp keys set-touch aut on +ykman openpgp keys set-touch aut on ``` Signing: ```console -$ ykman openpgp keys set-touch sig on +ykman openpgp keys set-touch sig on ``` Encryption: ```console -$ ykman openpgp keys set-touch dec on +ykman openpgp keys set-touch dec on ``` **Note** Versions of YubiKey Manager before 5.1.0 use `enc` instead of `dec` for encryption. -Depending on how the YubiKey is going to be used, you may want to look at the policy options for each of these and adjust the above commands accordingly. They can be viewed with the following command: +**Note** Older versions of YubiKey Manager use `touch` instead of `set-touch` -``` -$ ykman openpgp keys set-touch -h -Usage: ykman openpgp keys set-touch [OPTIONS] KEY POLICY - - Set the touch policy for OpenPGP keys. - - The touch policy is used to require user interaction for all operations using the private key on the YubiKey. The touch policy is set - individually for each key slot. To see the current touch policy, run the "openpgp info" subcommand. - - Touch policies: - - Off (default) no touch required - On touch required - Fixed touch required, can't be disabled without deleting the private key - Cached touch required, cached for 15s after use - Cached-Fixed touch required, cached for 15s after use, can't be disabled - without deleting the private key +To view and adjust policy options: - KEY key slot to set (sig, dec, aut or att) - POLICY touch policy to set (on, off, fixed, cached or cached-fixed) - -Options: - -a, --admin-pin TEXT Admin PIN for OpenPGP - -f, --force confirm the action without prompting - -h, --help show this message and exit +``` +ykman openpgp keys set-touch -h ``` -If the YubiKey is going to be used within an email client that opens and verifies encrypted mail, `Cached` or `Cached-Fixed` may be desirable. +If the YubiKey is going to be used within an email client which opens and verifies mail, `Cached` or `Cached-Fixed` may be desirable. -YubiKey will blink when it is waiting for a touch. On Linux you can also use [yubikey-touch-detector](https://github.com/maximbaz/yubikey-touch-detector) to have an indicator or notification that YubiKey is waiting for a touch. +YubiKey will blink when it is waiting for a touch. On Linux, [maximbaz/yubikey-touch-detector](https://github.com/maximbaz/yubikey-touch-detector) can be used to indicate YubiKey is waiting for a touch. # Email -GPG keys on YubiKey can be used with ease to encrypt and/or sign emails and attachments using [Thunderbird](https://www.thunderbird.net/), [Enigmail](https://www.enigmail.net) and [Mutt](http://www.mutt.org/). Thunderbird supports OAuth 2 authentication and can be used with Gmail. See [this guide](https://ssd.eff.org/en/module/how-use-pgp-linux) from EFF for detailed instructions. Mutt has OAuth 2 support since version 2.0. +YubiKey can be used to decrypt and sign emails and attachments using [Thunderbird](https://www.thunderbird.net/), [Enigmail](https://www.enigmail.net) and [Mutt](http://www.mutt.org/). Thunderbird supports OAuth 2 authentication and can be used with Gmail. See [this EFF guide](https://ssd.eff.org/en/module/how-use-pgp-linux) for more information. Mutt has OAuth 2 support since version 2.0. ## Mailvelope -[Mailvelope](https://www.mailvelope.com/en) allows GPG keys on YubiKey to be used with Gmail and others. +[Mailvelope](https://www.mailvelope.com/en) allows YubiKey to be used with Gmail and others. -**Important** Mailvelope [does not work](https://github.com/drduh/YubiKey-Guide/issues/178) with the `throw-keyids` option set in `gpg.conf`. +**Important** Mailvelope [does not work](https://github.com/drduh/YubiKey-Guide/issues/178) with the `throw-keyids` option set in `gpg.conf` On macOS, install gpgme using Homebrew: ```console -$ brew install gpgme +brew install gpgme ``` -To allow Chrome to run gpgme, edit `~/Library/Application\ Support/Google/Chrome/NativeMessagingHosts/gpgmejson.json` and add: +To allow Chrome to run gpgme, edit `~/Library/Application\ Support/Google/Chrome/NativeMessagingHosts/gpgmejson.json` to add: ```json { @@ -2913,27 +2587,31 @@ To allow Chrome to run gpgme, edit `~/Library/Application\ Support/Google/Chrome } ``` -Edit the default path to allow Chrome to find GPG: +Edit the default path to allow Chrome to find GnuPG: ```console -$ sudo launchctl config user path /usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin +sudo launchctl config user path /usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin ``` -Finally, install the [Mailvelope extension](https://chrome.google.com/webstore/detail/mailvelope/kajibbejlbohfaggdiogboambcijhkke) from the Chrome app store. +Finally, install the [Mailvelope extension](https://chromewebstore.google.com/detail/mailvelope/kajibbejlbohfaggdiogboambcijhkke) from the Chrome web store. ## Mutt -Mutt has both CLI and TUI interfaces, and the latter provides powerful functions for daily email processing. In addition, PGP can be integrated such that signing/encryption/verifying/decryption can be done without leaving TUI. +Mutt has both CLI and TUI interfaces - the latter provides powerful functions for processing email. In addition, PGP can be integrated such that cryptographic operations can be done without leaving TUI. + +To enable GnuPG support, copy `/usr/share/doc/mutt/samples/gpg.rc` + +Edit the file to enable options `pgp_default_key`, `pgp_sign_as` and `pgp_autosign` -To enable GnuPG support, one can just use the config file `gpg.rc` provided by mutt, usually located at `/usr/share/doc/mutt/samples/gpg.rc` after installation. One only needs to edit the file on options like `pgp_default_key`, `pgp_sign_as` and `pgp_autosign`. After editting one can `source` this rcfile in their main `muttrc` to use it. +`source` the file in `muttrc` -**Important** If one uses `pinentry-tty` as one's pinentry program in `gpg-agent.conf`, it would mess with one's Mutt TUI, as reported. This is because Mutt TUI uses curses while tty output may harm the format. It is recommended to use `pinentry-curses` or other graphic pinentry program. +**Important** `pinentry-tty` set as the pinentry program in `gpg-agent.conf` is reported to cause problems with Mutt TUI, because it uses curses. It is recommended to use `pinentry-curses` or other graphic pinentry program instead. # Reset -If PIN attempts are exceeded, the card is locked and must be [reset](https://developers.yubico.com/ykneo-openpgp/ResetApplet.html) and set up again using the encrypted backup. +If PIN attempts are exceeded, the YubiKey is locked and must be [Reset](https://developers.yubico.com/ykneo-openpgp/ResetApplet.html) and set up again using the encrypted backup. -Copy the following script to a file and run `gpg-connect-agent -r $file` to lock and terminate the card. Then re-insert YubiKey to reset. +Copy the following to a file and run `gpg-connect-agent -r $file` to lock and terminate the card. Then re-insert YubiKey to complete reset. ```console /hex @@ -2965,25 +2643,27 @@ Admin PIN: 12345678 ## Recovery after reset -If for whatever reason you need to reinstate your YubiKey from your master key backup (such as the one stored on an encrypted USB described in [Backup](#backup)), follow the following steps in [Rotating keys](#rotating-keys) to setup your environment, and then follow the steps of again [Configure Smartcard](#configure-smartcard). - -Before you unmount your backup, ask yourself if you should make another one just in case. +To reset YubiKey from the Certify key backup (such as the one on encrypted portable storage described in [Backup](#backup)), follow [Rotating keys](#rotating-keys) to setup the environment, then [Configure YubiKey](#configure-yubikey). # Notes -1. YubiKey has two configurations: one invoked with a short press, and the other with a long press. By default, the short-press mode is configured for HID OTP - a brief touch will emit an OTP string starting with `cccccccc`. If you rarely use the OTP mode, you can swap it to the second configuration via the YubiKey Personalization tool. If you *never* use OTP, you can disable it entirely using the [YubiKey Manager](https://developers.yubico.com/yubikey-manager) application (note, this not the similarly named older YubiKey NEO Manager). The command to disable OTP with ykman is `ykman config usb -d OTP`. -1. Programming YubiKey for GPG keys still lets you use its other configurations - [U2F](https://en.wikipedia.org/wiki/Universal_2nd_Factor), [OTP](https://www.yubico.com/faq/what-is-a-one-time-password-otp/) and [static password](https://www.yubico.com/products/services-software/personalization-tools/static-password/) modes, for example. -1. Setting an expiry essentially forces you to manage your subkeys and announces to the rest of the world that you are doing so. Setting an expiry on a primary key is ineffective for protecting the key from loss - whoever has the primary key can simply extend its expiry period. Revocation certificates are [better suited](https://security.stackexchange.com/questions/14718/does-openpgp-key-expiration-add-to-security/79386#79386) for this purpose. It may be appropriate for your use case to set expiry dates on subkeys. -1. To switch between two or more identities on different keys - unplug the first key and restart gpg-agent, ssh-agent and pinentry with `pkill gpg-agent ; pkill ssh-agent ; pkill pinentry ; eval $(gpg-agent --daemon --enable-ssh-support)`, then plug in the other key and run `gpg-connect-agent updatestartuptty /bye` - then it should be ready for use. -1. To use yubikeys on more than one computer with gpg: After the initial setup, import the public keys on the second workstation. Confirm gpg can see the card via `gpg --card-status`, Trust the public keys you imported ultimately (as above). At this point `gpg --list-secret-keys` should show your (trusted) key. +1. YubiKey has two configurations, invoked with either a short or long press. By default, the short-press mode is configured for HID OTP; a brief touch will emit an OTP string starting with `cccccccc`. OTP mode can be swapped to the second configuration via the YubiKey Personalization tool or disabled entirely using [YubiKey Manager](https://developers.yubico.com/yubikey-manager): `ykman config usb -d OTP` + +1. Using YubiKey for GnuPG keys does not prevent use of other features, such as [WebAuthn](https://en.wikipedia.org/wiki/WebAuthn), [OTP](https://www.yubico.com/resources/glossary/otp/) and [static password](https://support.yubico.com/hc/en-us/articles/360016614980-Understanding-Core-Static-Password-Features). + +1. Setting a key expiry forces identity and credential lifecycle management. However, setting an expiry on the primary Certify key is useless, because it can be used to simply extend itself. [Revocation certificates](https://security.stackexchange.com/questions/14718/does-openpgp-key-expiration-add-to-security/79386#79386) should be used instead. + +1. To switch between multiple identities on different YubiKeys, unplug the first YubiKey and restart gpg-agent, ssh-agent and pinentry with `pkill gpg-agent ; pkill ssh-agent ; pkill pinentry ; eval $(gpg-agent --daemon --enable-ssh-support)` then insert the other YubiKey and run `gpg-connect-agent updatestartuptty /bye` + +1. To use YubiKey on multiple computers, import the corresponding public keys on them. Confirm see YubiKey is visible with `gpg --card-status`, then trust the imported public keys ultimately. `gpg --list-secret-keys` will show the correct and trusted key. # Troubleshooting -- Use `man gpg` to understand GPG options and command-line flags. +- Use `man gpg` to understand GnuPG options and command-line flags. - To get more information on potential errors, restart the `gpg-agent` process with debug output to the console with `pkill gpg-agent; gpg-agent --daemon --no-detach -v -v --debug-level advanced --homedir ~/.gnupg`. -- If you encounter problems connecting to YubiKey with GPG - try unplugging and re-inserting YubiKey, and restarting the `gpg-agent` process. +- If you encounter problems connecting to YubiKey with GnuPG - try unplugging and re-inserting YubiKey, and restarting the `gpg-agent` process. - If you receive the error, `gpg: decryption failed: secret key not available` - you likely need to install GnuPG version 2.x. Another possibility is that there is a problem with the PIN, e.g. it is too short or blocked. @@ -2999,7 +2679,7 @@ Before you unmount your backup, ask yourself if you should make another one just - If you still receive the error, `sign_and_send_pubkey: signing failed: agent refused operation` - [run the command](https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=835394) `gpg-connect-agent updatestartuptty /bye` -- If you still receive the error, `sign_and_send_pubkey: signing failed: agent refused operation` - edit `~/.gnupg/gpg-agent.conf` to set a valid `pinentry` program path, e.g. `pinentry-program /usr/local/bin/pinentry-mac` on macOS. +- If you still receive the error, `sign_and_send_pubkey: signing failed: agent refused operation` - edit `~/.gnupg/gpg-agent.conf` to set a valid `pinentry` program path. `gpg: decryption failed: No secret key` could also indicate an invalid `pinentry` path - If you still receive the error, `sign_and_send_pubkey: signing failed: agent refused operation` - it is a [known issue](https://bbs.archlinux.org/viewtopic.php?id=274571) that openssh 8.9p1 and higher has issues with YubiKey. Adding `KexAlgorithms -sntrup761x25519-sha512@openssh.com` to `/etc/ssh/ssh_config` often resolves the issue. @@ -3007,17 +2687,17 @@ Before you unmount your backup, ask yourself if you should make another one just - If you receive the error, `Error connecting to agent: No such file or directory` from `ssh-add -L`, the UNIX file socket that the agent uses for communication with other processes may not be set up correctly. On Debian, try `export SSH_AUTH_SOCK="/run/user/$UID/gnupg/S.gpg-agent.ssh"`. Also see that `gpgconf --list-dirs agent-ssh-socket` is returning single path, to existing `S.gpg-agent.ssh` socket. -- If you receive the error, `Permission denied (publickey)`, increase ssh verbosity with the `-v` flag and ensure the public key from the card is being offered: `Offering public key: RSA SHA256:abcdefg... cardno:00060123456`. If it is, ensure you are connecting as the right user on the target system, rather than as the user on the local system. Otherwise, be sure `IdentitiesOnly` is not [enabled](https://github.com/FiloSottile/whosthere#how-do-i-stop-it) for this host. +- If you receive the error, `Permission denied (publickey)`, increase ssh verbosity with the `-v` flag and verify the public key from the card is being offered: `Offering public key: RSA SHA256:abcdefg... cardno:00060123456`. If it is, verify the correct user the target system - not the user on the local system. Otherwise, be sure `IdentitiesOnly` is not [enabled](https://github.com/FiloSottile/whosthere#how-do-i-stop-it) for this host. - If SSH authentication still fails - add up to 3 `-v` flags to the `ssh` client to increase verbosity. - If it still fails, it may be useful to stop the background `sshd` daemon process service on the server (e.g. using `sudo systemctl stop sshd`) and instead start it in the foreground with extensive debugging output, using `/usr/sbin/sshd -eddd`. Note that the server will not fork and will only process one connection, therefore has to be re-started after every `ssh` test. -- If you receive the error, `Please insert the card with serial number: *` see [using of multiple keys](#using-multiple-keys). +- If you receive the error, `Please insert the card with serial number` see [Using Multiple Keys](#using-multiple-keys). - If you receive the error, `There is no assurance this key belongs to the named user` or `encryption failed: Unusable public key` use `gpg --edit-key` to set `trust` to `5 = I trust ultimately`. -- If, when you try the above `--edit-key` command, you get the error `Need the secret key to do this` - manually specify trust for the key in `~/.gnupg/gpg.conf` by using the `trust-key [key ID]` directive. +- If, when you try the above command, you get the error `Need the secret key to do this` - specify trust for the key in `~/.gnupg/gpg.conf` by using the `trust-key [key ID]` directive. - If, when using a previously provisioned YubiKey on a new computer with `pass`, you see the following error on `pass insert`, you need to adjust the trust associated with the key. See the note above. @@ -3026,9 +2706,9 @@ gpg: 0x0000000000000000: There is no assurance this key belongs to the named use gpg: [stdin]: encryption failed: Unusable public key ``` -- If you receive the error, `gpg: 0x0000000000000000: skipped: Unusable public key`, `signing failed: Unusable secret key`, or `encryption failed: Unusable public key` the sub-key may be expired and can no longer be used to encrypt nor sign messages. It can still be used to decrypt and authenticate, however. +- If you receive the error, `gpg: 0x0000000000000000: skipped: Unusable public key`, `signing failed: Unusable secret key`, or `encryption failed: Unusable public key` the Subkey may be expired and can no longer be used to encrypt nor sign messages. It can still be used to decrypt and authenticate, however. -- If you lost your GPG public key, follow [this guide](https://www.nicksherlock.com/2021/08/recovering-lost-gpg-public-keys-from-your-yubikey/) to recover it from YubiKey. +- If the GnuPG public key is lost, follow [this guide](https://www.nicksherlock.com/2021/08/recovering-lost-gpg-public-keys-from-your-yubikey/) to recover it from YubiKey. - Refer to Yubico article [Troubleshooting Issues with GPG](https://support.yubico.com/hc/en-us/articles/360013714479-Troubleshooting-Issues-with-GPG) for additional guidance. @@ -3052,91 +2732,63 @@ EOF # Alternatives -* [`piv-agent`](https://github.com/smlx/piv-agent) is an SSH and GPG agent which you can use with your PIV hardware security device (e.g. a Yubikey). -* [`keytotpm`](https://www.gnupg.org/documentation/manuals/gnupg/OpenPGP-Key-Management.html) is an option to use GnuPG with TPM systems. +* [`smlx/piv-agent`](https://github.com/smlx/piv-agent) - SSH and GnuPG agent which can be used with PIV devices +* [`keytotpm`](https://www.gnupg.org/documentation/manuals/gnupg/OpenPGP-Key-Management.html) - use GnuPG with TPM systems ## Create keys with batch Keys can also be generated using template files and the `batch` parameter - see [GnuPG documentation](https://www.gnupg.org/documentation/manuals/gnupg/Unattended-GPG-key-generation.html). -Start from the [gen-params-rsa4096](contrib/gen-params-rsa4096) template. If you're using GnuPG v2.1.7 or newer, you can also use the ([gen-params-ed25519](contrib/gen-params-ed25519) template. These templates will not set the master key to expire - see [Note #3](#notes). +Use the example [gen-params-rsa4096](contrib/gen-params-rsa4096) or [gen-params-ed25519](contrib/gen-params-ed25519) template (the latter requires GnuPG v2.1.7). -Generate master key: +Generate the Certify key: ```console -$ gpg --batch --generate-key gen-params-rsa4096 -gpg: Generating a basic OpenPGP key -gpg: key 0xEA5DE91459B80592 marked as ultimately trusted -gpg: revocation certificate stored as '/tmp.FLZC0xcM/openpgp-revocs.d/D6F924841F78D62C65ABB9588B461860159FFB7B.rev' -gpg: done +gpg --batch --generate-key gen-params-rsa4096 ``` -Verify the result: +Verify results: ```console -$ gpg --list-key -gpg: checking the trustdb -gpg: marginals needed: 3 completes needed: 1 trust model: pgp -gpg: depth: 0 valid: 1 signed: 0 trust: 0-, 0q, 0n, 0m, 0f, 1u -/tmp.FLZC0xcM/pubring.kbx -------------------------------- -pub rsa4096/0xFF3E7D88647EBCDB 2021-08-22 [C] - Key fingerprint = 011C E16B D45B 27A5 5BA8 776D FF3E 7D88 647E BCDB -uid [ultimate] Dr Duh +gpg --list-key ``` -The key fingerprint (`011C E16B D45B 27A5 5BA8 776D FF3E 7D88 647E BCDB`) will be used to create the three subkeys for signing, authentication and encryption. +The fingerprint is used to create the three Subkeys for encryption, signing and authentication operations. -Now create the three subkeys for signing, authentication and encryption. Use a 1 year expiration for sub-keys - they can be renewed using the offline master key, see [rotating keys](#rotating-keys). - -We will use the the quick key manipulation interface of GNUPG (with `--quick-add-key`), see [the documentation](https://www.gnupg.org/documentation/manuals/gnupg/Unattended-GPG-key-generation.html#Unattended-GPG-key-generation). +Use a one or several year expiration for Subkeys - they can be renewed using the Certify key, see [rotating keys](#rotating-keys). Create a [signing subkey](https://stackoverflow.com/questions/5421107/can-rsa-be-both-used-as-encryption-and-signature/5432623#5432623): ```console -$ gpg --quick-add-key "011C E16B D45B 27A5 5BA8 776D FF3E 7D88 647E BCDB" \ - rsa4096 sign 1y +gpg --quick-add-key "$KEYID" rsa4096 sign 1y ``` -Now create an [encryption subkey](https://www.cs.cornell.edu/courses/cs5430/2015sp/notes/rsa_sign_vs_dec.php): +Create an [encryption subkey](https://www.cs.cornell.edu/courses/cs5430/2015sp/notes/rsa_sign_vs_dec.php): ```console -$ gpg --quick-add-key "011C E16B D45B 27A5 5BA8 776D FF3E 7D88 647E BCDB" \ - rsa4096 encrypt 1y +gpg --quick-add-key "$KEYID" rsa4096 encrypt 1y ``` Finally, create an [authentication subkey](https://superuser.com/questions/390265/what-is-a-gpg-with-authenticate-capability-used-for): ```console -$ gpg --quick-add-key "011C E16B D45B 27A5 5BA8 776D FF3E 7D88 647E BCDB" \ - rsa4096 auth 1y -``` - -Continue with the Verify section of this guide. - -# Links - -* [Minimal key management tool written for this guide](https://gitlab.com/lsasolutions/makegpg) -* https://alexcabal.com/creating-the-perfect-gpg-keypair/ -* https://blog.habets.se/2013/02/GPG-and-SSH-with-Yubikey-NEO -* https://blog.josefsson.org/2014/06/23/offline-gnupg-master-key-and-subkeys-on-yubikey-neo-smartcard/ -* https://blog.onefellow.com/post/180065697833/yubikey-forwarding-ssh-keys -* https://developers.yubico.com/PGP/ - * https://developers.yubico.com/PGP/Card_edit.html -* https://developers.yubico.com/yubikey-personalization/ -* https://evilmartians.com/chronicles/stick-with-security-yubikey-ssh-gnupg-macos -* https://gist.github.com/ageis/14adc308087859e199912b4c79c4aaa4 -* https://github.com/herlo/ssh-gpg-smartcard-config -* https://github.com/tomlowenthal/documentation/blob/master/gpg/smartcard-keygen.md -* https://help.riseup.net/en/security/message-security/openpgp/best-practices -* https://jclement.ca/articles/2015/gpg-smartcard/ -* https://rnorth.org/gpg-and-ssh-with-yubikey-for-mac -* https://trmm.net/Yubikey -* https://www.bootc.net/archives/2013/06/09/my-perfect-gnupg-ssh-agent-setup/ -* https://www.esev.com/blog/post/2015-01-pgp-ssh-key-on-yubikey-neo/ -* https://www.hanselman.com/blog/HowToSetupSignedGitCommitsWithAYubiKeyNEOAndGPGAndKeybaseOnWindows.aspx -* https://www.void.gr/kargig/blog/2013/12/02/creating-a-new-gpg-key-with-subkeys/ -* https://mlohr.com/gpg-agent-forwarding/ -* https://www.ingby.com/?p=293 -* https://support.yubico.com/support/solutions/articles/15000027139-yubikey-5-2-3-enhancements-to-openpgp-3-4-support -* https://github.com/dhess/nixos-yubikey +gpg --quick-add-key "$KEYID" rsa4096 auth 1y +``` + +# Additional resources + +* [Yubico - PGP](https://developers.yubico.com/PGP/) +* [Yubico - PGP Card edit](https://developers.yubico.com/PGP/Card_edit.html) +* [Yubico - Yubikey Personalization](https://developers.yubico.com/yubikey-personalization/) +* [A Visual Explanation of GPG Subkeys (2022)](https://rgoulter.com/blog/posts/programming/2022-06-10-a-visual-explanation-of-gpg-subkeys.html) +* [dhess/nixos-yubikey](https://github.com/dhess/nixos-yubikey) +* [lsasolutions/makegpg](https://gitlab.com/lsasolutions/makegpg) +* [Trammell Hudson - Yubikey (2020)](https://trmm.net/Yubikey) +* [Yubikey forwarding SSH keys (2019)](https://blog.onefellow.com/post/180065697833/yubikey-forwarding-ssh-keys) +* [GPG Agent Forwarding (2018)](https://mlohr.com/gpg-agent-forwarding/) +* [Stick with security: YubiKey, SSH, GnuPG, macOS (2018)](https://evilmartians.com/chronicles/stick-with-security-yubikey-ssh-gnupg-macos) +* [PGP and SSH keys on a Yubikey NEO (2015)](https://www.esev.com/blog/post/2015-01-pgp-ssh-key-on-yubikey-neo/) +* [Offline GnuPG Master Key and Subkeys on YubiKey NEO Smartcard (2014)](https://blog.josefsson.org/2014/06/23/offline-gnupg-master-key-and-subkeys-on-yubikey-neo-smartcard/) +* [Creating the perfect GPG keypair (2013)](https://alexcabal.com/creating-the-perfect-gpg-keypair/) +* [GPG and SSH with Yubikey NEO (2013)](https://blog.habets.se/2013/02/GPG-and-SSH-with-Yubikey-NEO) +* [Riseup - OpenPGP Best Practices](https://help.riseup.net/en/security/message-security/openpgp/best-practices)