12 dark secrets of encryption

Encryption is fast becoming developer’s go-to solution for whatever data privacy or security worry ails you. Afraid of putting your credit card into a web form? Don’t worry. We’re using encryption. Unsure whether a website is authentic? Encryption has your back. The good news is, encryption algorithms do work some of the time. The math offers some protection against eavesdropping and a solid foundation for trust.

But all magic has its limits and the tricky thing with encryption is that it can be impossible to be certain where those limits are. The math can be so awe inspiring that we can only sit and stare with our mouths agape. It’s easy to get lost and just resign yourself to trusting it will all work out when the calculations are so complex.

In the end, with encryption, the best we can do is manage our expectations and our understanding. We can’t live without encryption, but we can’t assume that it will work as easily or as reliably as a light switch.

So here are a dozen dark secrets of encryption to keep in mind when looking for solutions to intractable problems in your information architecture.

We don’t understand it

Most of the power of encryption relies on the fact that we don’t know enough about the math involved to reverse it. We know how to compute the functions but not how to invert them. We can multiply and multiply large numbers but we can’t compute the logarithm. In other words, we don’t know the math backwards and forwards, we only know it forwards. When a bunch of smart people can’t figure out how to go backwards, we call it a day, shrug and embrace the algorithms. It’s the best we can do. The most commonly deployed algorithm depend on the fact that no one has publicly figured out any way to attack them.

Our estimates are just estimates

Some mathematicians have found basic algorithms for attacking the well-known encryption functions but they’re all much too slow to break the encryption with real keys. The algorithms work only with small numbers and their speed increases exponentially with the size of the problem. These algorithms generate all of those eye-popping estimates about how it would take billions of quadrillions of quintillions of bazillions of years to break. That sounds reassuring, but it’s like a neophyte golfer saying it could take bazillions of years of golf to hit a hole in one. That may be true for the neophyte, but not for the pros who hit them regularly. In the world of encryption, we’re all neophytes tossing off estimates.

Proofs are partial

Some of the most dedicated scientists and mathematicians work hard at providing a “proof” of their algorithm. These chains of well-vetted logical steps help us understand the strength of the encryption algorithm but that’s not the same thing as a guarantee that your data will be safe. The proofs only shine light on some of the job and there are always monsters hiding in the darkness. In most of the cases (except one-time pads), the proofs don’t cover everything and rely on assumptions about how some problems are really hard. That may be true in the past, but that’s not a guarantee for the future.

We can’t measure strength

Security technology sales teams like to toss around terms like “bank-grade” or mix in numbers like 1024-bit but the reality is that we don’t have a good way to do more than guess at the strength of the algorithms. Is 2048-bit twice as good as 1024-bit? Or is the difference astronomical?

The research only begins to scratch the surface. Some of the attacks work only on a narrow range of messages and then only when a million stars align. Other attacks open up everything. We can look at how these attacks work in the lab, but it’s hard to extend the work to how they might threaten our data.

The future of computing is a mystery

No one knows if quantum computers will ever be built with enough power to tackle meaningful problems, but we know people are trying and putting out press releases about making progress. We also know that if the quantum machines appear, some encryption algorithms will break right open. Many encryption scientists are working hard at building new algorithms that can resist quantum computers, but no one really knows the extent of a quantum computer’s powers. Will it be limited to the known algorithms? Or will someone find another way of using the quantum computer to break all of the new algorithms.

Encrypted data is not safe data

Sometimes encryption works too well. It locks up data inside a mathematical vault and then, somehow, the key disappears. It’s easy to back up encrypted data but it’s a challenge to back up keys and passwords. If you’re too careful, you may end up locking yourself out of the data. If you die unexpectedly, no one may ever figure out the password or missing key. Encrypted data is not the same as safe data. Encrypted data is fragile.

Encryption is easy. Key management is hard

Some encryption standards are well-trusted because they’ve been developed through a grueling, multi-year process. It’s easy enough to grab one from an open source library and be confident that the encryption will be secure.

The hard part, though, is distributing the keys between everyone who needs them. Symmetric systems like AES require that the key travel separately through a secure channel, but if we had a secure channel we wouldn’t need encryption. If we plan ahead, we can usually get the right keys to the right people.

Public key systems have made it easier for people to set up a secure path without meeting in advance, but they have their own problems. How do you know you’re using the right public key for a person? Is the certificate authority trustworthy? There’s still a need for leaps of faith in the system.

The support code is fragile

Key distribution isn’t the only facet that creates nightmares for encryption developers. Many parts of the algorithm can leak information, sometimes deliberately. It’s common, for instance, to mix in random numbers with a message, but finding these random numbers can be tricky. Some of the so-called random number generators have flaws that make them far from random, and their predictability could be used to guess the key and break the message. The encryption algorithm is only part of the game.

Shared hardware is dangerous

Lately more and more code is running in the cloud because of the cost and flexibility. The problem is that no one knows what the neighbors who are sharing your machine are doing.  There are numerous vulnerabilities that allow one piece of software to peek into the memory of another piece on the same computer. The operating system developers try to stop it, but new holes like RowHammer appear frequently. It seems like there are dozens of potential attacks on machines in the cloud and we’re just beginning to realize just how much we need to worry about it.

Hacked hardware is impossible to detect

Have you looked at the transistors on your chips? Have you made sure they’re already loyal to you, the software developer? Some clever hackers reverse-engineered one chip and discovered it had a hidden and undocumented god mode that was triggered by a random string of bytes. Who put it there? No one is rushing to take credit.

Digital signatures just shift responsibility

The mathematics behind some of the best digital signature algorithms is beguiling and hypnotizing. Only the owner of the private key can perform the computations that produces a legit digital signature. That sounds much, much better than a handwritten signature, which can usually be forged by a fourth grader who needs a parent to sign a bad test.

But is it really? The private keys aren’t bound to people. A digital signature can only be produced by someone with access to the private key. That may be the rightful owner, or it may be someone who broke into the computer or shoulder-surfed a password or inserted a key logger or found a way to get the key. If your key is on your computer and your computer is on the internet, that could be anyone in the world who is also connected to the internet.

Scientists are trying hard to build secure hardware and strong solutions but they only make the job more difficult for the attackers. The wonderful math is easily undermined by common frailties.

Not everyone is talking

Some mathematicians and experts on cryptography like to talk publicly about the technology. Others don’t say a thing. We don’t even know how many silent ones are out there.

It’s really a miracle that society has developed as much knowledge of codes and ciphers as we have. The more we use the technology, though, the greater the incentive to keep quiet about any weakness. When real money and real secrets are flowing through the encryption-armored tubes of the internet, well, the knowledge about any chink in the armor becomes more valuable. In other words, the more we use encryption, the deeper and darker the secrets grow.

More on IT security:

• The new CIO security priority: Your software supply chain
• Why IT leaders are putting more business spin on security spend
• Security vs. innovation: IT’s trickiest balancing act
• 10 critical security skills every IT team needs
• How to measure cybersecurity effectiveness — before it’s too late
• 10 ways you’re failing at IT audits