Once, there was an Internet. And it was a happy place with no security concerns whatsoever, because only a dozen or so people got to use it.

That fairy tale is not the world we live in today, and thanks to high profile problems like Heartbleed and Shellshock, more people recognize it. Unfortunately, some of the design ethos from that fantasyland still impacts us. The web isn’t secure for the uses it sees today—and HTTP was never designed to be. SSL, intended to provide a secure connection layer between systems, has evolved through multiple versions into TLS, each attempting to reduce the vulnerabilities of the prior.
The vulnerabilities and problems of HTTPS, while not numberless, are legion. And each of these vulnerabilities presents an opportunity for an adversary to defeat the goals of Internet users—whether they seek financial security, privacy from government surveillance, or network agnosticism.

What is HTTPS, anyway?

HTTPS isn't a standalone protocol; HTTP over TLS is two separate protocols, isolated from one another. The effects of one protocol's actions on another are rarely studied as much as the actual protocols themselves. That isolation has led to vulnerabilities—using compression in HTTP to improve transfer speed is good, except that the secrecy goals of TLS can be subverted through variable-sized content, as in the BREACH security exploit.

Who do you trust?

TLS certificates are issued by certificate authorities (CAs); these CAs sign the certificates that a web site presents to its users to ‘prove’ who they are. You could almost consider them like a driver’s license—issued by some authority. But who are these authorities? They are the dozens of entities—some commercial, some governmental—who are trusted by our browsers. Unlike a driver’s license, any trusted CA can issue a certificate for any website—it’s like having your local library issue an ID card for a Pentagon employee or one government issue certificates for another government’s website.
Illegitimately gaining a trusted certificate can be achieved in at least three distinct paths:

• compromise a CA publishing interface, either directly or by compromising a user’s credentials;
• for Domain Validated certificates, have publication control of the website that the CA can observe (by compromising DNS, the publication interface, or the server directly); or
• by modifying the browser’s list of trusted certificates. This is a common practice in many enterprises, to enable the enterprise to run a CA for their own websites, or to deploy a web filtering proxy. But these CAs are then able to issue certificates to any website.

Once an adversary has a certificate, they merely need to also become a ‘man in the middle’ (MITM), able to intercept and modify traffic between a client and a server. With this power set, they are able to read and modify all traffic on that connection.
Certificate Transparency (CT) is an initiative to begin monitoring and auditing the CAs to determine whether they have issued rogue certificates and to provide browsers an interface to collectively validate certificates. This may lead to a reduction in the number of trusted CAs to only those that don’t behave in a rogue fashion. There is another possible mitigation called DANE (DNSSEC Assertion of Named Entities), where the information about the validity of certificates/authorities for hostnames/domains is published through DNS and signed by DNSSEC, reducing the number of trusted entities who can publish SSL keys.

I can haz TLS?

Until recent versions of TLS that incorporate Server Name Indication (SNI), a server was required to first present the certificate that declared for which hosts it was able to conduct an HTTPS session. This meant that no IP address could have more than one certificate. In HTTP, a single IP address can, through virtual hosting, have many hostnames, as the client will signal to the server which hostname from which it would like a web page. While the advent of multi-domain certificates has allowed multiple hostnames, it hasn’t provided the freedom to have ‘unlimited’ TLS-secured hostnames. SNI is an extension to TLS that provides this capability, allowing a browser to tell a server what certificate it would like to be presented.
But SNI isn’t supported by all browsers—most notably, Windows XP and early versions of Android. The former is on its way out, but the latter is still being deployed on lower-end feature phones, especially in the developing world. And unfortunately, there are no good strategies for supporting both SNI and non-SNI clients available today. Until either SNI is fully supported, or IPv6 adoption achieves critical mass, many websites will not be able to have HTTPS.

TLS is only Transport Layer Security

Often, a client isn’t talking directly to the content provider—there is some other entity in the middle. It might be an enterprise proxy; it might be a network operator gateway; it might be a content delivery network. In these cases, the TLS connection only provides secrecy on the first leg—the client has to hope that the secrecy is preserved across the public Internet. Few of the mid-point entities provide any assertions about how they’ll handle the security of the forward connections that were prompted from a TLS connection; some even advertise the convenience of having the ‘flexibility’ to downgrade from HTTPS to merely HTTP.
Until HTTP contains a signaling mechanism through which the mid-points can communicate about the TLS choices they’ve made, a client will not know whether a TLS connection is robust (or even exists!) across public links.

TLS isn’t privacy

