This post is a combination of a description of a Chrome bug (fixed in May), a mea culpa, and an explanation of of the way HTTPS certificates work. So there’s something for everyone! :-)
Here’s the situation — don’t worry if you don’t understand all of this initially, a lot of it is explained later. Last year, the Chromium team decided that they should encourage site owners to stop using HTTPS certificates signed using the SHA-1 algorithm, which has security holes. The way they are doing this is by making the “padlock” icon in the URL bar show that a site is not secure if it has a certificate that expires after the end of 2015 if either the certificate itself is signed with SHA-1, or if any of the certificates in its chain are. I encountered some weird behaviour related to this when we recently got a new certificate for PythonAnywhere. Hopefully by posting about it here (with a bit of background covering the basics of how certificates work, including some stuff I learned along the way) I can help others who encounter the same problem.
tl;dr for people who understand certificates in some depth — if any certificate in your chain, including your own cert, is signed with multiple hashing algorithms, then if you’re using Chrome and have a version of libnss < 3.17.4 installed, Chrome's check to warn about SHA-1 signatures, instead of looking at the most-secure signature for each cert, will look at the least-secure one. So your certificate will look like it's insecure even if it's not. Solution for Ubuntu (at least for 14.04 LTS):
sudo apt-get install libnss3. Thank you so much to Vincent G on Server Fault for working out the fix.
Here’s the background. It’s simplified a bit, but I think is largely accurate — any corrections from people who know more about this stuff than I do would be much appreciated!
Most readers here probably have a decent working knowledge of asymmetrical cryptography, so I’m going to skip a lot of detail here; there are excellent primers on public key encryption all over the Internet and if you need to know more, google for one that suits you.
But if you just want to get through this post, here’s the stuff you need to know: public and private keys are large numbers, generated in public/private pairs. Each of them can be used on its own to encrypt data. Stuff that is encrypted with the private key can be decrypted with the public key, and vice versa.
It is almost impossibly unlikely that a particular bit of data encrypted with one private key would be the same as the same data encrypted with a different private key. So, if I want to prove that I sent you something, and you already have a copy of my public key (let’s ignore how you got hold of it for now), I can send you the data encrypted with my private key, and if you can decrypt it then it’s pretty much guaranteed that it was me who sent it — or at least it was someone who has a copy of my private key.
Furthermore, we can extend this to a concept of digital signatures. If I want to send you some data and to prove that it came from me, I can use a hash function to reduce that data down to a short(ish) number, then I can encrypt that hash with my private key. I then send you the data, with the encrypted hash tacked onto the end as a signature. To verify that it really came from me, you hash the data using the same algorithm, then decrypt the signature using my public key. If they match, then you know I really did sign it.
This has a couple of advantages over simply encrypting the whole thing using my private key — the most relevant for this post being that the data itself is in the clear: we’re only using the encryption to prove who provided it.
When you want to run an HTTPS site, you need to get a certificate. This is basically some data that states the domain that’s covered by the certificate and who owns it, and a public key. It basically claims “the owner of the private key associated with this public key is the person that this data relates to”. It also has some data saying “this is who says that this claim is true” — the issuer. So, for the certificate that you bought from, say, Joe’s SSL Certificates, the issuer will be some identifier for that company.
So, the question is, how do we stop people from just issuing themselves certificates saying that Joe has said that the private/public key pair they’ve just generated is the correct one for google.com? The certificate is digitally signed using Joe’s SSL Certificates’ private key. So, assuming that the browser has Joe’s SSL Certificates’ public key, and it trusts Joe to only sign certificates that he really knows are OK, it just uses Joe’s public key to validate the signature.
Browsers come with a bunch of public keys installed as ones they should trust (actually, some rely on a list provided by the operating system). They’re called “root CAs”, and in this case, we’re saying that Joe’s SSL Certificates is one of them. In the real world, maybe not every browser in the world does trust the specific issuer who signed your certificate.
What happens under these circumstances is that Joe gets his own certificate. This includes his public key, and is signed by someone else. So, the browser receives your certificate and Joe’s when they visit your website. They check your certificate against Joe’s, using the public key in Joe’s certificate, and then they check Joe’s against the certificate they have stored for whoever signed Joe’s one.
And obviously this can go on and on; perhaps Joe’s certificate was signed by Amy, who your browser doesn’t trust… so your web server has to send your certificate, and Joe’s certificate, and Amy’s certificate, and Amy’s certificate is signed by someone the browser does trust and we’re done.
This could in theory go on pretty much indefinitely, with hundreds of certificates being sent, giving a chain of trust from your certificate up to someone the browser really does trust — that is, back to an issuer and their associated public key that came packaged with Chrome or Firefox or whatever browser is being used. But in practice, chains are normally between two and five certificates long.
So, if you’ve ever set up SSL for a domain on PythonAnywhere or on your own server, now you know what all that stuff with the “certificate chain” or “bundle” was. You were putting together a set of certificates that started with your own one, then went from there across a sequence of signatures and public keys to one that all web browsers trust by default.
Signature hashing algorithms
One thing we’ve glossed over a bit until now is the hashing algorithm. It’s really important that different certificates hash to different numbers. Let’s imagine we had a somewhat naive algorithm:
def hash(certificate): return 4
I could get a certificate issued for my own domain, which would include as its signature the number 4 encrypted by my issuer’s private key. Because I know that every other certificate in the world also hashes to the number 4, I can just change my certificate so that it says that it relates to google.com, keeping the same public key, and it will still pass the signature validation browsers do. This means that if I can somehow trick your computer (through some kind of clever network hackery) into thinking that my website is google.com, then I can present my hacked certificate when you visit, and your browser will accept it and show you a green padlock in the URL bar. This is obviously not a Good Thing.
This is where we can actually start talking about SHA-1. It’s a hashing algorithm designed by the NSA back in 1995. It’s no longer regarded as being very good — initial problems started surfacing in 2005. This is for cryptographic values of “not very good” — it’s still pretty much impossible to produce a valid certificate that would hash to the same value as one that you’re trying to impersonate. But it’s possible in theory, and has been for quite a while, so it’s time to move on to SHA-2. SHA-2 is also an NSA creation — it’s worth noting that the Snowden revelations don’t seem to have done the hashing algorithm’s reputation any harm, and it’s still regarded as the way to go.
(Just to confuse matters a bit, SHA-2 is actually a family of hash functions, called SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224, and SHA-512/256. So if someone is talking about something hashed with SHA-256, they could equally, if less precisely, say that it was hashed with SHA-2. I’ll try to use SHA-2 in the remainder of this blog post to stop my own brain from melting when I reread it…)
Sign it once, sign it twice
So there are different hash algorithms that can be used to sign things. But that obviously could cause problems — given a particular signature, how does the person checking the signature know which one was used? The simple fix is to add an extra field to the signature saying which algorithm was used.
And what if the checker doesn’t know how to perform the particular hash that the signature requires? After all, this is the Internet, and there are computers running software of all different ages knocking around. The answer is that each certificate can have multiple signatures, all using different hashing algorithms but encrypted with the same private key (and so, decryptable with the same public key). It’s simple to do — hash the data once using SHA-1, encrypt that with your private key, and store that as the SHA-1 signature. Then hash the original data again using SHA-2, encrypt the result with the same private key, and then store that as the SHA-2 one.
Once that’s done, a browser trying to validate a certificate can go through the signatures, and find the most secure signature it understands the hashing algorithm for. Then it can check that one and ignore the rest. Old software that doesn’t understand the latest and greatest hashing algorithms has lower security than new software, but it’ll still have something. And new software can stay ahead and always choose the newest algorithm.
So, SHA-1 bad, SHA-2 good. Google quite understandably wanted to reduce the number of sites using certificates using the old, broken encryption. So they decided that when your browser loads a website, it will look along the chain and see if there are any certificates there that are SHA-1 only. If it’s expiring soon (as in, before the end of 2015), they’ll accept it anyway. That means that no-one with an old SHA-1 certificate was forced to upgrade quickly. But if it expires later than that, then they show a “broken security” warning. If you click on that, it tells you that one of the certificates in the chain uses SHA-1 so it’s not secure.
Phew! Finally I can tell you what triggered this whole infodump :-)
We recently got a new certificate for PythonAnywhere. Our current one expires in August 2015, so we needed a new one for another year. I was checking it out prior to pushing it to our live service, and got the “broken security” warning. “Tsk”, I thought, “what a useless certificate issuer we have!” A bit of googling around led me to pages that seemed to be claiming that our issuer had a habit of issuing SHA-1 certs and you had to kick them to get an SHA-2 one. So I sent them a grumpy email asking for an SHA-2 version of our cert, or whichever one in the chain it was. (At this point I didn’t realise that a certificate could have multiple signatures, and — I think — the version of Chrome I was using to explore the certificate chain on the installed certificate on the test servers only showed me the SHA-1 signatures when I checked.)
Then a client provided us with a new cert for their own domain. We installed it, and *bang* — they got the same warning. I let them know about what the problem appeared to me to be. But after a couple of back-and-forwards with their certificate issuers, mediated by them (and I have to thank them for their patience in this) I started doubting myself. My computer was showing the SHA-1 errors in Chrome. A Crunchbang virtual machine I was using, likewise. But the client themselves couldn’t see it. They checked on Firefox, but Mozilla aren’t doing this sunsetting thing, so that was expected. But then they checked in Chrome on Windows, and they didn’t get it. The same Chrome version as I was running, but no warning.
The clincher for me was when my colleague Glenn checked it in his browser, running on Ubuntu, just like me. Same Chrome version… no error. There was obviously something wrong with my own machine! A whole bunch of Googling later and I found this answer to a Server Fault post, by Vincent G.
There’s an Ubuntu library, libnss3, described as “Network Security Service libraries”. In version 3.17.4, there was a fix to a bug described as “NSS incorrectly preferring a longer, weaker chain over a shorter, stronger chain”. It looks like this was pushed live in May.
I use i3 as my window manager, which means that the normal Ubuntu “you have updates you need to install” stuff doesn’t happen, so I need to update my OS manually. It looks like it was a while since I did that… (Cue spearphishing attacks.)
I updated, and suddenly both our certificate and the client’s looked OK. Sincere apologies emailed to both clients and to our respective CAs…
So, just to reiterate what happened… both we and our clients were issued with new certificates. These expired after the end of 2015. Each certificate in the chain up to a root cert was signed with SHA-2 hashing, and also (for backward compatibility) was also signed with SHA-1. When loaded into a Chrome with no buggy libraries, the browser would look along the chain and recognise that every certificate had an SHA-2 signature, so it would decide it was fine. But in my version with the buggy libnss3, it would look along the chain and spot the SHA-1 signatures. It would erroneously decide to ignore the SHA-2 ones, and would report the certificate as broken.
The moral of the story? Keep updating your system. And if something looks broken, check it on as many OS/browser combinations as possible… On the other hand, when
select really is broken, it’s a real pain to debug.