Juniper backdoor originally designed for intel access

Yesterday we highlighted the story about Juniper Networks discovering rogue code that potentially allows outsiders to not only gain control of a target's VPN access system, but also to monitor the traffic passing through that VPN. The likelihood of this being nation-state cyber-espionage increased yesterday with the revelation that the Juniper random number generator (RNG) used was Dual_EC_DRBG, an RNG that has long been seen as having been 'backdoored' by the US National Security Agency ( NSA). Cryptographer Adam Langley has written up the issue in his blog and suggests that the real story is Juniper originally designed the operating system to have what is called a NOBUS-backdoor ('nobody but us', i.e. the NSA), but then decided to "change the locks" on that intelligence community backdoor. What Juniper now seems to have discovered is that another locksmith since decided to change the locks again - without telling them. 

Update: Ralf wrote up some notes from his work. These now include an update themselves with information from Willem Pinckaers that suggests that the presumed Dual-EC output is exposed to the world in Juniper devices.

On Thursday, Juniper announced that some of their products were affected by “unauthorized code in ScreenOS that could allow a knowledgeable attacker to gain administrative access to NetScreen® devices and to decrypt VPN connections”. That sounds like an attacker managed to subvert Juniper's source code repository and insert a backdoor. Of course, any glimpses that we get of these sorts of attacks are fascinating.

Juniper followed up with a slightly more detailed post that noted that there were two backdoors: one via SSH and one that “may allow a knowledgeable attacker who can monitor VPN traffic to decrypt that traffic”. Either of these would be very interesting to a nation-state attacker but that latter—passive decryption of VPN connections—is really in their neighborhood.

So, of course, smarter people than I quickly took to Twitter to pull apart the differences in the fixed firmware versions. Since Twitter conversations are terrible to try and pick apart after the fact, I'm writing down the gist of things here. But I'm just the scribe in this case; other people did the work.

One of the first things that people focused on was a difference to a large, hex value that was visible by just diffing the strings of the two firmwares. That change is interesting not just because it's a large, opaque hex string in a binary, but because of the hex strings that immediately precede it. Specially they were:

FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF : this is the prime order of the underlying field of P-256, a standard elliptic curve.

: this is the prime order of the underlying field of P-256, a standard elliptic curve. FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC : P-256 is typically written in short-Weierstrass form: y 2 =x 3 +ax+b. This is then the a value for P-256.

: P-256 is typically written in short-Weierstrass form: y =x +ax+b. This is then the value for P-256. 5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B : This is the b value for the P-256 equation.

: This is the value for the P-256 equation. 6B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296 : This is the x coordinate for the standard generator of P-256—the starting point for operations on the curve.

: This is the coordinate for the standard generator of P-256—the starting point for operations on the curve. FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551 : This is the number of points on P-256.

So all the values just before the changed one are constants for P-256, suggesting that the changed value is cryptographic too. The obvious, missing value would be the y coordinate for the standard generator. One possibility was that the attack put in the wrong y value. This could put the generator on the wrong curve, say a weaker curve that shares most of the same parameters as P-256 but with a different value for b. But the curve that would have resulted, while weaker, wasn't real-time-passive-decryption weak. Also the replacement value in the fixed version wasn't the standard y value either.

Ralf-Philipp Weinmann was looking at the code itself and found:

That means that the changed value is an x coordinate and that the code was calculating the y value from it given the curve equation. Thus it would only need the x values and the points would always be on the correct curve. So perhaps it's a public key for something?

Changing a public key could easily be a big backdoor, but recall that the result here is somehow passive decryption of VPN traffic. It's unclear how changing a public key could result in passive decryption.

Back at the keyboard, things are making sense again. This will need some digging, but here's a hint: :"EC PRNG KAT failure". — Ralf (RPW) (@esizkur) December 18, 2015

Oh dear. To explain: “EC PRNG” suggests that the value might be a constant in an elliptic-curve based pseudo-random number generator. That could certainly explain how passive decryption of VPN traffic was possible because it brings up memories of Dual-EC. Dual-EC was an NSA effort to introduce a backdoored pseudo-random number generator (PRNG) that, given knowledge of a secret key, allowed an attacker to observe output from the RNG and then predict its future output. If an attacker can predict the output of the PRNG then they can know the keys that one or both sides of a VPN connection will choose and decrypt it. (For more details, see the research paper.)

Indeed, it quickly came to light that Juniper have a page where they say that the VPN devices in question here “do utilize Dual_EC_DRBG, but do not use the pre-defined points cited by NIST”. In short, they used a backdoored RNG but changed the locks. Then this attack might be explained by saying that someone broke in and changed the locks again.

We're not sure that's actually what happened, but it seems like a reasonable hypothesis at this point. If it's correct, this is fairly bananas. Dual-EC is not a reasonable RNG: it's massively larger, slower and more complex than standard RNGs. It's output isn't even very uniform. Huge compromises were made in its design in order to meet its primary objective: to be a NOBUS, passive backdoor. (“NOBUS” is an intelligence community term for “nobody but us”, i.e. other parties shouldn't be able to use the backdoor.) Why would it be used in ScreenOS in the first place?

If nothing else, Juniper deserves credit for being forthcoming that there was a backdoor, and not just quietly rolling out a patch. — matt blaze (@mattblaze) December 18, 2015

Again, assuming this hypothesis is correct then, if it wasn't the NSA who did this, we have a case where a US government backdoor effort (Dual-EC) laid the groundwork for someone else to attack US interests. Certainly this attack would be a lot easier given the presence of a backdoor-friendly RNG already in place. And I've not even discussed the SSH backdoor which, as Wired notes, could have been the work of a different group entirely. That backdoor certainly isn't NOBUS—Fox-IT claim to have found the backdoor password in six hours.