Original text:
1. <del> DISCLAIMER: This is a work-in-progress draft of MLS and has not yet seen significant security analysis.  It should not be used as a basis for building production systems. </del> RFC EDITOR: PLEASE REMOVE THE FOLLOWING PARAGRAPH The source for this draft is maintained in GitHub.  Suggested changes should be submitted as pull requests at https://github.com/mlswg/mls-protocol. Update messages SHOULD be sent at regular intervals of time as long as the group is active, and members that don't update SHOULD eventually be removed from the group.  It's left to the application <del> to determine an appropriate amount of time between Updates. </del>  Members are removed from the group in a similar way.  Any member of the group can send a Remove proposal followed by a Commit message. MUST be filled with all zero bytes.  A receiver MUST verify that there are no non-zero bytes in the "padding" field, and if this check fails, the enclosing MLSCiphertext MUST be rejected as malformed.  In the MLS key schedule, the sender creates two distinct key ratchets for handshake and application messages for each member of the group. The length of the "padding" field in "MLSCiphertextContent" can be chosen at the time of message encryption by the sender.  Senders may use padding to reduce the ability of attackers outside the group to <del> infer the size of the encrypted content. </del>  15.2.

Reviewer comments:
Thanks to Gorry Fairhurst: URL Reviewer: Gorry Fairhurst Review result: On the Right Track This is an early review of draft-ietf-mls-protocol-16, which seeks to specify a key establishment protocol to provide scalable efficient asynchronous group key establishment. This document seems to define a component that could be used to build or operate over an Internet transport. The focus is on security algorithms and procedures. There are some issues that Major Issue: This would have been easier to understand if there was a section that described the transport requirements of the messages. This makes me wonder what transport service is actually needed? - Can the underlying transport reorder messages? Is loss tolerated or reliability required? Are there any requirements on message size? etc. A brief paragraph explicitly explaining the requirements would help. A later statement says, which appears to suggest any service can be used: "MLS is an encrypted messaging layer designed to be transmitted over arbitrary lower layer protocols....." I note draft-ietf-mls-architecture states: "MLS is not intended as a full instant messaging protocol but rather is intended to be embedded in concrete protocols, such as XMPP [RFC6120]." This could form a part of such an explanation, if it applies to this ID also? Major Issue: The document targets PS, but the version I reviewed added a "DISCLAIMER: This is a work-in-progress draft of MLS and has not yet seen significant security analysis. It should not be used as a basis for building production systems." - Why is the final document proposed as a PS rather than EXP, if this is not for general deployment? Or is this clause to be removed by RFC-Ed? Major Issue: From a transport perspective, there are issues in the statement providing insufficient guidance on selecting a rate: "Update messages SHOULD be sent at regular intervals of time as long as the group is active, and members that don't update SHOULD eventually be removed from the group. It's left to the application to determine an appropriate amount of time between Updates." One possible way to address this is to state that the messages are either sent over a congestion-controlled transport or the maximum aggregate rate of messages falls within a specific guideline as defined in RFC8085, or some other BCP with similar advice on rate selection. Minor: " Application messages MAY be padded to provide some resistance against traffic analysis techniques over encrypted traffic [CLINIC] [HCJ16]." - Padding is a well known technique - it can have benefits and also have drawbacks, e.g. in efficiency of transmission and for message-based transfers in reducing robustness to paths that have limited PMTU, where larger messages can be dropped. Minor: " A receiver MUST verify that there are no non-zero bytes in the padding field, and if this check fails, the enclosing MLSCiphertext MUST be rejected as malformed." - I don't doubt that this is useful, but it would be helpful to add a sentence to explain why these are required to be encoded as zero.

Revised text:
1.  RFC EDITOR: PLEASE REMOVE THE FOLLOWING PARAGRAPH The source for this draft is maintained in GitHub.  Suggested changes should be submitted as pull requests at https://github.com/mlswg/mls-protocol. Update messages SHOULD be sent at regular intervals of time as long as the group is active, and members that don't update SHOULD eventually be removed from the group.  It's left to the application  <ins> to determine an appropriate amount of time between Updates.  In general, however, applications should take care that they do not send MLS messages at a rate that overwhelms the transport over which messages are being sent. </ins> Members are removed from the group in a similar way.  Any member of the group can send a Remove proposal followed by a Commit message. MUST be filled with all zero bytes.  A receiver MUST verify that there are no non-zero bytes in the "padding" field, and if this check fails, the enclosing MLSCiphertext MUST be rejected as malformed. <ins> This check ensures that the padding process is deterministic, so that, for example, padding cannot be used as a covert channel. </ins> In the MLS key schedule, the sender creates two distinct key ratchets for handshake and application messages for each member of the group. The length of the "padding" field in "MLSCiphertextContent" can be chosen at the time of message encryption by the sender.  Senders may use padding to reduce the ability of attackers outside the group to  <ins> infer the size of the encrypted content.  Note, however, that the transports used to carry MLS messages may have maximum message sizes, so padding schemes SHOULD avoid increasing message size beyond any such limits that exist in a given deployment scenario. </ins> 15.2.