9 ways developers can rebuild trust on the Internet
- 23 July, 2015 02:02
The Internet is a pit of epistemological chaos. As Peter Steiner posited -- and millions of chuckles peer-reviewed -- in his famous New Yorker cartoon, there's no way to know if you're swapping packets with a dog or the bank that claims to safeguard your money. To make matters worse, Edward Snowden has revealed that the NSA may be squirreling away a copy of some or all of our packets, and given the ease with which it can be done, other countries and a number of rogue hacker groups may very well be following the NSA's lead.
Yet we keep dumping our data into the routers, blithely assuming it will all work out. When it doesn't, well, the trouble is manageable. Hackers may be rooting around in federal computers, stealing copies of your taxes, but until they start paying your taxes too, it probably won't make much difference. When someone stole my credit card to buy an iPad at Office Depot, the credit card company covered the loss. It's easy to be lulled into a false sense of security like this.
Though most of us have thus far gone unscathed by the Internet's chaos and lack of trust, that doesn't mean we should continue to throw caution to the wind. Not only will fraudsters grow bolder, but the deeper social costs can be staggering. After all, we all must shoulder the cost of fraud through higher prices that hide bigger transaction fees. The gradual erosion of trust hurts us all.
We may not be able to wave a wand and make the Internet perfect, but we can certainly add features to improve trust on the Internet. To that end, we offer the following nine ideas for bolstering a stronger sense of assurance that our data, privacy, and communications are secure. Fixing the Internet may be a lofty (and likely unattainable) goal, but if we each consider ways of adding security to our current projects, we'll slowly start making the Internet a more trustworthy place for all.
Add public keys to major services
Facebook works hard to make sure its users are real people who are using their real names. Given the scale of the endeavor and the nature of people, we can't assume that Facebook has been completely successful, but its long, hard push to build trust in the names on its users' accounts can help the Internet at large.
The best news of this year may be that Facebook is going to allow its users to distribute their PGP public key through Facebook's system. Anyone who wants to email a person via PGP will soon be able to go to Facebook, download the person's public key, and start a secure communication immediately.
This process won't be perfectly secure for many reasons, but it's more secure than using the less guarded public key repositories, and it may be more secure than trusting a random Web page to deliver the correct public key. The last time I checked, there were some keys affiliated with my name on public PGP servers that had nothing to do with me. Facebook is definitely a step up from the volunteer services running on random servers.
We will still need to worry about fake accounts and the security of the link between Facebook and us. However, there's no doubt that a steady stream of status updates from a person you know makes it easier to trust the key.
Will other services start distributing public keys? Will they start building a web of trust? Banks and credit unions would be good starts. The tellers and the branches already know their regulars, and they could add trust to the public key repositories. Schools and universities that know their students for some time might be another option. Anything that can move us closer to the web of trust that PGP creator Phil Zimmerman imagined so long ago would be good for everyone.
Build better random number generators
All of the encryption in the world can't help you if the attackers are able to guess your keys. One of the traditional ways to prevent this is to use random keys chosen by a random number generator. But can this random number generator be trusted?
This isn't merely a theoretical attack. After two Microsoft researchers discovered a potential backdoor in Dual_EC_DRBG (Dual Elliptic Curve Deterministic Random Bit Generator) in 2007, the industry stopped using it as frequently. Finally, after years of questioning, the National Institute of Standards and Technology stopped supporting the algorithm in 2014.
Still, it can be difficult to find backdoors and dangerous to assume that good researchers will take up the task. How can we be sure our random number generators are safe? By increasing the complexity using a cryptographically secure hash function to further scramble the random values produced by the generator, for example.
Any scrambling could also add extra data that would be hard for an attacker to control -- for example, the exact time or some global value downloaded from the Web, such as the current hash at the top of the bitcoin block chain. This would prevent an attacker from controlling the inputs to the random number generator.
As more and more algorithms use encryption, we need more random keys than ever. Assuring a stable, non-guessable mechanism for generating random keys will go a long way to creating a strong foundation.
Expand trusted hardware
Given the layers of software and the complexity of the modern computer, it's unreasonable to imagine that they can be secured. There are too many potential backdoors to assume that our desktop machines, our smartphones, or even our printers can stay in our complete control.
The research community has long experimented with creating special, small computers with one job. Some would compute a special login once, and others would compute a digital signature. A person's private key could be locked inside a chip, and it would be difficult to extract the secret data. While it may never be possible to prove that the information remains safe, the device could have a few reasonable defenses that would limit the ability to attack. It could, for instance, have a mechanical switch so that it couldn't be turned on secretly. It might also refuse to sign more than one value for every time the switch is enabled.
If everyone carried such a small, trusted device with them, it would make it possible for people to create digital signatures that are much easier to trust. While loss and compromise will still be a problem, the widgets would still boost the level of trustworthiness of the Internet.
Add Merkle trees to the file system
Digital files are notoriously easy to change. While paper records will usually reveal our attempts at tampering, digital files can be changed to say whatever we want. To make matters worse, most file systems aren't very careful about protecting the records of when changes are made. Good hackers will not only change the file, but also backdate the records to show that no changes were made.
The simplest way to detect changes is to use a cryptographically secure hash function, a value that acts like a checksum for files that is hard to forge. Any change in the data will be reflected in the hash value, and it will be practically impossible for someone to change the file in a way that the hash value doesn't shift.
When files change over time, the sequence of hash values can itself be hashed together using a Merkle tree. This gives us some assurance that we know the history of the files, including when they changed. Computing good hash values like this is already part of the Git protocol. The more we can move these ideas into the general file system, the more we can have some assurance that files are accurate. The system may only be able to detect that changes were made, not actually fix them all of the time, but this is still better than not knowing anything at all.
Build more block chains and extend them for others
The bitcoin ecosystem is intriguing for many political and social reasons that often overshadow the block chain at the core. People love to speculate as to whether bitcoin will overthrow the central banking system or whether it will enable a lawless, anonymous criminal world. Whatever the answer to those questions, it's important not to let the speculation distract us from the fact that the block chain can add stability and trust to the Internet.
At the core, bitcoin is a centralized ledger that records transactions in a way that's very hard, if not practically impossible, to change. The entries in the ledger generally record who transfers a bitcoin to whom, but there's no reason why it can't be used to fix other data into virtual concrete. If a student turns in a paper, he or she could also record a hash of the document in the block chain. If the paper were to be lost in a spam filter or some other failure, the student could still prove that the paper was submitted at a certain time.
There are a million different opportunities like this to add trust to the Internet by recording values in case anyone doubts that they existed at a certain time and a number of bitcoin startups are exploring how to commercialize them. Despite numerous issues with the concentration of the bitcoin mining world and the high cost of running the block chain, the technology at its core is solid and useful for so much more beyond mere monetary transactions.
Add chaining to Internet interactions
One of the simplest parts of the Internet, the basic HTTP call, does little more than deliver a pile of bits. The HTTPS adds a layer of security that can keep out casual eavesdroppers and flag changes, but it can be expensive to use for all interactions.
A simpler solution is to compute a Merkle tree for all interactions. While not all HTTP traffic falls in a simple ordered list that's easy to hash up into a tree, much of it does. The confusion that comes from the barrage of AJAX calls from some pages can be simplified with small changes to the architecture.
Build out cross-linked certified websites
The basic Git repository provides more than a place to store files. The protocol for saving files and pushing them into other repositories also watches for tampering by computing a SHA-1 hash of all files when they're committed.
But why stop with one repository? Why not swap digital signatures or hash values with other repositories and spread out the network of trust?
The Inter Planetary File System is one experiment that's trying to turn the Web into one big, connected file system. We need to explore more ways to link the information between websites. The curators can work together to build a web of trust between the sites.
Add homomorphic encryption
Servers can store information in ways that are both encrypted and still useful. In other words, the server can continue to store data without compromising user privacy. I detailed some simple versions in my book "Translucent Databases."
In the past few years, there has been great excitement about a wide range of theoretical approaches to the problem of working with data in encrypted form. The databases can sort or search through large collections of personal information without actually holding the unencrypted versions. They can calculate without understanding the underlying information.
Computing with data that you can't see or read may sound a bit like magic, but we already have several good practical solutions. The best may be the Unix password file, which stores a cryptographically secure hash of the password instead of the password itself. When someone logs in, the system can hash the incoming string and compare it to the value in the database. But anyone who gains access to the password file can't figure out the real password because the file only stores the hashed version.
The new approaches are much more ambitious and, alas, far from practical. Some can take years to solve very simple arithmetical challenges, but they are getting better rapidly. More research is necessary, but this remains an exciting solution that promises to make it simpler for companies to do intelligent things with databases and not worry about people's privacy.
It seems silly to end with the biggest, simplest solution, but adding more encryption makes eavesdropping that much harder. A number of prominent sites like Google, Facebook, and Apple are turning on SSL encryption by default, and other sites can follow their lead. The overhead of adding SSL to all traffic is more manageable.
There are a number of other standards that can add encryption. Both IPSec and TLS will do a good job of encrypting the packets between client and server. These algorithms, though, still trust the server, a solution that works for some services but is far from ideal for tasks where the server is an intermediary.
Integrating end-to-end encryption tools with email and chat products is essential for boosting the basic security of our communications. It can be subverted at the server and deep in the OS, but it still is the simplest way to help people trust that the bits they ship across the Internet remain safe and in their control.