Draft: draft-ietf-lake-edhoc

Commentary: I think it would be good to point out early that the EDHOC protocol ( just like TLS ) only provides proof - of - possesion . Authentication has to be done by the application . I have seen horrible uses of TLS where the implementors believe RFC 8446 when it says it provides authentication . Added text for " Unauthenticated Operation " . As pointed out by  , this is more general than just TOFU . " Unauthenticated operation " is the term used by TLS 1.3 
 I think this is ready to merge . 
 The selfie attack mitigation implies that an initiator is stopping the exchange if it receives its own identity . An active attacker can then use this behavior to test if an initiator identity is the same one as a responder identity . In turn , it implies that the initiator anonymity does not hold against an active attacker when this mitigation is enabled . To judge if this is an issue in practice , the following question should be answered : Are there scenarios where an identity is shared between an initiator and a receiver , but the initiator identity should still be protected ? One could maybe think about the case where multiple initiators and receivers are on the same server , sometimes sharing public keys and using distinct ports , but it is expected that the initiators identities are still protected . Possible actions : mention privacy loss due to the selfie attack mitigation . update the selfie attack mitigation , by mentioning that initiators should conclude the exchange as usual , but can check at the end whether they are talking to themselves or not . remove the selfie attack mitigation . Classical selfie attacks are when there is a pre - shared key between an initiator and a receiver , and the initiator will be talking to itself while it believes to be talking to the receiver . When there are only public keys , as in EDHOC , it is unclear to me if what is currently called in the draft is indeed a selfie attack . An initiator talking to itself knows it and does not believe to be talking to some other identity . As such this is why it could be possible to either remove the mention of selfie attacks in the draft , or update it . 
 I and R are expected to stop the exchange it they receive any identity they do not want to talk to . This likely includes their own identity . Good point that this leaks information . I think that should be , but I do n't see that the own identity is special . Classical selfie attacks are when there is a pre - shared key between an initiator and a receiver , and the initiator will be talking to itself while it believes to be talking to the receiver . When there are only public keys , as in EDHOC , it is unclear to me if what is currently called in the draft is indeed a selfie attack . The selfie attack mitigation is intended for Trust On First Use ( TOFU ) use cases , where there is no authentication in the initial setup . I do n't think an initiator talking to itself in a TOFU use case would not know it except if they checked R 's public key . Do you some better suggestion than " Selfie attack " . I agree that it is not perfect . " Selfie attacks " has in older papers been called reflection attacks , but the term reflection attacks has also been used for very different attacks . One option is to not give the attack any name and instead just describe the attack . 
 I think I like to not give any name , as it does not perfectly match the classical definition . Here , the property which is violated is " If an EDHOC exchange is completed , two distinct identities / computers / agents were active " . Which is different to violating the authentication of the protocol as is the case in classical selfie attacks . Good point . So what we are talking about in this issue is a slightly different privacy leak , which happens when the set of parties you are willing to talk to is equal to all responders minus yourself . To be more concrete , let me try to put it in a kind of drafty formal description that could replace the existing formulation . First the existing formulation : Now a possible replacement : 
 Thanks for the input ! This issue is related to the TOFU use case which is still to be detailed ( Appendix D.5 ) . We probably should wait with the update until we have progressed that . 
 Relates to 
 I made PR for this issue . This is also related to PR and PR . The suggested text in is largely based on the suggested text above but I made some changes . I did not think this fitted well with the rest of the draft . The sentence was also not really needed . This is only true in the case where the set of identifiers is a small finite set . In the general case the set of identifiers the Initiator is not willing to communicate with is infinite . I suggest to add the following recommendation for TOFU To not leak any long - term identifiers , it is recommended to use a freshly generated authentication key as identity in each initial TOFU exchange . 
 I merged the PR to master . Keeping the issue open for a while . 
 The current text is not really explaining how TOFU works and the security considerations . Would be good with some more text . TOFU might also go agains requirements in other parts of the document that says that " EDHOC is mutually authenticated . 
 This is conflicting with present use of COSE . Requires a separate section in the draft , preferably an appendix . We need to describe the use case , trust model , how to use EDHOC and the security properties . Can we reference some other RFC ? 
 Looking at adding text on TOFU I think there is some more work to do . I do n't TOFU should require anything specicial . The Section " Identities and trust anchors { # identities } " is fluffy . It is not clear that this is just general recommendations that is outside the scope of the EDHOC protocol and the reposability of the application . EDHOC provides proof - of - possesion and transfers a credential that enables authentication . That s it . An EDHOC implementation might implemend Authentication for a specific use case , but that is still outside the EDHOC protocol . Any description of the interface between EDHOC and the application when it comes to credential is missing . In general EDHOC provides proof - of - possesion of the private key and then gives CRED_x to the application that says YES / NO . How the application does chain validation and identity validation ( or the lack of it like in TOFU ) is outside of EDHOC . 
 Status : This issue is waiting on a restructure , shortening , clarification on the responsibility of the EDHOC protocol and the application . and 
 The restructuring is done and merged with the master . Appendix D.5 is placeholder for TOFU . 
 I made PR for TOFU . As  pointed out this should be more general than TOFU . I changed the heading to " unauthenticated opearation " which is the term used by TLS 1.3 
 Merged adding text to the empty TOFU section . Closing 
 I made some minor updates , have a look .
Paragraph (version A):
EDHOC is designed to encrypt and integrity protect as much
information as possible, and all symmetric keys are derived using as
much previous information as possible.  EDHOC is furthermore designed
to be as compact and lightweight as possible, in terms of message
sizes, processing, and the ability to reuse already existing CBOR,
COSE, and CoAP libraries.
Paragraph (version B):
EDHOC is designed to encrypt and integrity protect as much
information as possible, and all symmetric keys are derived using as
much previous information as possible.  EDHOC is furthermore designed
to be as compact and lightweight as possible, in terms of message
sizes, processing, and the ability to reuse already existing CBOR,
COSE, and CoAP libraries.  Like (D)TLS, authentication is the
responsibility of the application, EDHOC identifies (and optionally
transports) authentication credentials, and provides proof-of-
possession of the private authentication key.
Paragraph (version A):
So-called selfie attacks are mitigated as long as the Initiator does
not have its own identity in the set of Responder identities it is
allowed to communicate with.  In trust on first use (TOFU) use cases
the Initiator should verify that the Responder's identity is not
equal to its own.  Any future EHDOC methods using e.g., pre-shared
keys might need to mitigate this in other ways.
Paragraph (version B):
So-called selfie attacks are mitigated as long as the Initiator does
not have its own identity in the set of Responder identities it is
allowed to communicate with.  In Trust on first use (TOFU) use cases,
see tofu, the Initiator should verify that the Responder's identity
is not equal to its own.  Any future EHDOC methods using e.g., pre-
shared keys might need to mitigate this in other ways.