TLS provides encryption for the information contained inside a request, thus hiding the specific content you’re engaging with. It’s useful for hiding the specific details of similarly shaped data, like social security numbers or credit cards; but very poor at hiding things like activism or research. The design of the system doesn’t conceal the ‘shape’ of your traffic—and the Wikipedia pages for Occupy Central have a different shape than the shape of the Wikipedia page for the Large Hadron Collider. It also doesn’t prevent traffic analysis—while the contents of a user-generated video may be secret, the identity of the systems (and hence the users) that uploaded and downloaded it aren’t. Some privacy systems like Tor may provide useful protections, but at the cost of performance.

Don’t trust the lock

All together, the architecture of TLS and HTTPS doesn’t provide enough safety against all adversaries in all situations. There are some steps underway that will improve safety, but many hazards will still remain, even absent the highly publicized implementation defects. But these steps will increase the cost for adversaries, sometimes in measurable and observable ways.
That icon lock in your browser is useful for securing your commerce and finances, but be cautious about trusting it with your life.

This article originally appeared in The Internet Monitor 2014: Reflections on the Digital World.

SSL is dead, long live TLS

An attack affectionately known as “POODLE” (Padding Oracle On Downgraded Legacy Encryption), should put a stake in the heart of SSL, and move the world forward to TLS. There are two interesting vulnerabilities: POODLE, and the SSL/TLS versioning fallback mechanism. Both of these vulnerabilities are discussed in detail in the initial disclosure, as well as a history lesson in Daniel Franke’s How Poodle Happened.

POODLE

POODLE is a chosen-plaintext attack similar in effect to BREACH; an adversary who can trigger requests from an end user can extract secrets from the sessions (in this case, encrypted cookie values). This happens because the padding on SSLv3 block ciphers (to fill out a request to a full block size) is not verifiable - it isn’t covered by the message authentication code. This allows an adversary to alter the final block in ways that will slowly leak information (based on whether their alteration survives verification or not, leaking information about *which* bytes are interesting). Thomas Pornin independently discovered this, and published at StackExchange.


On its own, POODLE merely makes certain cipher choices no longer as trustworthy. Unfortunately, these were the last ciphers that were even moderately trustworthy - the other ciphers available in SSLv3 having fallen into untrustworthiness due to insufficient key size (RC2, DES, Export ciphers); cryptanalytic attacks (RC4); or a lack of browser support (RC2, SEED, Camellia). The POODLE attack takes out the remaining two (3DES and AES) as trustworthy (and covers SEED and Camellia as well, so we can’t advocate for those).

One simple answer is for all systems to stop using these cipher suites, effectively deprecating SSLv3. Unfortunately, it isn’t that easy - there are both clients and servers on the Internet that still don’t support the TLS protocols or ciphersuites. To support talking to these legacy systems, an entity may not be able to just disable SSLv3; instead they’d like to be able to talk SSLv3 with those that only support SSLv3, but ensure that they’re using the best available TLS version. And that’s where the next vulnerability lies.

SSL/TLS Version Selection Fallback

We’ve probably all encountered - either in real life or in fiction - two strangers attempting to find a common language in which to communicate. Each one proposes a language, hoping to get a response, and, if they fail, they move on to the next. Historically, SSL/TLS protocol version selection behaved that way - a client would suggest the best protocol it could; but if it had an error - even as simple as dropped packets - it would try again, with the next best version. And then the next best … until it got to a pretty bad version state.

This is a problem if there’s an adversary in the middle, who doesn’t want you picking that “best” language, but would much prefer that you pick something that they can break (and we now know that since all of the ciphers available in SSLv3 are breakable, merely getting down to SSLv3 is sufficient). All the adversary has to do is to block all negotiations until the client and server drop down to a SSLv3.

There is a quick fix, to merely disable SSLv3. This means that if an adversary succeeds at dropping down, the connection will fail - the server will think it’s talking to a legacy client, and refuse the connection. But that’s merely a solution for the short term problem of POODLE, because there are other reasons an adversary might want to trigger protocol version downgrade today (e.g., to eliminate TLS extensions) or in the future (when TLS1.0 ciphers are all broken). A longer term fix is the TLS Signaling Cipher Suite Value (SCSV). This is a new “cipher suite,” that encodes the best protocol version that the client would have liked to use. This is carried as a new cipher suite; servers that support SCSV don’t actually treat it as a cipher to choose from (what cipher suites normally list), instead, if the value carried in the SCSV is *worse* than the best protocol version that the server supports, it treats this connection as one that has been attacked, and fails the connection. A client only sends an SCSV value if it has already been forced to version downgrade; it’s a way of signaling “I tried to connect with a better protocol than I think you support; if you did support it, then somebody is messing with us.”

So POODLE should put a stake most of the way through SSL’s heart, and SCSV will help us keep it there. Long live TLS.

Crossposted on the Akamai Blog.

