Tag: openpgp

OpenPGP key statistics

Recently there has been some talk about the number of OpenPGP keys available on the various keyservers. My own contribution to this discussion is tracking the development at sks-keyservers.net . As can be seen on both the line chart of total number of keys, and the breakdown to a bar chart for daily addition, new keys are added at a higher rate today than it was just a few years ago, and without any statistical considerations, the change of rate seems to coincidentally correspond to the Snowden leaks.

 

LineChart BarChart

This post will look into some of the underlying data and hopefully provide a bit more information depth. The data was exported from one of my own keyservers yesterday and consists of 3,526,080 primary keys, of which 118 keys were invalid to the point that I've discarded them from the rest of the analysis (unable to properly parse the OpenPGP packets to extract the information). To emphasize; I have not looked into subkeys in any way for the purposes of this post and I have made no attempt to determine whether these keys are expired, revoked or otherwise inactive.

The overall majority (94.74%) were Version 4 keys c.f. RFC4880 with V3 keys representing 4.73% and V2 keys representing 0.53%. DSA keys represented 74.4%, while 25.6% were RSA keys and a minority ElGamal (0.03%), Elliptic Curve keys (35 keys) and keys in the experimental range (32 keys) .

The key lengths spans from 3 keys in the experimental range key with algo id 103 of 224 bits to 32,768 bits (3 keys, two of which are RSA and one DSA). Due to the low occurrence of ECC keys (that have an expectation of lower key lenghts for similar expected security levels -  normally in the 256-521 bit range, although there is a strong possibility that the aforementioned 224 bits keys should also fit in this category) I have not done any adjustment for these. A full 77.4% of the keys are included when looking at the aggregate figures up to and including 1024 bits, roughly 2.7 million of the keys, and the corresponding number when looking at a 2048 and 4096 bits respectively are 95.3% and 99.95% of all keys included.

key_length

Load-balancing SKS

The synchronizing key server (SKS) is the most used implementation of OpenPGP key servers. Despite its many strengths, however, its web frontend scales badly and should generally be placed behind a reverse proxy such as nginx, apache or varnish. For inclusion in the High-Availability (HA) pool of sks-keyservers.net this is a requirement, and it is also part of the weighting criteria for the various geographical sub pools. With the increase in number of keys I've been thinking of ways to ensure that the pool stays even more responsive, and currently considering (i) to make it a hard-requirement for inclusion in the pool to have a reverse proxy set up (ii) to reuse the HA pool for a set of servers that are even more available, by proving that they are load-balanced across multiple instances of SKS.

 

My own keyserver, for historical reasons named keys2.kfwebs.net (keys.kfwebs.net was located in another server facility and is currently not operational),  is running such a load balanced setup using Nginx's upstream module.But before getting back to that, some basic information about my SKS setup.

Two or three SKS servers (depending on whether I need to use one of them for experimenting with other projects such as the Key Signing Party list auto-generating lists based on publications to a keyserver) are running on different Virtual Machines, one server peering with the global network and the other servers peering internally. To ease the load on SKS, static pages are served by nginx directly using:

location / {
root /var/sks/web;
index   index.xhtml;
}

 

The actual data being served by SKS is in the /pks subdirectory and is being handled by the directive

location /pks {
proxy_pass http://sks_servers/pks;
proxy_pass_header  Server;
add_header Via "1.1 keys2.kfwebs.net";
proxy_ignore_client_abort on;
}

And this is where the load-balancing is starting to happen. "sks_servers" is not a hostname that is being referenced but an upstream directive in Nginx that states;

upstream sks_servers
{
server  localhost:11372;
server  192.168.0.27:11371;
}

When adding and removing servers I simply edit this directive and reload nginx, and here I also have the possibility of assigning weights to each of the servers (defaults to 1).
In the status list of the pool such load-balanced servers can be identified by a blue flag for RProx (Reverse Proxy). Hopefully enough operators will set up load-balanced systems for an even more responsive High-Availability pool to exist.

 

OpenPGP Key Signing Parties

After posing Monkeysphere: Easing key management and improving HTTPS security I received some constructive feedback from an acquaintance. The message was clear enough; I need to make an effort in getting more signatures for my key so that it is possible to validate it based on the Web of Trust.

 

There are several ways to get the key better connected, but a popular method is to set up, or simply participating in, key signing parties (KSP). The Keysigning Party HOWTO is a good read, so I won't go into the descriptives too much, except to say that I'm a fan of the List Based Method Party described in the howto. This require a bit more organization ahead of the key signing party, but overall the experience should be a smoother one. The basic idea with this approach is that you have one, or several, organizers that collects the public keys of the participants ahead of time and prepare a list of keys for the participants. Normally there will be a set of requirements for these keys e.g. that they are available on public keyservers such as the sks-keyservers.net pools.

Those wanting to participate then send a copy of the key itself or the keyid or fingerprint for such a key so that it can be retrieved from the keyservers. From an organizer perspective the steps are then to start building up a database of participants, e.g. in a GnuPG keyring, which is what I'll use.

 

Step 1: Create a directory for information about the key signing party

mkdir -p $HOME/Tmp/KeySigningPartyRing

Step 2: For each of the participants, download the keys into a gpg keyring in this home dir

I'm starting with my own keys

gpg2 --homedir $HOME/Tmp/KeySigningPartyRing --keyserver eu.pool.sks-keyservers.net --recv-key 0x0B7F8B60E3EDFAE3

gpg2 --homedir $HOME/Tmp/KeySigningPartyRing --keyserver eu.pool.sks-keyservers.net --recv-key 0x43FE956C542CA00B

These keys are then stored in pubring.gpg in the homedir specified.

 

Step 3: Creating the participant list

To create a list of participants based on the information found in the keyring I personally use a PHP Script that is available at https://bitbucket.org/kristianf/keysigningpartylist

This script take the homedir as an argument, so I run it as

php -f /path/to/keysigningPartyList.php $HOME/Tmp/KeySigningPartyRing

The script can be configured by a file called ksp_conf in the same homedir,  I set the variables as

title: My KSP
date: 2013-12-31

Step 4: Digitally sign the participant list

In order to ensure that the list has not been modified after it is uploaded to a http/ftp location that the participants have access to I then sign the two files generated from the script, which unless otherwise configured in ksp_conf is key_party_list.html and fpr.txt I also sign these files using gpg. To do this, while having the homedir as my working directory,  I run

for f in key_party_list.html fpr.txt; do gpg2 --armor --detach-sign $f; done

 

Step 5: Upload the participant list

I can then upload the participant list, the fingerprint list (this is a convenience file, more on that later) and the relevant digital signatures.

for f in key_party_list.html* fpr.txt*; do scp "$f" "server:/path/to/openpgp_key_signing_party_example/"; done

The result can be seen at http://dev.kfwebs.net/openpgp_key_signing_party_example/ . Each participant will then print the participant list, or the organizer print them and bring along to the key signing party.

Step 6: Holding the KSP

During the KSP each participant then bring a copy of their own fingerprint and key data that can be used to match against the list and verify the ID documents to make sure they match the UID.

 

Step 7: Signing the keys and uploading this for others to see

After the KSP is done, and all keys have been verified, it is time to sign the other's keys. This is where the convenience-file fpr.txt comes in, as this can readily be passed on to tools such as caff and monkeysign or it can just be used to retrieve all the keys from a keyserver.