Twitter can probably obtain your private keys, and admit that they can MITM you and have full access to your metadata.
[S]omeone can put in some (not all that much, really) effort to obtain your private key and render it all pointless.
[T]here’s no out of band mechanism to … verify the authenticity of … [the] public key at present. Twitter can simply give you a public key where they control the private key, decrypt the message, and then reencrypt it with the intended recipient’s key and pass it on.
And the server knows who and when you’re messaging even if they haven’t bothered to break your private key, so there’s a lot of metadata leakage.
1 Like
For more context:
Part 1: mjg59 | Failing upwards: the Twitter encrypted DM failure
text
Almost two years ago, Twitter launched encrypted direct messages. I wrote about their technical implementation at the time, and to the best of my knowledge nothing has changed. The short story is that the actual encryption primitives used are entirely normal and fine - messages are encrypted using AES, and the AES keys are exchanged via NIST P-256 elliptic curve asymmetric keys. The asymmetric keys are each associated with a specific device or browser owned by a user, so when you send a message to someone you encrypt the AES key with all of their asymmetric keys and then each device or browser can decrypt the message again. As long as the keys are managed appropriately, this is infeasible to break.
But how do you know what a user’s keys are? I also wrote about this last year - key distribution is a hard problem. In the Twitter DM case, you ask Twitter’s server, and if Twitter wants to intercept your messages they replace your key. The documentation for the feature basically admits this - if people with guns showed up there, they could very much compromise the protection in such a way that all future messages you sent were readable. It’s also impossible to prove that they’re not already doing this without every user verifying that the public keys Twitter hands out to other users correspond to the private keys they hold, something that Twitter provides no mechanism to do.
This isn’t the only weakness in the implementation. Twitter may not be able read the messages, but every encrypted DM is sent through exactly the same infrastructure as the unencrypted ones, so Twitter can see the time a message was sent, who it was sent to, and roughly how big it was. And because pictures and other attachments in Twitter DMs aren’t sent in-line but are instead replaced with links, the implementation would encrypt the links but not the attachments - this is “solved” by simply blocking attachments in encrypted DMs. There’s no forward secrecy - if a key is compromised it allows access to not only all new messages created with that key, but also all previous messages. If you log out of Twitter the keys are still stored by the browser, so if you can potentially be extracted and used to decrypt your communications. And there’s no group chat support at all, which is more a functional restriction than a conceptual one.
To be fair, these are hard problems to solve! Signal solves all of them, but Signal is the product of a large number of highly skilled experts in cryptography, and even so it’s taken years to achieve all of this. When Elon announced the launch of encrypted DMs he indicated that new features would be developed quickly - he’s since publicly mentioned the feature a grand total of once, in which he mentioned further feature development that just didn’t happen. None of the limitations mentioned in the documentation have been addressed in the 22 months since the feature was launched.
Why? Well, it turns out that the feature was developed by a total of two engineers, neither of whom is still employed at Twitter. The tech lead for the feature was Christopher Stanley, who was actually a SpaceX employee at the time. Since then he’s ended up at DOGE, where he apparently set off alarms when attempting to install Starlink, and who today is apparently being appointed to the board of Fannie Mae, a government-backed mortgage company.
Anyway. Use Signal.
Part 2: mjg59 | Twitter's new encrypted DMs aren't better than the old ones
text
(Edit: Twitter could improve this significantly with very few changes - I wrote about that here. It’s unclear why they’d launch without doing that, since it entirely defeats the point of using HSMs)
When Twitter[1] launched encrypted DMs a couple
of years ago, it was the worst kind of end-to-end
encrypted - technically e2ee, but in a way that made it relatively easy for Twitter to inject new encryption keys and get everyone’s messages anyway. It was also lacking a whole bunch of features such as “sending pictures”, so the entire thing was largely a waste of time. But a couple of days ago, Elon announced the arrival of “XChat”, a new encrypted message platform built on Rust with (Bitcoin style) encryption, whole new architecture. Maybe this time they’ve got it right?
tl;dr - no. Use Signal. Twitter can probably obtain your private keys, and admit that they can MITM you and have full access to your metadata.
The new approach is pretty similar to the old one in that it’s based on pretty straightforward and well tested cryptographic primitives, but merely using good cryptography doesn’t mean you end up with a good solution. This time they’ve pivoted away from using the underlying cryptographic primitives directly and into higher level abstractions, which is probably a good thing. They’re using Libsodium’s boxes for message encryption, which is, well, fine? It doesn’t offer forward secrecy (if someone’s private key is leaked then all existing messages can be decrypted) so it’s a long way from the state of the art for a messaging client (Signal’s had forward secrecy for over a decade!), but it’s not inherently broken or anything. It is, however, written in C, not Rust[2].
That’s about the extent of the good news. Twitter’s old implementation involved clients generating keypairs and pushing the public key to Twitter. Each client (a physical device or a browser instance) had its own private key, and messages were simply encrypted to every public key associated with an account. This meant that new devices couldn’t decrypt old messages, and also meant there was a maximum number of supported devices and terrible scaling issues and it was pretty bad. The new approach generates a keypair and then stores the private key using the Juicebox protocol. Other devices can then retrieve the private key.
Doesn’t this mean Twitter has the private key? Well, no. There’s a PIN involved, and the PIN is used to generate an encryption key. The stored copy of the private key is encrypted with that key, so if you don’t know the PIN you can’t decrypt the key. So we brute force the PIN, right? Juicebox actually protects against that - before the backend will hand over the encrypted key, you have to prove knowledge of the PIN to it (this is done in a clever way that doesn’t directly reveal the PIN to the backend). If you ask for the key too many times while providing the wrong PIN, access is locked down.
But this is true only if the Juicebox backend is trustworthy. If the backend is controlled by someone untrustworthy[3] then they’re going to be able to obtain the encrypted key material (even if it’s in an HSM, they can simply watch what comes out of the HSM when the user authenticates if there’s no validation of the HSM’s keys). And now all they need is the PIN. Turning the PIN into an encryption key is done using the Argon2id key derivation function, using 32 iterations and a memory cost of 16MB (the Juicebox white paper says 16KB, but (a) that’s laughably small and (b) the code says 16 * 1024 in an argument that takes kilobytes), which makes it computationally and moderately memory expensive to generate the encryption key used to decrypt the private key. How expensive? Well, on my (not very fast) laptop, that takes less than 0.2 seconds. How many attempts to I need to crack the PIN? Twitter’s chosen to fix that to 4 digits, so a maximum of 10,000. You aren’t going to need many machines running in parallel to bring this down to a very small amount of time, at which point private keys can, to a first approximation, be extracted at will.
Juicebox attempts to defend against this by supporting sharding your key over multiple backends, and only requiring a subset of those to recover the original. ~~I can’t find any evidence that Twitter’s does seem to be making use of this,~~Twitter uses three backends and requires data from at least two, but all the backends used are under x.com so are presumably under Twitter’s direct control. Trusting the keystore without needing to trust whoever’s hosting it requires a trustworthy communications mechanism between the client and the keystore. If the device you’re talking to can prove that it’s an HSM that implements the attempt limiting protocol and has no other mechanism to export the data, this can be made to work. Signal makes use of something along these lines using Intel SGX for contact list and settings storage and recovery, and Google and Apple also have documentation about how they handle this in ways that make it difficult for them to obtain backed up key material. Twitter has no documentation of this, and as far as I can tell does nothing to prove that the backend is in any way trustworthy. (Edit to add: The Juicebox API does support authenticated communication between the client and the HSM, but that relies on you having some way to prove that the public key you’re presented with corresponds to a private key that only exists in the HSM. Twitter gives you the public key whenever you communicate with them, so even if they’ve implemented this properly you can’t prove they haven’t made up a new key and MITMed you the next time you retrieve your key)
On the plus side, Juicebox is written in Rust, so Elon’s not 100% wrong. Just mostly wrong.
But ok, at least you’ve got viable end-to-end encryption even if someone can put in some (not all that much, really) effort to obtain your private key and render it all pointless? Actually no, since you’re still relying on the Twitter server to give you the public key of the other party and there’s no out of band mechanism to do that or verify the authenticity of that public key at present. Twitter can simply give you a public key where they control the private key, decrypt the message, and then reencrypt it with the intended recipient’s key and pass it on. The support page makes it clear that this is a known shortcoming and that it’ll be fixed at some point, but they said that about the original encrypted DM support and it never was, so that’s probably dependent on whether Elon gets distracted by something else again. And the server knows who and when you’re messaging even if they haven’t bothered to break your private key, so there’s a lot of metadata leakage.
Signal doesn’t have these shortcomings. Use Signal.
[1] I’ll respect their name change once Elon respects his daughter
[2] There are implementations written in Rust, but Twitter’s using the C one with these JNI bindings
[3] Or someone nominally trustworthy but who’s been compelled to act against your interests - even if Elon were absolutely committed to protecting all his users, his overarching goals for Twitter require him to have legal presence in multiple jurisdictions that are not necessarily above placing employees in physical danger if there’s a perception that they could obtain someone’s encryption keys
Part 3: mjg59 | How Twitter could (somewhat) fix their encrypted DMs
text
As I wrote in my last post, Twitter’s new encrypted DM infrastructure is pretty awful. But the amount of work required to make it somewhat better isn’t large.
When Juicebox is used with HSMs, it supports encrypting the communication between the client and the backend. This is handled by generating a unique keypair for each HSM. The public key is provided to the client, while the private key remains within the HSM. Even if you can see the traffic sent to the HSM, it’s encrypted using the Noise protocol and so the user’s encrypted secret data can’t be retrieved.
But this is only useful if you know that the public key corresponds to a private key in the HSM! Right now there’s no way to know this, but there’s worse - the client doesn’t have the public key built into it, it’s supplied as a response to an API request made to Twitter’s servers. Even if the current keys are associated with the HSMs, Twitter could swap them out with ones that aren’t, terminate the encrypted connection at their endpoint, and then fake your query to the HSM and get the encrypted data that way. Worse, this could be done for specific targeted users, without any indication to the user that this has happened, making it almost impossible to detect in general.
This is at least partially fixable. Twitter could prove to a third party that their Juicebox keys were generated in an HSM, and the key material could be moved into clients. This makes attacking individual users more difficult (the backdoor code would need to be shipped in the public client), but can’t easily help with the website version[1] even if a framework exists to analyse the clients and verify that the correct public keys are in use.
It’s still worse than Signal. Use Signal.
[1] Since they could still just serve backdoored Javascript to specific users. This is, unfortunately, kind of an inherent problem when it comes to web-based clients - we don’t have good frameworks to detect whether the site itself is malicious.
mjg59 = Matthew Garrett, a Linux Kernel contributor and fairly well known name in the Linux security space, known for work with secure boot and uefi among other things.
1 Like