Kacy Catanzaro is the first woman to qualify for the American Ninja Warrior Finals. Her qualifying run in Dallas is not merely an athletic marvel, but also demonstrates a useful set of skills and practices for anyone tackling large and complex tasks.

Consider the structure of the course: a set of challenges, each one generally more difficult than the one before it. And when each challenge is completed, you move on to the next one. Note that the course isn’t a single challenge (although many other competitors approached it as a single challenge), and it is a lot like management - especially incident-based management. We often work on an urgent project, get it complete, and then move on to the next project. Or worse - the project extends for a long time, and we *don’t* treat it as a series of challenges. Sometimes, we use similar skills, competencies, and people, and wear them out. (Go watch some other competitors, and see how often their runs come to an end because of certain overused muscle groups giving out.)

Let’s consider Kacy’s approach. After each challenge, she undergoes some subset of the following ritual: celebration, gratitude, recovery, and preparation.

Celebration

It’s important when we finish some task to celebrate. To acknowledge that we just did a hard thing, and defeated it. This gives us mental closure (“I totally beat that!”), as well as builds up our energy level (“I beat this hard thing, the next hard thing can’t be that bad”). It gives us the mindset of winners (“I get things done”) instead of the oppressed (“I have a never-ending set of challenges”). You can see Kacy celebrate after clearing each challenge - even just a little fist-pump acknowledges her success at the previous challenge and gets her ready to face the next one.

Gratitude

Even when we complete a project “on our own,” we often receive a lot of help that can be easy to overlook - people helped train us, took work off our plate, cheered us on. And when we don’t do the work on our own - when many people contributed to an accomplishment - we should express our gratitude. We should remind them that their work is valued, and that when they do work on our behalf, we appreciate it. There is a shortage of gratitude in the world; recipients of gratitude will react strongly and positively to the feedback. You see Kacy thanking the crowd and her boyfriend for their support after many of the challenges.

Recovery

Challenges are *hard*; if they were easy, we’d call them cakewalks. We use (and abuse) the resources at our disposal - our bodies, our coworkers, our families, and our systems. After taking advantage of these things, we need to acknowledge the damage, and take even small steps to repair the damage. That might be taking a day off, taking action to reconnect with people we’ve ignored, taking care of ongoing maintenance; or merely relaxing for a while. Kacy is focused on finishing, and she takes the time to let overtaxed muscles rest and recover before asking more of them.

Preparation

After finishing a challenge, we will often face another challenge. It’s not often the same challenge, even if it looks a bit similar. Or it may look wildly different, but be addressable with strikingly similar strategies. Either way, we need to take the time to think through how we’re going tackle this challenge, and then go execute. Watch how Kacy plans her approach to the next challenge before she tackles it, rather than jumping into it blindly.

Life will present us with many sequences of challenges, some masked as single large challenges, others clearly separated. Taking the time to recharge ourselves and our fellow participants will increase not only our effectiveness at any given task, but also our ability to continue to efficiently operate over time. These four rituals are an easy rubric to apply in almost any situation, and, like Kacy, they can enable us to overcome the obstacles in our path.

