YubiKey-Guide VS secretive

Instead, most people generate keypair(s) on an airgapped machine and write them to two Yubikeys. Or write subkeys to a single Yubikey and keep a backup in encrypted form. See https://github.com/drduh/YubiKey-Guide

I'd recommend using the Yubikey as a GPG smartcard[1]. The private key stays on the Yubikey. I also use it for ssh. But make sure you have a backup key or two, just in case the primary Yubikey gives out. FIDO2 and all other regular Yubikey functionality still works with it.

[1]: https://github.com/drduh/YubiKey-Guide

The excellent guide by drduh should be mentioned here: https://github.com/drduh/YubiKey-Guide — I've been using this approach for years to store my OpenPGP keys on Yubikeys and use them for SSH.

I don't generate my keys on devices. That lets me be flexible and keep backups, as well as use the same keys on multiple physical devices. Using a single yubikey is a bad idea, as you're bound to eventually lose it or break it. Hasn't happened to me yet in 5 years, but I expect it to happen.

I followed this guide to generate a master key and three subkey.

See https://github.com/drduh/YubiKey-Guide . Also google for OpenPGP card specifications, they will answer your question

Regarding GPG/SSH keys, there is a great howto: https://github.com/drduh/YubiKey-Guide

I'd be lying if I said I understood all of that. I'm definitely going to do some research ahaha. Someone else on this post sentence this like which they said was very good guide. https://github.com/drduh/YubiKey-Guide

When storing the key on a Yubikey, however, all you need is just the PIN in order to use the key. It can contain numbers, letters, symbols, etc. and can be quite long, so you can treat it as a passphrase for all intents and purposes. There are actually two PIN codes: one regular one, for a read access, and another administrative one, for write access for when you want to modify the gpg applet settings or the key on the Yubikey. There is also a limit to how many times in a row you can enter pins incorrectly, after which the gpg applet gets locked and the only thing you can do is reset it, erasing the PGP keys. See https://github.com/drduh/YubiKey-Guide for more information.

Try follow this guide from DrDuh https://github.com/drduh/YubiKey-Guide/blob/master/README.md

Secretive might be what you're looking for: https://github.com/maxgoedjen/secretive

Good find! I was always curious how this worked.

I'm a big fan of tools like secretive[1] that can help solve this problem by using biometrics to shift the UX/security trade-off and thus make it feasible to always require some kind of authentication to sign a token with a key.

I'm not aware of any tools that do the same for Linux, and a quick Google search doesn't turn up much[2]. It does look like you can at least get a notification[3], though.

This could provide another layer of protection on the user's endpoint device in addition the network monitoring called out in the article. Defense in depth, and all that.

[1] https://github.com/maxgoedjen/secretive

[2] https://unix.stackexchange.com/questions/705144/unlock-an-ss...

[3] https://www.insecure.ws/2013/09/25/ssh-agent-notification.ht...

https://github.com/maxgoedjen/secretive

> Secretive is an app for storing and managing SSH keys in the Secure Enclave

Secretive, which replaces painfully managing SSH keys from the command line / editor. Getting a Touch ID prompt is so much better, though migrating computers will suck.

consider using a higher-security setup. Secretive is an SSH agent for MacOS that stores keys within the host's secure enclave, where they can't be copied off, and can optionally require touchid validation before the key is used. This way, if you forward it the key to an compromised host and an attacker tries to use them, it'll still require a fingerprint (but, balance it with the fact that Secretive doesn't have nearly as many eyeballs checking it, yet!). Likewise, yubikeys can be setup to store SSH keys inside them and require touch to use.

You can store them in the Secure Enclave on OSX and require TouchID to use the key for signing.

See: https://github.com/maxgoedjen/secretive

Not exactly connected but the same crowd interested in this topic may also be interested in this tool to store SSH private keys in the Secure Enclave, kind of like what can be done with a YubiKey:

https://github.com/maxgoedjen/secretive

I've been looking for something like this for 3-4 years but only found it six months ago (in an HN thread). I use separate keys for every use case, and now know every time a key is used for any purpose, whether it's connecting to source control or my text editor is connecting to a remote VM.

Only thing I haven't figured out is how to do git signatures with these sorts of keys, but I haven't debugged it at all.

On Macs, Secretive [0] is great. It creates keys in the secret enclave, from where they can't be read, only used for signing requests. TouchID authorisation is optional but it's so quick and easy that I keep it on for all keys.

It can also use Smart Cards (Yubikeys are called out by name in the readme).

A forwarded agent will have the same level of security, meaning that if the forwarded agent needs to use a key in Secretive, it will have to be authorised locally - and even if TouchID is disabled, you are notified if a key is used.

[0] https://github.com/maxgoedjen/secretive/