News for hackers. Stuff that matters.
Re:PGP Marks 30th Anniversary by dale_glass on Tuesday June 08, 2021 @02:43AM (#27431325)
It's very unfortunate PGP/GPG hasn't kept up with the times. Today it has two significant issues:

1. The needed trust model has changed significantly. 2. It's not reusable enough.

1. The original PGP mostly dealt with direct person-to-person relationships. Alice and Bob needed to safely communicate. Perhaps Bob could vouch for Carol. But that was the intended model: closely related groups, with maybe a person trusted to act as an introducer. Today our needs are different, and we need to securely communicate with people we never met, or to verify their signatures. Any Linux system contains thousands of packages, which were worked on by many thousands of developers, one may need to communicate with securely at some point. Eg, I want to verify the GPG signature on the Tor browser, but I never met anyone on the team, and how do I know who knows the team?

My personal network actually extends very far. I did the FOSDEM key signing party several times, so my theoretical reach is enormous. But it can only be achived by hacking around GPG's trust model. I need to figure out by hand a path between me and Tor, download the keys, and manually tell GPG I trust each key's signature. This isn't convenient, user friendly, not as safe as it could be.

2. GPG is unfortunately stuck in the "Unix Philosophy" era, where you're supposed to just invoke the binary and parse its text output. I believe this crippled GPG's adoption, because it's slow. GPG has to do the whole startup, reading its key databases and so on every single time. Back when GPG support was introduced into KMail many years ago this added a very noticeable delay to viewing any signed message.

And it's sadly still the case. The world badly needs a GPG library, that allows one to skip those startup costs, and to avoid the whole intended model of ~/.gnupg and just let a program do things like interpret in-memory data for any conceivable purpose. This is still badly lacking.

Re:PGP Marks 30th Anniversary by globular-toast on Tuesday June 08, 2021 @03:35AM (#27431616)
I think you're wrong on point 1. PGP was always very much about communicating with people you don't know. Otherwise you'd just use symmetric encryption. Web of trust is still the best way we have to do that. Newer applications like signal etc are what require each pair of correspondents to exchange keys and "complete the graph".

The difference with more "modern" technologies is just that they let you implicitly trust keys more easily. Web browsers just have you trust hundreds of CAs without even making you aware of them. Verifying keys on messaging apps is unknown and not understood by the vast majority of users.

Re:PGP Marks 30th Anniversary by dale_glass on Tuesday June 08, 2021 @04:09AM (#27431796)
Give it a try, then.

0. GPG implicitly trusts your key.

1. GPG trusts keys you've signed.

2. GPG can also trust keys signed by people you trust.

And that's where it ends, normally.

So say you want to verify the signature on the Tor browser. So have you met the key holder directly and signed their key? #1 failed. Do you know anybody who signed the Tor key? #2 failed. You can't properly verify it.

Actually, GPG allows the chain to extend for longer. You can verify a You -> Alice -> Bob -> Carol chain. The problem is that standard GPG doesn't have any easy way for you to find about Bob. You know Alice, you can find the content signed by Carol, but you may lack Bob's key.

You can find it out by hand, by getting Carol's key, finding who signed it, and downloading all those keys hoping somebody you know signed one of those.

That's the easy scenario, if you extend this to another step, that is, You -> Alice -> Bob -> Carol -> Dave, it gets even more annoying.

And besides not being user friendly, it turns out that GPG sucks at dealing with large key databases, so mass-downloading keys in hopes of finding a connection tends to noticeably degrade performance.

Re:PGP Marks 30th Anniversary by upofadown on Tuesday June 08, 2021 @06:55AM (#27433347)
>Actually, GPG allows the chain to extend for longer. You can verify a You -> Alice -> Bob -> Carol chain.

But it certainly doesn't mandate it. It's called the web of trust, not the chain of trust. You would never have such a chain of trust in real life so there is no reason to use PGP to create a model that doesn't make sense. Trust is normally quite shallow.

This is a generic rhetorical technique often used against flexible systems. The flexibility is used to create absurd straw men.

Re:PGP Marks 30th Anniversary by dale_glass on Tuesday June 08, 2021 @07:33AM (#27433730)
The web can be seen as being made from many chains.

https://imgur.com/a/aTDcbtu

Those connections exist on keyservers already, GPG just doesn't have a comfortable way of finding them. For instance if you want to verify M's key, you have:

A -> B -> G -> M

A -> C -> H -> M

A -> D -> H -> M

A -> E -> I -> M

Using multiple paths should allow building some confidence into M's key.

The issue is that in the current model, A has the keys for B, C, D and E, and also M's key since they're trying to check their signature. But the rest of the web that is present on keyservers isn't easily reachable to the user.

Re:PGP Marks 30th Anniversary by globular-toast on Tuesday June 08, 2021 @04:38AM (#27431944)
I get that it's hard but it's hard because security is hard. What's the alternative? How else can you verify the signature on Tor browser?
Re:PGP Marks 30th Anniversary by dale_glass on Tuesday June 08, 2021 @04:57AM (#27432050)
By explicitly supporting this model. Recognize that in the modern usage model you often need to find a trust path to some completely random person you've never met, such as the maintainer of some random software program.

And that you need to support a "good enough" trust model for those cases. What do I mean by that? GPG has two separate things: signatures, and trust levels. When you sign somebody's key, GPG wants to know how confident you are that this person will only sign the keys of people who deserve it. Eg, you can trust that Philip Zimmermann will check fingerprints, but your grandma maybe won't, so her signature isn't worth much if anything.

For the first part, GPG needs a path finding service. That is, when dealing with a "You -> Alice -> Bob -> Carol" path, you can give this service your key ID, Carol's key id, and the service tells you whether any path at all exists between those keys. This should be an automatic API that GPG itself can use, like it uses a keyserver. This used to exist, in the form of some random website run by an university professor that now seems gone. It needs to exist as a proper, official webservice.

For the second, in GPG's normal security model, GPG is going to ask you how confident you are in Bob's cryptographic knowledge and signing discipline. And how the heck could you know? You don't know him, he's a friend of Alice's. She should know that. Some way needs to be invented to deal with this, either by having Alice's signature on Bob's key contain a trust level, or by having a mode in which a signature is at least better than nothing, and you can get some confidence rating based on how many paths you can take to reach the destination.

Re:PGP Marks 30th Anniversary by rjzzleep on Tuesday June 08, 2021 @06:59AM (#27433414)
One thing I've noticed is that package signing has a bit of an issue. It lacks metadata about the package.

I'll use archlinux as an example but the same applies to PPA's in Ubuntu:

Say you add a public key of a third party because you want to install a certain package or add a certain repo. The keyring then trusts that key. But it doesn't trust the key for a specific package. It just generally trusts the key.

From a security aspect your system is not compromised, because the security of your base packages now depends on whether random key for third party is compromised. I.e. you can now install backdoored software because that package you wanted to add is compromised.

It's not really limited to linux repos though, imagine you install a driver on windows and it asks you to trust the signing key. That signing key can now be use to put random malicious software on your windows system.

Is there any reason why this metadata couldn't be added to something like pgp other than it requiring a lot of changes in the tooling?

Re:PGP Marks 30th Anniversary by dale_glass on Tuesday June 08, 2021 @07:24AM (#27433647)
My view is that it's because GPG sucks, and has been used for things it doesn't want to be used for.

GPG's usage model is a commandline tool, used by a person to verify a signature on a file or such. It has a keyring in ~/.gnupg, and importing keys imports them into this keyring. And it really insists on that.

This whole idea of having a key that only applies to a specific package or repository was never intended in its design. When something like a package manager uses GPG it calls the commandline tool and gives it a home directory and keyring somewhere.

What the world really needs is a GPG library. But not GPGme, which just calls the GPG binary and parses the output.

What is needed is one that dispenses with any ideas about how the end-user is supposed to work and just provides primitives to parse keys and messages, verify signatures, etc, and lets the user make decisions about whether to have a global list of keys, or per-repo keys, use a proper database like postgres, or even not store anything at all if all you need is to parse something. But alas, such things are still scarce, and the prevailing model is just hacking GPG into sort of doing a job it doesn't want to do.

There's also some weirdness on the package handling side. Apparently the modern way of doing things in Debian is that you don't sign a package, you sign the repository metadata instead. This may be motivated by the fact that GPG sucks and is slow (because you're calling a binary that loads libraries, parses config file and databases every time, etc), and calling GPG a thousand times during installation would be a significant slowdown.

Re:PGP Marks 30th Anniversary by guillemj on Tuesday June 08, 2021 @09:16AM (#27434728)
Hmm this seems to conflate various things.

As anyone who has had to make code interact with GnuPG will attest, I very much agree its interfaces are not ideal to put it mildly. I'm pretty excited, though, about things like Statless OpenPGP CLI (SOP), or Sequoia's CLI f.ex., and several of the other tools referenced up-thread to handle package signatures are also CLI, so I don't think that's an inherent problem.

Regarding packages, apt supports pinning specific keys or keyrings to specific repositories (via the signed-by attribute), as does debsig-verify (which can pin keys or keyrings to specific policies). On Debian, packages get signed by the maintainers (both the source packages, inside the .dsc file, and for the entire upload, inside the .changes file), which get uploaded and then the repository software takes over and signs both source and binary packages in the metaindices. This was made pretty much designed on purpose, and independently of GnuPG CLI's speed or design shortcomings. The repository needs to handle key rotation, due to expiration, algo renewal, security compromises, maintainers leaving the project (and as such their keys not being trusted anymore), etc. Embedding the signatures into the source or binary packages would mean that they would change content, which implies massive mirroring costs, simple digest verification oddities, and similar. Adding detached signatures for each individual source and binary package would make the inode count explode. The metadata still would need to be signed no matter what, and doing either of those per package signing would also make signature update and repository metadata generation and mirroring extremely painful, as you need to be able to do that atomically. In addition the repository needs to be signed as a whole, because it's really a snapshot of a known state, and while it should be fine to mix and match various repositories (at the user request), that should not be the default (at least within a specific repository state).

Re:PGP Marks 30th Anniversary by dale_glass on Tuesday June 08, 2021 @09:28AM (#27434871)
@guillemj Interesting information, thanks. I stand corrected.

Also, is there a comment depth limit? I can't seem to reply directly. Sheesh.