David Wong | Cryptologie | Markdown http://www.cryptologie.net/ About my studies in Cryptography. en-us Thu, 16 Aug 2018 11:09:29 +0200 Facebook's TLS 1.3 library David Wong Thu, 16 Aug 2018 11:09:29 +0200 http://www.cryptologie.net/article/450/facebooks-tls-13-library/ http://www.cryptologie.net/article/450/facebooks-tls-13-library/#comments
> Using early data in TLS 1.3 has several caveats, however. An attacker can easily replay the data, causing it to be processed twice by the server. To mitigate this risk, we send only specific **whitelisted requests** as early data, and we’ve deployed a **replay cache alongside our load balancers to detect and reject replayed data**. Fizz provides simple APIs to be able to determine when transports are replay safe and can be used to send non-replay safe data.

My guess is that either all GET requests are considered safe, or only GET requests on the / route are considered safe.
I'm wondering why they use a replay cache on the other side as this overhead could nullify the benefits of 0-RTT.

They also mention every state transitions being stored in one place, this is [true](https://github.com/facebookincubator/fizz/blob/09ba244f83592ae89b1f9137f7b99ba58ae4f2a9/fizz/client/ClientProtocol.cpp#L32):

cpp
FIZZ_DECLARE_EVENT_HANDLER(
ClientTypes,
StateEnum::Uninitialized,
Event::Connect,
StateEnum::ExpectingServerHello);

FIZZ_DECLARE_EVENT_HANDLER(
ClientTypes,
StateEnum::ExpectingServerHello,
Event::HelloRetryRequest,
StateEnum::ExpectingServerHello);

FIZZ_DECLARE_EVENT_HANDLER(
ClientTypes,
StateEnum::ExpectingServerHello,
Event::ServerHello,
StateEnum::ExpectingEncryptedExtensions);


I think this is a great idea, which more TLS libraries should emulate. I had started a whitelist of transitions for TLS 1.3 draft 18 [here](https://gist.github.com/mimoo/779dcf8c44d80a2a34a1a2f2ed620711) but it's probably outdated. ]]>
Problems that UDP and only UDP has David Wong Mon, 13 Aug 2018 16:30:46 +0200 http://www.cryptologie.net/article/449/problems-that-udp-and-only-udp-has/ http://www.cryptologie.net/article/449/problems-that-udp-and-only-udp-has/#comments
To Simplify, TCP is just a collection of algorithms that extend UDP to make it support **in-order delivery** of **streams**. UDP on the other hand does not care about such streams and instead sends blocks of messages (called **datagrams**) in **whatever-order** and provides **no guarantee** what-so-ever that you will ever receive them.

TCP also provides some security guarantees on top of IP by starting a session with a **TCP handshake** it allows both endpoints of a communication to provide a proof of IP ownership, or at least that they can read whatever is sent to their claimed IPs. This means that to mess up with TCP, you need to be an **on-path** attacker man-in-the-middle'ing the connection between the two endpoints. UDP has none of that, **it has no notion of sessions**. Whatever packets are received from an IP, it'll just accept them. This means that an **off-the-path** attacker can trivially send packets that look like they are coming from any IP, effectively **spoofing the IP** of either one of the endpoint or anyone on the network. If the protocol built on top of UDP does not do anything to detect and prevent this, then bad things might happen (from complex attacks to simple denial of services).

This is not the only bad thing that can happen though. Sometimes (meaning for some protocols) a well-crafted message to an endpoint will trigger a large and disproportionate response. Malicious actors on the internet can use this to perform **amplification attacks**, which are denial-of-service attacks. To do that, the actor can send these special type of messages pretending to be a victim IP and then observe the endpoint respond with a large amount of data to the victim IP.

Intuitively, it sounds like both of these issues can be tackled by doing some sort of TCP handshake, but in practice it is rarely the case as the very first message of your protocol (which hasn't been able to provide a proof of IP ownership yet) can still trigger large messages. This is why in [QUIC](https://www.chromium.org/quic), the very first message from a client needs to be padded with 0s in order to make it as large as the server's response. Meaning that an attacker would have to at least spend as much resources that is provided by the attack, nullifying its benefits.

Looking at another protocol built on top of UDP, [DTLS](https://tools.ietf.org/html/rfc6347) (TLS for UDP) has a notion of "cookie" which is really some kind of bearer token that the client will have to keep providing to the server in relevant messages, this in order to prove that it is indeed the same endpoint talking to the server. ]]>
TLS 1.3 is out! David Wong Sat, 11 Aug 2018 13:55:45 +0200 http://www.cryptologie.net/article/448/tls-13-is-out/ http://www.cryptologie.net/article/448/tls-13-is-out/#comments
* Will we see a fast deployment of the protocol? It seems like browsers are ready, but web servers will have to follow.
* Who will use 0-RTT? I'm expecting the big players to use it (largely because they've been requesting it) but what about the small ones?
* Are we going to see vulnerabilities in the protocol? It seems highly unlikely, TLS 1.2 itself (with AES-GCM) has remained solid for more than 10 years.
* Are we going to see vulnerabilities in the implementations? We will see about that. If anything happens, I'm expecting it to happen around 0-RTT, PSKs and key exports. But let's hope that libraries have learned their lessons.
* Is [BearSSL](https://bearssl.org/) going to implement TLS 1.3? It sounds like it.
]]>
WhatsApp, Secure Messaging, Transcript Consistency and Trust in a group chat David Wong Fri, 10 Aug 2018 11:54:10 +0200 http://www.cryptologie.net/article/447/whatsapp-secure-messaging-transcript-consistency-and-trust-in-a-group-chat/ http://www.cryptologie.net/article/447/whatsapp-secure-messaging-transcript-consistency-and-trust-in-a-group-chat/#comments
First, there is nothing new in being able to man-in-the-middle and decrypt your own TLS sessions (+ a simple protocol on top). Sure the tool is neat, but it is not breaking WhatsApp in this regard, it is merely allowing you to look at (and to modify) what you're sending to the WhatsApp server.

The blog post goes through some interesting ways to mess with a WhatsApp group chat, as it seems that the application relies in some parts on metadata that you are in control of. This is bad hygiene, but for me the interesting attack is attack number 3: you can send messages to SOME members of the group, and send different messages to OTHER members of the group.

At first I thought: this is nothing new. If you read the [WhatsApp whitepaper](https://www.whatsapp.com/security/WhatsApp-Security-Whitepaper.pdf) it is a clear limitation of the protocol: you do not have **transcript consistency**. And by that I mean, nothing is **cryptographically enforcing** that all members of a group chat are seeing the exact same thing.

It is always hard to ensure that the last messages have been seen by everyone of course (some people might be offline), but transcript consistency really only cares about **ordering, dropping, and tampering** of the messages.

Let's talk about WhatsApp some more. Its protocol is very different from what Signal does and in group chats, each member shares their unique symmetric key with the other members of the group (separately). This means that when you join a group with Alice and Bob, you first create some random symmetric key. After that, you encrypt it under Alice's public key and you send it to her. You then do the same thing with Bob. Once all the members have knowledge of your random symmetric key, you can encrypt all of your messages with it (perhaps using a ratchet). When a member leaves, you have to go through this dance again in order to provide **forward secrecy** to the group (leavers won't be able to read messages anymore). If you understood what I said, the protocol does not really gives you way to enforce transcript consistency, you are in control of the keys so you choose who you encrypt what messages to.

But wait! Normally, the server should distribute the messages in a fan-out way (the server distributes **one** encrypted message to **X** participants), forcing you to collude with a root@WhatsApp in order to perform this kind of shenanigans. In the [blog post's attack](https://github.com/romanzaikin/BurpExtension-WhatsApp-Decryption-CheckPoint) it seems like you are able to bypass this and do not need the help of WhatsApp's servers. This is bad and I'm still trying to figure out what really happened.

By the way, to my knowledge no end-to-end encrypted protocol has this property of transcript consistency for group chats. Interestingly, the Messaging Layer Security (MLS) which is the latest community effort to standardize a messaging protocol does not have a solution for this either. I'll probably talk about MLS in a different blog post because it is still very interesting.

The last thing I wanted to mention is **trust inside of a group chat**. We've been trying to solve trust in a one-to-one conversation for many many years, and between PGP being broken and the many wars between the secure messaging applications, it seems like this is still something we're struggling with. Just yesterday, a post titled [I don't trust Signal](https://news.ycombinator.com/item?id=17723973) made the front page on hackernews. So is there hope for trust in a group chat anytime soon?

First, there are three kinds of group chat:

* large group chats
* medium-sized group chats
* small group chats

I'll argue that **large group chats have given up on trust**, as it is next to impossible to figure out who is who. Unless of course we're dealing with a PKI and a company enforcing onboarding with a CA. And even this is has issues (beyond the traitors and snoops).

I'll also argue that **small group chats are fine with the current protocols**, because you're probably trusting people not to run this kind of attacks.

**The problem is in medium-sized group chats**. ]]>
QUIC Crypto and simple state machines David Wong Thu, 09 Aug 2018 12:39:32 +0200 http://www.cryptologie.net/article/446/quic-crypto-and-simple-state-machines/ http://www.cryptologie.net/article/446/quic-crypto-and-simple-state-machines/#comments
* Google wanted to improve TCP (2.0™️)
* but TCP can't really be changed
* so they built it on top of UDP (which is just IP with ports, check the [2 page RFC for UDP](https://tools.ietf.org/html/rfc768) if you don't believe me)
* they made it with **encryption by default**
* and they called it **QUIC**, because it's quick, you know

There is more to it, it makes HTTP blazing fast with multiplexed streams and all, but I'm only interested about the crypto here.

Google QUIC's (or gQUIC) default encryption was provided by a home-made crypto protocol called QUIC Crypto. The thing is documented in a 14-page [doc file](https://docs.google.com/document/d/1g5nIXAIkN_Y-7XJW5K45IblHd_L2f5LTaDUDwvZ5L6g/edit) and is more or less up-to-date. It was at some point agreed that things needed to get standardized, and thus [the process of making QUIC an RFC (or RFCs) began](https://datatracker.ietf.org/wg/quic/about/).

Unfortunately QUIC Crypto did not make it and the IETF decided to replace it with TLS 1.3 for diverse reasons.

Well, as Adam Langley puts it in some of [his slides](https://www.ietf.org/proceedings/92/slides/slides-92-saag-5.pdf). The protocol was dead simple:

While the protocol had some flaws, in the end, it was still a beautiful and elegant protocol. At its core was an extremely straight forward and linear state machine summed up by this diagram:

* a server config is just a blob that contains the server current semi-ephemeral keys. The server config is rotated every X days.
* an inchoate client hello is just an empty client hello, which prompts the server to send a REJ(ect) message containing its latest config (after that the client can try again with a full client hello)
* SHLO is a (encrypted) server hello which contains ephemeral keys

As you can see **there isn't much going on**, if you know the keys of the server you can do some 0-RTT magic, if you don't then request the keys and start the handshake again.

Compare that to [the state machine of TLS 1.3](https://tools.ietf.org/html/draft-ietf-tls-tls13-28#appendix-A.1):

In the end, TLS 1.3 is a solid protocol, but I'd like to see more experimentation here instead of just relying on TLS. version 1.3 is built on top of numerous previous failed versions which means a great amount of complexity due to legacy and a multitude of use cases and extensions it needs to support. Simpler protocols should be better, simple state machines make for better analysis and more secure implementations. Just look at the [Noise protocol framework](http://noiseprotocol.org/) and its 1k LOC implementations and its symbolic proofs done with [ProVerif](https://noiseexplorer.com) and [Tamarin](https://www.wireguard.com/papers/wireguard-formal-verification.pdf). Actually, why haven't we started using Noise for everything? ]]>
That's right! when crafting a transaction to send money on the bitcoin network, you actually do not include I am sending my BTC to _this address_. Instead, you include a script called a **ScriptPubKey** which dictates a set of inputs that are allowed to redeem the monies. The **PubKey** in the name surely refers to the main use for this field: to actually let a unique public key redeem the money (the intended recipient). But that's not all you can do with it! There exist a multitude of ways to write ScriptPubKeys! You can for example:

* not allow anyone to redeem the BTCs, and even use the transaction to record arbitrary data on the blockchain (this is what a lot of applications built on top of bitcoin do, they "burn" bitcoins in order to create metadata transactions in their own blockchains)
* allow someone who has a password to use the BTCs (but to submit the password, you would need to include it in clear inside a transaction which would inevitably be advertised to the network before actually getting mined. This is dangerous)
* allow a subset of signatures from a fixed set of public keys to redeem the BTCs (this is what we call multi-sig transactions)
* allow someone who can break a hash function (SHA-1) to redeem the BTCs (This is what [Peter Todd did in 2013](https://en.bitcoin.it/wiki/Script#Incentivized_finding_of_hash_collisions))
* only allow the BTCs to be redeemed after some time in the future (via a timestamp)
* etc.

On the other hand, if you want to use the money you need to prove that you can use such a transaction's output. For that you include a **ScriptSig** in a new transaction, which is another script that runs and creates a number of inputs to be used by the **ScriptPubKey** I talked about. And you guessed it, in our prime use-case this will include a signature (the **Sig** in the name)!

Recap: when you send BTCs, you actually send it to whoever can give you a correct input (created by a ScriptSig) to your program (ScriptPubKey). In more details, a Bitcoin transaction includes a set of **input BTCs** to **spend** and a set of **output BTCs** that are now **redeemable** by whoever can provide a valid ScriptSig. That's right, **a transaction actually uses many previous transactions to collect money from, and spread them in possibly multiple pockets of money that other transactions can use**. Each input of a transaction is associated to a previous transaction output, along with the ScriptSig to redeem it. Each output is associated with a ScriptPubKey. By the way, an output that hasn't been spent yet is called an UTXO for unspent transaction output.

The scripting language of Bitcoin is actually quite limited and easy to learn. It uses a stack and must return True at the end. The limitations actually bothered some people who thought it might be interesting to create something more [turing-complete](https://en.wikipedia.org/wiki/Turing_completeness), and thus [Ethereum](https://en.wikipedia.org/wiki/Ethereum) was born. ]]>
CryptoMag is looking for articles David Wong Thu, 05 Jul 2018 14:16:06 +0200 http://www.cryptologie.net/article/444/cryptomag-is-looking-for-articles/ http://www.cryptologie.net/article/444/cryptomag-is-looking-for-articles/#comments
You want to teach someone about a crypto concept, something 101 that could be explained in 1-2 pages with a lot of diagrams? Look no more, we need you.

## Concept

The idea is to have a recurrent benevolent e-magazine (like [POC||GTFO](https://github.com/tylert/pocorgtfo)) that focuses on:

* **cryptography**: *duh!* That being said, cryptography does include: implementations, cryptocurrencies, protocols, at scale, politics, etc. so there are more topics that we deem interesting than just theoretical cryptography.
* **pedagogy**: heaps of *diagrams* and a focus on teaching. Taking an original writing style is a plus. We're looking not to bore readers.
* **101**: we're looking for *introductions* to concepts, not deeply technical articles that require a lot of initial knowledge to grasp.
* **short**: articles should be similar to a blog post, not a full-fledged paper. With that in mind articles should be around 1, 2 or 3 pages. We are not looking for something dense though, so no posters, rather a submission should be a light read that can be part of a series or influence the reader to read more about the topic.

## Topics

Preferably, authors should write about something they are familiar with, but here is a list of topics that would likely be interesting for such a light magazine:

* what is SSH?
* what is SHA-3?
* what is functional encryption?
* what is TLS 1.3?
* what is a linear differential attack?
* what is a cache attack?
* how does LLL work?
* what are common crypto implementation tricks?
* what is R-LWE?
* what is a hash-based signature?
* what is an RFC?
* what is the IETF?
* what is the IACR?
* why are companies encrypting databases?
* what is x509, .pem, asn.1 and base64?
* etc...

## Format

LaTeX if possible.

## How to submit

send me a dropbox link or something on the [contact page](/contact), you can also send it to me via [twitter](https://www.twitter.com/cryptodavidw)

PS: I am going to annoy you if you don't use diagrams in your article ]]>
Tamuro meetup in London David Wong Fri, 29 Jun 2018 12:20:15 +0200 http://www.cryptologie.net/article/443/tamuro-meetup-in-london/ http://www.cryptologie.net/article/443/tamuro-meetup-in-london/#comments Smart Contract Security @ IT Camp David Wong Fri, 08 Jun 2018 22:25:19 +0200 http://www.cryptologie.net/article/442/smart-contract-security-it-camp/ http://www.cryptologie.net/article/442/smart-contract-security-it-camp/#comments
<iframe width="560" height="315" src="https://www.youtube.com/embed/yIQUnV3dTBs" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen></iframe>

Yours truly. ]]>
Ethereum Smart Contract Security @ IT Camp - Cluj Napoca David Wong Sun, 03 Jun 2018 15:59:53 +0200 http://www.cryptologie.net/article/441/ethereum-smart-contract-security-it-camp-cluj-napoca/ http://www.cryptologie.net/article/441/ethereum-smart-contract-security-it-camp-cluj-napoca/#comments If anyone is there and wants to talk about crypto while drinking beer, contact me! ]]> Decentralized Application Security Project David Wong Wed, 11 Apr 2018 20:30:18 +0200 http://www.cryptologie.net/article/440/decentralized-application-security-project/ http://www.cryptologie.net/article/440/decentralized-application-security-project/#comments

The page is on [github](https://github.com/CryptoServices/dasp) as well and we welcome contributions to the [top 10](https://dasp.co/) and the [list of known exploits](https://dasp.co/timeline.html). In addition we're looking to host more projects related to the Ethereum space there, if you are looking for research projects or are looking to contribute on tools or anything that can make smart contracts development more secure, [file an issue on github](https://github.com/CryptoServices/dasp/issues)!

Note that I will be giving the talk again at [IT Camp](https://itcamp.ro/agenda/) in Cluj-Napoca in a few months. ]]>
Fed Up Getting Shattered and Log Jammed? A New Generation of Crypto Is Coming David Wong Sun, 08 Apr 2018 14:09:17 +0200 http://www.cryptologie.net/article/439/fed-up-getting-shattered-and-log-jammed-a-new-generation-of-crypto-is-coming/ http://www.cryptologie.net/article/439/fed-up-getting-shattered-and-log-jammed-a-new-generation-of-crypto-is-coming/#comments
<iframe width="800" height="515" src="https://www.youtube.com/embed/bTGLO4obxco" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen></iframe>

[I gave a summary of the talk here](https://www.cryptologie.net/article/432/introducing-disco/). You can also directly check out the specification of Disco or the libdisco library on [www.discocrypto.com](https://www.discocrypto.com). ]]>
Two Student Tickets for Black Hat Asia in March 2018 David Wong Mon, 22 Jan 2018 12:12:13 +0100 http://www.cryptologie.net/article/438/two-student-tickets-for-black-hat-asia-in-march-2018/ http://www.cryptologie.net/article/438/two-student-tickets-for-black-hat-asia-in-march-2018/#comments
Anyone interested?

EDIT: these have been given away. ]]>
On Real World Crypto and Secure Messaging David Wong Thu, 11 Jan 2018 00:49:42 +0100 http://www.cryptologie.net/article/437/on-real-world-crypto-and-secure-messaging/ http://www.cryptologie.net/article/437/on-real-world-crypto-and-secure-messaging/#comments
Today Paul Rösler came to **Real World Crypto** to talk about the results, which is a good thing.
Interestingly, in the middle of the talk Wired released a worrying article untitled [WhatsApp Security Flaws Could Allow Snoops to Slide Into Group Chats](https://www.wired.com/story/whatsapp-security-flaws-encryption-group-chats/).
Interestingly as well, at some point during the day Matthew Green also wrote about it in [Attack of the Week: Group Messaging in WhatsApp and Signal](https://blog.cryptographyengineering.com/2018/01/10/attack-of-the-week-group-messaging-in-whatsapp-and-signal/).

They make it seem really worrisome, but should we really be scared about the findings?

**Traceable delivery** is the first thing that came up in the presentation. What is it? It’s the check marks that appear when your recipient receives a message you sent. It's mostly a UI feature but the fact that no security is tied to it allows a server to fake them while dropping messages, making you think that your recipient has wrongly received the message. This was never a security feature to begin with, and nobody never claimed it was one.

**Closeness** is the fact that the WhatsApp servers can add a new participant into your private group chat without your consent (assuming you’re the admin). This could lead people to share messages to the group including to a rogue participant. The caveat is that:

* previous messages cannot be decrypted by the newcomer because a new key is generated when someone new joins the mix

* everybody is receiving a notification that somebody joined, at this point everyone can choose to willingly send messages to the group

Again, I do not see this as a security vulnerability. Maybe because I’ve understood how group chats can work (or miswork) from growing up with shady websites and applications. But I see this more as a UI/UX problem.

The paper is not bad though, and I think they’re right to point out these issues. Actually, they do something very interesting in it, they start it up with a nice **security model** that they use to analyse several messaging applications:

> Intuitively, a secure group communication protocol should provide a level of security comparable to when a group of people communicates in an isolated room: everyone in the room hears the communication (**traceable delivery**), everyone knows who spoke (**authenticity**) and how often words have been said (**no duplication**), nobody outside the room can either speak into the room (**no creation**) or hear the communication inside (**confidentiality**), and the door to the room is only opened for invited persons (**closeness**).

Following this security model, you could rightfully think that we haven’t reached the best state in secure messaging. But the fuss about it could also wrongfully make you think that these are worrisome attacks that need to be dealt with.

The facts are here though, this paper has been blown out of proportion. [Moxie (one of the creator of Signal) reacts on hackernews](https://news.ycombinator.com/item?id=16117487):

> To me, this article reads as a better example of the problems with the security industry and the way security research is done today, because I think the lesson to anyone watching is clear: don't build security into your products, because that makes you a target for researchers, even if you make the right decisions, and regardless of whether their research is practically important or not.

I'd say the problem is in the reaction, not in the published analysis. But it's a sad reaction indeed.

Good night.
]]>
Updates on How to Backdoor Diffie-Hellman David Wong Mon, 08 Jan 2018 18:12:54 +0100 http://www.cryptologie.net/article/436/updates-on-how-to-backdoor-diffie-hellman/ http://www.cryptologie.net/article/436/updates-on-how-to-backdoor-diffie-hellman/#comments on how to backdoor the Diffie-Hellman key agreement algorithm. Inside the whitepaper,
I discussed three different ways to construct such a backdoor; two of these were considered nobody-but-us (NOBUS) backdoors.

> A NOBUS backdoor is a backdoor accessible only to those who have the knowledge of some secret (a number, a passphrase, ...). Making a NOBUS backdoor irreversible without the knowledge of the secret.

In October 2016, Dorey et al. from Western University (Canada) published a white paper called [Indiscreet Logs: Persistent Diffie-Hellman Backdoors in TLS](http://eprint.iacr.org/2016/999). The research pointed out that one of my NOBUS construction was **reversible**, while the other NOBUS construction was **more dangerous** than expected.

I wrote this blogpost resuming their discoveries a long time ago, but never took the time to publish it here. In the rest of this post, I'll expect you to have an understanding of the two NOBUS backdoors introduced in [my paper](https://www.nccgroup.trust/uk/our-research/how-to-backdoor-diffie-hellman/).
You can find a summary of the ideas [here](https://www.cryptologie.net/article/360/how-to-backdoor-diffie-hellman-quick-explanation/) as well.

Reversing the first NOBUS construction
--------------------------------------

For those who have attended my talk at [Defcon](https://www.youtube.com/watch?v=90EYVy35gsY&t=1748s), Toorcon or a meetup; I should assure you that I did not talk about the first (now-known
reversible) NOBUS construction. It was left out of the story because it was not such a nice backdoor in the first place. Its security margins
were weaker (at the time) compared to the second construction, and it was also harder to implement.

### Baby-Step Giant-Step

The attack Dorey et al. wrote about comes from a 2005 white paper, where
Coron et al. [published an attack](http://eprint.iacr.org/2010/650) on a
construction based on Diffie-Hellman. But before I can tell you about
the attack, I need to refresh your memory on how the **baby-step giant-step** (BSGS) algorithm works.

Imagine that a generator \$$g\$$ generates a group \$$G\$$ in
\$$\mathbb{Z}\_p\$$, and that we want to find the order of that group
\$$|G| = p\_1\$$.

Now what we could do if we have a good idea of the size of that order
\$$p\_1\$$, is to split that length in two right in the middle: \$$p\_1 = a + b \cdot 2^{\lceil \frac{l}{2} \rceil}\$$, where \$$l \$$ is the bitlength of \$$p\_1\$$.

This allows us to write two different lists:

\$\begin{cases} L = \{ g^i \mod{p} \mid 0 < i < 2^{\lceil \frac{l}{2} \rceil} \} \\\\ L' = \{ g^{-j \cdot 2^{\lceil \frac{l}{2} \rceil} } \mod{p} \mid 0 \leq j < 2^{\lceil \frac{l}{2} \rceil} \} \end{cases} \$

Now imagine that you compute these two lists, and that you then stumble
upon a collision between elements from these two sets. This would entail
that for some \$$i\$$ and \$$j\$$ you have:

\\begin{align} &g^i = g^{-j \cdot 2^{\lceil \frac{l}{2} \rceil}} \pmod{p}\\\\ \Leftrightarrow &g^{i + j \cdot 2^{\lceil \frac{l}{2} \rceil}} = 1 \pmod{p}\\\\ \Rightarrow &i + j \cdot 2^{\lceil \frac{l}{2} \rceil} = a + b \cdot 2^{\lceil \frac{l}{2} \rceil} = p\_1 \end{align} \

We found \$$p\_1\$$ in time quasi-linear (via sorting, searching trees,
etc...) in \$$\sqrt{p\_1}\$$!

### The Construction

Now let's review our first NOBUS construction, detailed in [section 4 of my paper](https://eprint.iacr.org/2016/644.pdf).

Here \$$p - 1 = 2 p\_1 p\_2 \$$ with \$$p\_1 \$$ our small-enough
subgroup generated by \$$g\$$ in \$$\mathbb{Z}\_p\$$, and \$$p\_2\$$
our big-enough subgroup that makes the factorization of our modulus
near-impossible. The factor \$$q\$$ is generated in the same way.

### Using BSGS on our construction

At this point, we could try to reverse the construction using BSGS by
creating these two lists and hopping for a collision:

\$\begin{cases} L = \{ g^i \mod{p} \mid 0 < i < 2^{\lceil \frac{l}{2} \rceil} \} \\\\ L' = \{ g^{-j \cdot 2^{\lceil \frac{l}{2} \rceil} } \mod{p} \mid 0 \leq j < 2^{\lceil \frac{l}{2} \rceil} \} \end{cases} \$

Unfortunately, remember that \$$p\$$ is hidden inside of \$$n = p q \$$. We have no knowledge of that factor. Instead, we could calculate
these two lists:

\$\begin{cases} L = \{ g^i \mod{n} \mid 0 < i < 2^{\lceil \frac{l}{2} \rceil} \} \\\\ L' = \{ g^{-j \cdot 2^{\lceil \frac{l}{2} \rceil} } \mod{n} \mid 0 \leq j < 2^{\lceil \frac{l}{2} \rceil} \} \end{cases} \$

And this time, we can test for a collision between two elements of these
lists "mod \$$p\$$" via the \$$gcd\$$ function:

\$gcd(n, g^i - g^{-j \cdot 2^{\lceil \frac{l}{2} \rceil}}) \$

Hopefully this will yield \$$p\$$, one of the factor of \$$n\$$. If you
do not understand why, it works because if \$$g^i\$$ and \$$g^{-j \cdot 2^{\lceil \frac{l}{2} \rceil}}\$$ collide "mod \$$p\$$", then
we have:

\$p | g^i - g^{-j \cdot 2^{\lceil \frac{l}{2} \rceil}} \$

Since we also know that \$$p | n \$$, it results that the \$$gcd\$$ of
the two returns our hidden \$$p\$$!

Unfortunately at this point, the persnickety reader will have noticed
that this cannot be done in the same complexity as the original BSGS
attack. Indeed, we need to compute the \$$gcd\$$ for all pairs and this
increases our complexity to \$$\mathcal{O}(p\_1)\$$, the same
complexity as the attack I pointed out in my paper.

### The Attack

Now here is the that trick Coron et al. found out. They could optimize
calls to \$$gcd\$$ down to \$$\mathcal{O}(\sqrt{p\_1})\$$, which would
make the reversing as easy as using the backdoor. The trick is as
follow:

1. Create the polynomial

\$f(x) = (x - g) (x - g^2) \cdots (x - g^{2^{\lceil \frac{l}{2} \rceil}}) \mod{n} \$

2. For \$$0 \leq j < 2^{\lceil \frac{l}{2} \rceil}\$$ compute
the following \$$gcd\$$ until a factor of \$$n\$$ is found (as
before)

\$gcd(n, f(g^{-j \cdot 2^{\lceil \frac{l}{2} \rceil}})) \$

It's pretty easy to see that the \$$gcd\$$ will still yield a factor, as
before. Except that this time we only need to call it at most
\$$2^{\lceil \frac{l}{2} \rceil}\$$ times, which is \$$\approx \sqrt{p\_1}\$$ times by definition.

Improving the second NOBUS construction
---------------------------------------

The second NOBUS backdoor construction received a different treatment.
If you do not know how this backdoor works I urge you to first watch [my talk on the subject](https://www.youtube.com/watch?v=90EYVy35gsY&t=1748s).

Let's ask ourselves the question: what happens if the client and the
server do not negotiate an ephemeral Diffie-Hellman key exchange, and
instead use RSA or Elliptic Curve Diffie-Hellman to perform the key
exchange?

This could be because the client did not list a DHE (ephemeral
Diffie-Hellman) cipher suite in priority, or because the server decided
to pick a different kind of key agreement algorithm.

If this is the case, we would observe an exchange that we could not spy
on or tamper with via our DHE backdoor.

Dorey et al. discovered that an **active** man-in-the-middle could
change that by tampering with the original client's ClientHello
message to single-out a DHE cipher suite (removing the rest of the
non-DHE cipher suites) and **forcing the key exchange to happen by way
of the Diffie-Hellman algorithm**.

This works because there are no countermeasures in TLS 1.2 (or prior) to
prevent this to happen.

Final notes
-----------

My original white paper has been updated to reflect Dorey et al.'s
developments while minimally changing its structure (to retain
chronology of the discoveries). You can obtain it [here](https://eprint.iacr.org/2016/644).

Furthermore, let me mention that the new version of TLS —**TLS 1.3**—
will fix all of these issues in two ways:

- A server now signs the entire observed transcript at some point
during the handshake. This successfully prevents any tampering with
the ClientHello message as the client can verify the signature and
make sure that no active man-in-the-middle has tampered with the
handshake.
- Diffie-Hellman groups are now specified, exactly like how curves
have always been specified for the Elliptic Curve variant of
Diffie-Hellman. This means that unless you are in control of both
the client and the server's implementations, you cannot force one or
the other to use a backdoored group (unless you can backdoor one of
the specified group, which is what happened with [RFC
5114](http://blog.intothesymmetry.com/2016/10/the-rfc-5114-saga.html)). ]]>
Best crypto blog posts of 2017 David Wong Wed, 27 Dec 2017 17:05:28 +0100 http://www.cryptologie.net/article/435/best-crypto-blog-posts-of-2017/ http://www.cryptologie.net/article/435/best-crypto-blog-posts-of-2017/#comments
Merry christmas and happy new year. We're done for the year and so it is time for me to write this blog post ([I did the same last year](https://cryptologie.net/article/397/crypto-blogging-award-2016/) by the way).

I'll copy verbatim what I wrote last year about what makes a good blog post:

* **Interesting**. I need to learn something out of it, whatever the topic is. If it's only about results I'm generally not interested.
* **Pedagogical**. Don't dump your unfiltered knowledge on me, I'm dumb. Help me with diagrams and explain it to me like I'm 5.
* **Well written**. I can't read boring. Bonus point if it's funny :)

Without further adue, here is the list!

* [building lattice reduction (LLL) intuition](https://kel.bz/post/lll/) from [Kelby Ludwig](https://twitter.com/kelbyludwig) is a must read if you want to understand how lattices and lattice reductions work. By the way, this post is the perfect example of a blogpost that fits all my criteria of a good blog post. Make sure to check [Kelby's blog post of last year](https://kel.bz/post/lattices/) as well.

* [Introducing Miscreant: a multi-language misuse resistant encryption library](https://tonyarcieri.com/introducing-miscreant-a-multi-language-misuse-resistant-encryption-library) from [Tony Arcieri](https://twitter.com/bascule) is the perfect introduction to key wrapping and SIV modes. [AES-GCM-SIV](https://www.imperialviolet.org/2017/05/14/aesgcmsiv.html) from [Adam Langley]() is a good addition.

* [How I implemented my own crypto](http://loup-vaillant.fr/articles/implemented-my-own-crypto) is a trip report from **Loup Vaillant** about implementing his own cryptographic library.

* [Why TLS 1.3 isn't in browsers yet](https://blog.cloudflare.com/why-tls-1-3-isnt-in-browsers-yet/) by [Nick Sullivan](https://twitter.com/grittygrease) is a good summary of the mess that TLS 1.3 is (specifically because it needs to support so many legacy versions). For more lolz, make sure to read [Matthew Green](https://twitter.com/matthew_d_green)'s [The strange story of “Extended Random”](https://blog.cryptographyengineering.com/2017/12/19/the-strange-story-of-extended-random/).

* Cloudflare has a lot more good blogposts: [Privacy Pass - “The Math”](https://blog.cloudflare.com/privacy-pass-the-math/) from **Alex Davidson** goes through the math of one of the most crypto-y feature ever seen from a "normal" company, [SIDH in Go for quantum-resistant TLS 1.3](https://blog.cloudflare.com/sidh-go) by [Henry de Valence](https://twitter.com/hdevalence) does the same for the SIDH post-quantum key exchange. (A good addition to this is [SIDH a quantum resistant algorithm for DH exchange](https://crypto.anarres.info/2017/sidh) by **Shevek**).

* [HTTPS on Stack Overflow: The End of a Long Road](https://nickcraver.com/blog/2017/05/22/https-on-stack-overflow/) is a huge post from [Nick Craver](https://twitter.com/Nick_Craver) going into depth about the troubles of migrating towards HTTPS for large infrastructures. In addition, be sure to check [Jan Schaumann](https://twitter.com/jschauma)'s work on doing the same thing for yahoo: [The Razor's Edge - Cutting Your TLS Baggage](https://www.netmeister.org/blog/razors-edge.html).

* [SSL Certificate Exchange](http://www.commandlinefanatic.com/cgi-bin/showarticle.cgi?article=art061) from **Joshua Davies** is a really useful walkthrough of a TLS certificate. If you don't know much about TLS certificates and need to know more, it's a really good read.

* [Is SHA-3 slow?](https://keccak.team/2017/is_sha3_slow.html), [Keccak: open-source cryptography ](https://keccak.team/2017/open_source_crypto.html) and [Why Keccak is not ARX ](https://keccak.team/2017/not_arx.html). The [Keccak team](https://twitter.com/KeccakTeam/) made an excellent job this year of talking (and debunking critics) about the new SHA-3 hash function. You can learn about the different concepts surrounding SHA-3 through these posts.

* [Why Replace SHA-1 with BLAKE2?](https://research.kudelskisecurity.com/2017/03/06/why-replace-sha-1-with-blake2/) on the other hand, written by [JP Aumasson](https://twitter.com/veorq), tells you to replace your SHA-1 instances with his hash function BLAKE2. JP writes a lot of very good blog post, so check this one on [Should Curve25519 keys be validated?](https://research.kudelskisecurity.com/2017/04/25/should-ecdh-keys-be-validated/) (that launched the debate on Curve25519 key validation) or the ones on his submission to NIST's PQ crypto not-a-competition thingy: [Improving the SPHINCS post-quantum signature scheme, part 1](https://research.kudelskisecurity.com/2017/09/25/improving-the-sphincs-post-quantum-signature-scheme-part-1/).

* [Cryptographic vulnerabilities in IOTA](https://medium.com/@neha/cryptographic-vulnerabilities-in-iota-9a6a9ddc4367) by [Neha Narula](Neha Narula) and the follow up [Our response to "A Cryptocurrency Without a Blockchain Has Been Built to Outperform Bitcoin"](https://www.media.mit.edu/posts/iota-response/) by **Joi Ito** (both from the [Digital Currency medialab of MIT](https://twitter.com/medialab)) because it shows you how hilariously bad some cryptocurrencies are (interestingly IOTA reached and lost to 4th place (in terms of market cap) in the cryptocurrency world a few months ago).

* [Confidential Transactions from Basic Principles](http://cryptoservices.github.io/cryptography/2017/07/21/Sigs.html) from **Michael Rosenberg** is a pedogagical intro to ring signatures, range proofs and other cryptographic concepts. This is useful to dig into especially if you're keen on anonimity inside of cryptocurrencies. For an exploit of these, be sure to check [Exploiting Low Order Generators in One-Time Ring Signatures](https://nickler.ninja/blog/2017/05/23/exploiting-low-order-generators-in-one-time-ring-signatures/) from **Jonas Nick**.

* [What are zk-SNARKs?](https://z.cash/technology/zksnarks.html). **Zcash** has a series of articles about its underlying technology (anonimity inside of a cryptocurrency), it seems well written (like a lot of things on their website).

* [Survey of Discrete Log Algorithms](https://fortenf.org/e/crypto/2017/12/03/survey-of-discrete-log-algos.html) is a good intro to the discrete logarithm problem.

* [Walking through an F* proof](https://gist.github.com/s-zanella/97ee3dfbead56e8ce3b2316ff0bfb636) by [Santiago Zanella-Beguelin](https://twitter.com/xEFFFFFFF) seems like a good way to get yourself into F*.

That's it!

If you want more links like these, be sure to subscribe to my [link section](http://cryptologie.net/links) here on this website.

See you in 2018! ]]>
SHAKE and SP 800-185 David Wong Thu, 14 Dec 2017 16:22:01 +0100 http://www.cryptologie.net/article/434/shake-and-sp-800-185/ http://www.cryptologie.net/article/434/shake-and-sp-800-185/#comments

SHAKE is not a hash function, but an **Extendable Output Function** (or XOF). It behaves like a normal hash function except for the fact that it produces an “infinite” output. So you could decide to generate an output of one million bytes or an output of one byte. Obviously don't do the one byte output thing because it's not really secure. The other particularity of SHAKE is that it uses saner parameters that allow it to achieve the desired targets of 128-bit (for **SHAKE128**) or 256-bit (for **SHAKE256**) for security.
This makes it a faster alternative than SHA-3 while being a more flexible and versatile function.

## SP 800-185

SHAKE is intriguing enough that just a year following the standardization of SHA-3 (2016) another standard is released from the NIST's factory: [Special Publication 800-185](http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-185.pdf). Inside of it a new customizable version of SHAKE (named cSHAKE) is defined, the novelty: it takes an additional "customization string" as argument. This string can be anything from an empty string to the name of your protocol, but the slightest change will produce entirely different outputs for the same inputs. This
customization string is mostly used as domain separation for the other functions defined in the new document: **KMAC**, **TupleHash** and **ParallelHash**. The rest of this blogpost explains what these new functions are for.

## KMAC

Imagine that you want to send a message to your good friend Bob. You do not care about encrypting your message, but to make sure that nobody modifies the message in transit, you hash it with SHA-256 (the variant of SHA-2 with an output length of 256-bit) and append the hash to the message you're sending.


message || SHA-256(message)


On the other side, Bob detaches the last 256-bit of the message (the hash), and computes SHA-256 himself on the message. If the obtained result is different from the received hash, Bob will know that someone has modified the message.

**Does this work? Is this secure?**

Of course not, I hope you know that. A hash function is public, there are no secrets involved, someone who can modify the message can also recompute the hash and replace the original one with the new one.

Alright, so you might think that doing the following might work then:


message || SHA-256(key || message)


Both you and Bob now share that symmetric key which should prevent any man-in-the-middle attacker to recompute that hash.

**Do you really think this is working?**

Nope it doesn't. The reason, not always known, is that SHA-256 (and most variants of SHA-2) are vulnerable to what is called a **length extension attack**.

You see, unlike the sponge construction that releases just a part of its state as final output, SHA-256 is based on the [Merkle–Damgård construction](https://en.wikipedia.org/wiki/Merkle%E2%80%93Damg%C3%A5rd_construction) which outputs the entirity of its state as final output. If an attacker observes that hash, and pretends that the absorption of the input hasn't finished, he can continue hashing and obtain the hash of message || more (pretty much, I'm omitting some details like padding). This would allow the attacker to add more stuff to the original message without being detected by Bob:


message || more || SHA-256(key || message || more)


Fortunately, every SHA-3 participants (including the SHA-3 winner) were required to be resistant to these kind of attacks. Thus, **KMAC** is a **Message Authentication Code** leveraging the resistance of SHA-3 to length-extension attacks. The construction HASH(key || message) is now possible and the simplified idea of KMAC is to perform the following computation:


cSHAKE(custom_string=“KMAC”, input=“key || message”)


KMAC also uses a trick to allow pre-computation of the keyed-state: it pads the key up to the block size of cSHAKE. For that reason I would recommend not to come up with your own SHAKE-based MAC construction but to just use KMAC if you need such a function.

## TupleHash

**TupleHash** is a construction allowing you to hash a structure in an non-ambiguous way. In the following example, concatenating together the parts of an RSA public key allows you to obtain a fingerprint.

A malicious attacker could compute a second public key, using the bits
of the first one, that would compute to the same fingerprint.

Ways to fix this issue are to include the type and length of each
element, or just the length, which is what TupleHash does. Simplified,
the idea is to compute:


cSHAKE(custom_string=“TupleHash”,
input=“len_1 || data_1 || len_2 || data_2 || len_3 || data_3 || ..."
)


Where len_i is the length of data_i.

## ParallelHash

**ParallelHash** makes use of a tree hashing construction to allow
faster processing of big inputs and large files. The input is first
divided in several chunks of B bytes (where B is an argument of your
choice), each chunk is then separately hashed with
cSHAKE(custom_string=“”, . ) producing as many 256-bit output as
there are chunks. This step can be parallelized with SIMD instructions
or other techniques available on your architecture. Finally each output
is concatenated and hashed a final time with
cSHAKE(custom_string=“ParallelHash”, . ). Again, details have
been omitted.

]]>
Real World Crypto 2018 David Wong Mon, 11 Dec 2017 18:52:30 +0100 http://www.cryptologie.net/article/433/real-world-crypto-2018/ http://www.cryptologie.net/article/433/real-world-crypto-2018/#comments
<blockquote class="twitter-tweet" data-lang="en"><p lang="en" dir="ltr">Register for <a href="https://twitter.com/RealWorldCrypto?ref_src=twsrc%5Etfw">@RealWorldCrypto</a> 2018 soon or be disappointed. We are reaching our capacity.</p>— Nigel Smart (@SmartCryptology) <a href="https://twitter.com/SmartCryptology/status/940212072364699649?ref_src=twsrc%5Etfw">December 11, 2017</a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>

You might think it's too crypto-y for you, or not real-world enough. Think again. I'm not the only one who think this conference is awesome.

<blockquote class="twitter-tweet" data-lang="en"><p lang="en" dir="ltr">My favorite conference of the year, Real World Crypto, is coming up, and it’s in Zurich!<br><br>If you (broadly speaking) study crypto and wouldn’t attend because money, DM me something you made (a cryptopals solution, blog post, uni assignment…) and I’ll pay your registration.</p>— Filippo Valsorda (@FiloSottile) <a href="https://twitter.com/FiloSottile/status/939916067698290688?ref_src=twsrc%5Etfw">December 10, 2017</a></blockquote>

<blockquote class="twitter-tweet" data-lang="en"><p lang="en" dir="ltr">I met the Tor team and started the design that would become PrivacyPass at <a href="https://twitter.com/RealWorldCrypto?ref_src=twsrc%5Etfw">@RealWorldCrypto</a> in 2016 <a href="https://t.co/dkijEvmh8M">https://t.co/dkijEvmh8M</a> <a href="https://t.co/MBPvD11mns">https://t.co/MBPvD11mns</a></p>— George Tankersley (@gtank__) <a href="https://twitter.com/gtank__/status/938228341357907968?ref_src=twsrc%5Etfw">December 6, 2017</a></blockquote>

<blockquote class="twitter-tweet" data-lang="en"><p lang="en" dir="ltr">RWC 2018: less rugby, more crypto(graphy). If you don't go, someone else will.</p>— Santiago Zanella (@xEFFFFFFF) <a href="https://twitter.com/xEFFFFFFF/status/940275565579440130?ref_src=twsrc%5Etfw">December 11, 2017</a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>

<blockquote class="twitter-tweet" data-lang="en"><p lang="en" dir="ltr">I can&#39;t make it to RWC2018 so I&#39;ll match Filippo&#39;s offer. Promise to send me a write-up of the best talk you attended at RWC and I&#39;ll pay for your registration. <a href="https://t.co/Da8eNuNVUB">https://t.co/Da8eNuNVUB</a><br><br>Preference goes to students and underrepresented groups in cryptography. <a href="https://t.co/ZWTapi7Pva">https://t.co/ZWTapi7Pva</a></p>&mdash; yan (@bcrypt) <a href="https://twitter.com/bcrypt/status/940060661932888064?ref_src=twsrc%5Etfw">December 11, 2017</a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>
]]>
Introducing Disco David Wong Fri, 08 Dec 2017 10:39:28 +0100 http://www.cryptologie.net/article/432/introducing-disco/ http://www.cryptologie.net/article/432/introducing-disco/#comments

I've introduced both the [Strobe protocol framework](https://www.cryptologie.net/article/416/the-strobe-protocol-framework/) and the [Noise protocol framework](https://www.cryptologie.net/article/349/the-noise-protocol-framework/) in the past. So I won't go over them again, but I advise you to read these two blog posts before reading this one (if you care about the technical details).

As a recap:

**1.** The [Strobe protocol framework](https://strobe.sourceforge.io) is a framework to build symmetric protocols. It's all based on the SHA-3 permutation (keccak-f) and the duplex construction. Codebase is tiny (~1000LOC) and it can also be used to build simple cryptographic operations.

**2.** The [Noise protocol framework](http://noiseprotocol.org) is a framework to build things like TLS. It's very simple and flexible, and I believe a good TLS alternative for today.

Looking at the previous diagram representing the NX handshake pattern of Noise (where a client is not authenticated and a server sends its long-term static key as part of the handshake) I thought to myself: I can simplify this. For example, you can see:

* an h value absorbing every messages being sent and received, and being used to authenticate the transcript at some points in the handshake.
* a ck value being used to derive keys from the different key exchanges happening during the handshake.

These things can be simplified greatly by using Strobe to get rid of all the symmetric tricks, while at the same time getting rid of all the symmetric primitives in use (AES-GCM, SHA-256, HMAC and HKDF).

This is exactly how I came up with [Disco](https://www.discocrypto.com/disco.html), merging Noise and Strobe to simplify the former.

Here is the simplification I made of the previous diagram. We're using Strobe's functions like send_CLR, recv_CLR and AD to absorb messages being sent or received as well as the output of the different key exchanges. We're also using send_AEAD and recv_AEAD to encrypt/decrypt and authenticate the whole transcript up to this point (these functions don't exist in Strobe, but they are basically send/recv_ENC followed by send/recv_MAC).

You can see that everything looks suddenly much more simple to implement or understand. send_CLR, recv_CLR and AD are all functions that do the same thing: they XOR the input with the rate (public part) of our strobe state. It is so elegant that I made another diagram showing what is **really** happening in this diagram with Strobe. (Something that I obviously couldn't have done with AES-GCM, SHA-256, HMAC and HKDF.)

You can see two lines here in the StrobeState. The capacity (secret part) is on the left and the rate (public part) is on the right. Most things get absorbed by just XORing the input with the public part (of course if we reach the end of the public part, we would permute and start on a new block like we do for hashing with the sponge construction).

When we send or receive encrypted data, we also need to do a little dance and first permute the state to produce something based on all of the data we've previously absorbed (including outputs of diffie-hellman key exchanges). This output is random enough to allow us to encrypt (or decrypt) by just imitating one-time pads and stream ciphers: XORing the randomized public part with a plaintext (or a ciphertext).

Once this is done, the state is permuted again to generate a new series of random numbers (in the public part) which will be the authentication tag, allowing us to authenticate everything that was absorbed previously.

After that the state can be cloned and differentiated to allow both sides to encrypt data on different channels (unless they want to use the same channel by taking turns). Strobe functions can continue to be used to continuously encrypt/decrypt application data and authenticate the whole transcript (starting from the first handshake message to the last message sent or received).

I thought the idea was worth exploring, and so I wrote a specification and proposed it as an extension to Noise. [You can read it here](https://www.discocrypto.com/disco.html)). Details are still being actively discussed on the [Noise mailing list](https://moderncrypto.org/mail-archive/noise/2017/thread.html). Major points of contention seem to be that the Strobe functions used do not introduce intra-handshake forward-secrecy, and that the post-handshake API does not mirror the Noise's post-handshake API one (nonce-based) by default. The latter is on purpose to avoid having to setup nonces and keeping track of them if not needed (because messages are expected to arrive in order thanks to the transport protocol used underneath disco).

After all of that, I figured out that I would probably have to be the first one to implement Disco. So I went ahead and first implemented a Noise-based protocol in Golang (that I call [NoisePlugAndPlay](https://github.com/mimoo/NoiseGo)). I tested it with test vectors and other libraries to get a minimum amount of confidence in what I did, then I decided to implement Disco on top of it. The protocol I created is called [libdisco](https://www.discocrypto.com).

It's more than just a protocol to encrypt communications though. Since I'm using Strobe, I can also make it a symmetric cryptographic library without adding much lines of code (100 wrapping lines of code to be exact).

Of course it's all **experimental**. I will not recommend anyone to use this in production.

Instead, play with it and appreciate the concepts. Down the line, this could really be the modern alternative to TLS we've been waiting for (of course I'm biased here). But the road is long and paved with issues that need better be fixed before entering a stable version.

If I caught your interest, go take a look at [www.discocrypto.com](https://www.discocrypto.com).

]]>
My talk on SHA-3 and derived functions at DEF CON 25 David Wong Sat, 02 Dec 2017 11:52:06 +0100 http://www.cryptologie.net/article/431/my-talk-on-sha-3-and-derived-functions-at-def-con-25/ http://www.cryptologie.net/article/431/my-talk-on-sha-3-and-derived-functions-at-def-con-25/#comments
<iframe width="760" height="515" src="https://www.youtube.com/embed/BJnjAF2cz48" frameborder="0" allowfullscreen></iframe>

]]>