Despite the time and inconvenience caused to the industry by Heartbleed, its impact does provide some impetus for examining the underlying certificate hierarchy. (As an historical example, in the wake of CA certificate misissuances, the industry looked at one set of flaws: how any one of the many trusted CAs can issue certificates for any site, even if the owner of that site hasn't requested them to do so; that link is also a quick primer on the certificate hierarchy.)

Three years later, one outcome of the uncertainty around Heartbleed - that any certificate on an OpenSSL server *might* have been compromised - is the mass revocation of thousands of otherwise valid certificates.  But, as Adam Langley has pointed out, the revocation process hasn't really worked well for years, and it isn't about to start working any better now.

Revocation is Hard

The core of the problem is that revocation wasn't designed for an epochal event like this; it's never really had the scalability to deal with more than a small number of actively revoked certificates.  The original revocation model was organized around each CA publishing a certificate revocation list (CRL): the list of all non-expired certs the CA would like to revoke.  In theory, a user's browser should download the CRL before trusting the certificate presented to it, and check that the presented certificate isn't on the CRL.  In practice, most don't.  Partly because HTTPS isn't really a standalone protocol: it is the HTTP protocol tunneled over the TLS protocol.  The signaling between these two protocols is limited, and so the revocation check must happen inside the TLS startup, making it a performance challenge for the web, as a browser waits for a CA response before it continues communicating with a web server.

CRLs are a problem not only for the browser, which has to pull the entire CRL when it visits a website, but also for the CA, which has to deliver the entire CRL when a user visits one site.  This led to the development of the online certificate status protocol (OCSP).  OCSP allows a browser to ask a CA "Is this specific cert still good?" and get an answer "That certificate is still good (and you may cache this message for 60 minutes)."  Unfortunately, while OCSP is a huge step forward from CRLs, it still leaves in place the need to not only trust *all* of the possible CAs, but also make a real-time call to one during the initial HTTPS connection.  As Adam notes, the closest thing we have in the near term to operationally "revocable" certs might be OCSP-Must-Staple, in which the OCSP response (signed by the CA) is actually sent to the browser from the HTTPS server alongside the server's certificate.

One Possible Future

A different option entirely might be to move to DANE (DNSSEC Assertion of Named Entities).  In DANE, an enterprise places a record which specifies the exact certificate (or set of certificates, or CA which can issue certificates) which is valid for a  given hostname into its DNS zone file.  This record is then signed with DNSSEC, and a client would then only trust that specific certificate for that hostname. (This is similar to, but slightly more scalable than, Google's certificate pinning initiative.)

DANE puts more trust into the DNSSEC hierarchy, but removes all trust from the CA hierarchy.  That might be the right tradeoff.  Either way, the current system doesn't work and, as Heartbleed has made evident, doesn't meet the web's current or future needs.

(Footnote:  No conversation made herein around Certificate Transparency, or HSTS, both of which are somewhat orthogonal to this problem.)

This entry crossposted at blogs.akamai.com.

Context: Keynoting at ShowMeCon.

Here are my integrated slides (in PDF, each build its own slide) for my combined talk on how to apply some of the knowledge and research from the world of cognitive science to organization thinking, especially in the context of a security profession. This reading list still applies, to which I’ve added Traffic, by Tom Vanderbilt.

In brief: We often model other humans as one-dimensional caricatures - because it’s efficient for our brain to do so; because it’s hard to think in a different mode than our own; because we don’t see ourselves as the villain in our own story. To be effective partners in our organizations, we have to understand not only how this affects other people, but how it affects ourselves; and then rewire our behavior to move past these caricatures and have dialogues that change behavior, not just reinforce stereotypes.

This morning, I sat in on a panel titled “Closing the Cybersecurity Skills Gap.” Javvad Malik has curated a collection of tweet observations; I thought I’d expand and share a few of my own observations:

The “skills gap” that recruiters see isn’t the right one. Often, we hear about the skills gap from recruiters in the context of “I couldn’t find candidates that met your requirements.” But if the requirements included, “15 years of experience securing Windows7,” we don’t have a skills gap, we have a problem writing job descriptions.

An often missing skill is relating to the business. Our jobs as security professionals often puts us at odds with the business. Why? Because we strive to be the “conscience of the business” and stop it from taking certain risks. Our job is to help the business take risks - but to do so more wisely, through actionable knowledge. Since our business partners are the ones making the decisions to take risks, they are the ones who need to understand risks that impact their decisions.

Think systematically. Many of our training programs focus on providing building block skills; this gives people hammers (so that all problems look like nails). An underdeveloped skill is the ability to think holistically about systems.

Problem solving is a needed skill. Not simply identifying how to solve a problem; actually digging in and solving a problem is a critical skill. It might require building servers; installing applications; designing processes; analyzing data, and a dozen other sundry capabilities.

Communications and translations are key. Every job function has its own jargon - and being able to communicate in the jargon of the business is a critical capability. Having the ability to quickly learn about how current events or new technologies will affect your business, and then provide coherent summaries and advice to the business will be extremely helpful.

Be kind. The security profession has often celebrated being unkind and hurtful to each other and our business partners (think of The Wall of Sheep). Instead, we should be trying to understand them; to be helpful to them; and to understand how we can improve their world.

And some thoughts from prior blogposts: Certification isn’t a marker of mastery. Think about measuring value. Are you applying your skills to just compliance, or solving security problems like awareness training in novel ways?

Context: Tuesday, February 25th, I’m presenting “Cognitive Injection: Reprogramming the Situation-Oriented Human OS” at RSAC in Moscone West, Room 3005 at 4 pm (Pacific). My slides are here.

I’ve formed my opinion about how the human brain works with the assistance of some great contributors. Some of them are humans I hang out with, but many of them are authors and researchers; in the interest of helping others come to the same, or better, understanding, here’s a short reading list:

• Daniel Kahneman; Thinking, Fast and Slow
• James Reason; Human Error
• Atul Gawande; The Checklist Manifesto
• Christopher Chabris and Daniel Simons; The Invisible Gorilla
• Sam Peltzman,;“The Effects of Automobile Safety Regulation”, Journal of Political Economy, 1975. (see also: The Peltzman Effect)
• Tom Vanderbilt; Traffic