Re: [MLS] Improving entropy in MLS

Great questions. I really should have included our thoughts on the threat model.

We don't assume the entropy pool to be more protected than any other secret in MLS.

Functionally, we want the pool to allow the following: 
- a party should be able to accrue entropy over time using the OS's RNG
- a party should be able to inject entropy from other sources (in particular secrets derived from the epoch_secret of any of the party's groups whenever a fresh commit comes in)

Assuming the OS's RNG is really bad (e.g. it spits out only zeroes), then a party can still have decent entropy once it receives commits from groups that it is in. Any party that wants to predict the entropy in the pool would have to know every secret that is injected into the pool. That means that an adversary would have to compromise all of the party's groups to predict secrets extracted from the entropy pool.

Of course, the pool will take some time to accrue entropy from various sources, so it doesn't help if the adversary is present from the start, but it will help if the adversary compromises a party later on. If that happens, then the compromised party can recover if the adversary misses (i.e. doesn't intercept and decrypt) any commit from another party after the compromise.

Now we have to make sure that the design doesn't give us any disadvantages over just sampling from the OS's RNG every time we need fresh randomness.

Let's assume full state compromise. Then
1) the adversary can't obtain entropy extracted from the pool in the past (because it's essentially a KDF-chain, just as the key schedule)
2) the adversary can't predict what entropy the client will extract in the future if one of the following is true:
  - the OS's RNG is good
  - a commit from a group arrives, where the group itself is not compromised
  - any other external entropy gets injected that the adversary doesn't have access to (e.g. a signature from a secret key that is kept secure in an HSM)

To summarize: It's no silver bullet against bad entropy in general, but it's cheap, no worse than just relying on the OS's RNG and provides a framework to accrue randomness over time from various sources even if the OS's RNG is bad/compromised and it allows parties to recover from compromise in that case.

Hope that shed some light on things.

Cheers,
Konrad

> Benjamin Beurdouche <benjamin.beurdouche@inria.fr> hat am 30.03.2021 09:53 geschrieben:
> 
>  
> Hi all,
> 
> I like this idea. I am not fully clear about the threat model, though.
> 
> From reading this, it looks like we assume that the adversary that compromised a 
> principal doesn’t have complete control the entropy pool.
> 
> This is in contrast over what we assume of the AEAD keys or even the KEM keys
> where a full state compromise will gain access to the values.
> 
> However it looks very close to the assumptions about additional protections for signing keys.
> E.g., not directly accessible, and behind an interface that an adversary can query for certain operations
> through an API (e.g. when is stored in an HSM, co-processor or a functional secure enclave).
> 
> Am I reading this properly?
> If yes, I can understand the value in this threat model, but we should make it clear that the
> entropy pool has to get these additional protections to provide these good properties.
> 
> Seems to me like a good improvement in all cases anyway, so I think we should consider it.
> 
> Thanks!
> Ben
> 
> > On 30 Mar 2021, at 09:27, Konrad Kohbrok <konrad.kohbrok@datashrine.de> wrote:
> > 
> > Hi everyone,
> > 
> > MLS is a protocol that is very vulnerable to individual parties with bad randomness. For example, when a party joins a group, the secrecy of the group's key material relies on the quality of that party's key material. Similarly, when doing an external join, the groups entropy is completely replaced by that of the joining member.
> > 
> > There are multiple ways to mitigate this threat and Joël and Sandro proposed a few of them in the following mail to the list: https://mailarchive.ietf.org/arch/msg/mls/ZR84smU5xeLrziNTk5W1P1Z1nQI/
> > 
> > Concretely, there were two approaches: one that would be baked into the protocol (essentially using a secret derived from old path secrets to inject into new ones in addition to the current approach) and one that would mandate the use of an entropy pool.
> > 
> > The ideas were discussed a bit at the time, but nothing has happened since then. Joël, Sandro and I have just opened a PR with a concrete design for an entropy pool that is modeled after the key schedule (https://github.com/mlswg/mls-protocol/pull/467). Concretely, it allows gathering entropy over time and for parties with a bad entropy source to profit from parties with a good one without compromising security.
> > 
> > While for future iterations of MLS, we might want to consider a solution that is more integral to the protocol, we are aware that the authors want to avoid breaking changes at this point. With the entropy pool, we thus propose a solution that does not affect the protocol flow, but that still offers significant advantages over no mitigations at all.
> > 
> > Cheers,
> > Konrad
> > 
> > _______________________________________________
> > MLS mailing list
> > MLS@ietf.org
> > https://www.ietf.org/mailman/listinfo/mls