RFC 6509

MIKEY-SAKKE: Sakai-Kasahara Key Encryption in Multimedia Internet KEYing (MIKEY)

📅 published February 2012, from ietf

RFC 6509 ✨ MIKEY-SAKKE: Sakai-Kasahara Key Encryption in Multimedia Internet KEYing (MIKEY) 🎀

okay bestie, let's get into this one 💅 It's an Informational RFC (so it's published for info, not as an Internet Standard 🌸), written by M. Groves from CESG 💜, dated February 2012 📅. It's been assigned ISSN 2070-1721 ✨. Quick heads up on the title block: this doc doesn't obsolete anything and doesn't update anything, so there's no drama there 🙈

Here's the vibe: MIKEY-SAKKE is a key exchange method that uses Identity-based Public Key Cryptography (IDPKC) to set up a shared secret, plus certificateless signatures for source authentication 🦋. It's giving low-latency call setup, simplex transmission, scalability, and secure deferred delivery, all in one pretty package 🫶

Status of This Memo 🌈

This document is not an Internet Standards Track specification. It's published for informational purposes 💜

This document is a product of the Internet Engineering Task Force (IETF). It was approved for publication by the Internet Engineering Steering Group (IESG). Not every document the IESG approves is a candidate for any level of Internet Standard, so check Section 2 of RFC 5741 for the details 🧚

Want the current status, any errata, or a way to send feedback? Head to http://www.rfc-editor.org/info/rfc6509 ✨

Copyright (c) 2012 IETF Trust and the persons identified as the document authors. All rights reserved 💅

This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (http://trustee.ietf.org/license-info) as they stood on the date of publication 🌸 Please actually read these, bestie, because they spell out your rights and restrictions for this doc. Any Code Components pulled out of this document must include Simplified BSD License text, as described in Section 4.e of the Trust Legal Provisions, and they come with no warranty, as the Simplified BSD License describes 🔥

1. Introduction 💖

Multimedia Internet KEYing (MIKEY) [RFC3830] is a protocol framework for key distribution. It specifies key distribution methods that use pre-shared keys, RSA, and, optionally, a Diffie-Hellman Key Exchange 🧚 Since the original spec, people have proposed a bunch of alternative key distribution methods for MIKEY, like [RFC4650], [RFC4738], [RFC6043], and [RFC6267] 💜

This document describes MIKEY-SAKKE, a method for key exchange and source authentication. It's designed for use in IP Multimedia Subsystem (IMS) [3GPP.33.328] Media Plane Security, but it has potential for wider applicability 🦋 The scheme uses a Key Management Service (KMS) as a root of trust and as a distributor of key material. The KMS gives users assurance that the peers they talk to are authentic ✨ Unlike traditional key distribution systems, MIKEY-SAKKE does not require the KMS to offer high availability 🙌 It only needs to distribute new keys to its users periodically 🌈

MIKEY-SAKKE is made of two parts: an Identity-based Public Key Cryptography (IDPKC) scheme based on the one from Sakai and Kasahara [S-K], and a source authentication algorithm tailored to use Identifiers instead of certificates 💅 The algorithms behind this protocol are described in [RFC6507] and [RFC6508] 🎀

The main motivation for the MIKEY protocol design is the low-latency requirement of real-time communication, so lots of the defined exchanges finish in one-half to one roundtrip ⭐ Some exchanges, like those in [RFC6043] and [RFC6267], extend the latency on purpose to provide additional security 🙈 MIKEY-SAKKE gets similarly enhanced security, but it only needs a single simplex transmission (one-half roundtrip) 🔥

MIKEY-SAKKE also supports scenarios like forking, retargeting, deferred delivery, and pre-encoded content 🧚

1.1. Requirements Terminology 🫶

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in [RFC2119] 💖

2. A New MIKEY Mode: MIKEY-SAKKE 🦋

2.1. Outline ✨

The proposed MIKEY mode needs just a single simplex transmission. The Initiator sends a MIKEY I_MESSAGE to the intended recipient, containing SAKKE Encapsulated Data and a signature 💜 The Responder MUST validate the signature 🔥 Once the signature is validated, the Responder processes the Encapsulated Data using the operations defined in [RFC6508] to derive a Shared Secret Value (SSV) 🌸 This SSV is used as the TGK (the TEK Generation Key defined in [RFC3830]) 🧚

The Responder doesn't need to send a verification message back (like in pre-shared key mode, for example), because the parties are mutually authenticated once the single I_MESSAGE is processed 🙌 The notation used for MIKEY messages and their payloads in Figure 1, and throughout the rest of this document, is defined in [RFC3830] 💅

         Initiator                                   Responder

         I_MESSAGE =
         HDR, T, RAND, [IDRi], [IDRr], [IDRkmsi], [IDRkmsr],
         [CERT], {SP}, SAKKE, SIGN        --->

                 Figure 1: MIKEY-SAKKE Unicast Mode

The Initiator wants a secure media session with the Responder 🎀 Both of them trust a third party, the KMS, which provisions them with key material through a secure mechanism 🦋 Besides the public and secret keys that match their Identifier, the KMS MUST provision devices with its KMS Public Key and, where [RFC6507] is used, its KMS Public Authentication Key 💖 Section 2.1.2 has a full description of all the key material used in MIKEY-SAKKE 🧚 The Initiator and the Responder don't share any credentials; instead, the Initiator can derive the Responder's public Identifier 🫶

Implementations MAY support multiple KMSs. In that case, instead of one KMS, several different KMSs could be involved, e.g., one for the Initiator and one for the Responder 🌈 To make this work, each interoperating KMS MUST give its users the KMS public keys for every KMS subscriber domain its users communicate with 💜 It isn't expected that large mutually communicating groups of KMSs will be needed 🙈 Each KMS only has to give its domain of devices key material once per key period (see Section 3.3), rather than being active in every call ✨

As MIKEY-SAKKE is based on [RFC3830], the same terminology, processing, and considerations still apply unless otherwise stated 💅 Following [RFC3830], messages are integrity protected, and encryption is not applied to entire messages 🌸

2.1.1. Parameters 🎀

[RFC6508] requires each application to define the set of public parameters that implementations use. The parameters in Appendix A SHOULD be used in MIKEY-SAKKE; alternative parameters MAY be defined later; see Section 4.2 🦋

[RFC6507] requires each application to define the hash function and various other parameters to be used (see Section 4.1 of [RFC6507]). For MIKEY-SAKKE, the P-256 elliptic curve and base point [FIPS186-3] and SHA-256 [FIPS180-3] MUST be used 🔥

2.1.2. Key Types 💖

Users need keys for [RFC6508] and for signing messages. These keys MUST be provided by the users' KMS 🧚 It is RECOMMENDED that implementations support the signature scheme described in [RFC6507] 💜 Alternatively, RSA signing as defined in [RFC3830] MAY be used 🫶

SAKKE keys

SAKKE requires each user to have a Receiver Secret Key, created by the KMS, and the KMS Public Key 🌈 For systems that support multiple KMSs, each user also needs the KMS Public Key of every KMS subscriber domain they're authorized to communicate with 💅

ECCSI keys

If the Elliptic Curve-based Certificateless Signatures for Identity-based Encryption (ECCSI) signatures are used, each user requires a Secret Signing Key and Public Validation Token, both created by the KMS, plus the KMS Public Authentication Key 🦋 For systems that support multiple KMSs, each user also needs the KMS Public Authentication Key of every KMS subscriber domain they're authorized to communicate with 🎀

If RSA signatures are used instead, certificates and corresponding private keys MUST be supplied 🔥

2.2. Preparing and Processing MIKEY-SAKKE Messages 🌸

Preparation and parsing of MIKEY messages are described in Sections 5.2 and 5.3 of [RFC3830] 🧚 Error handling is in Section 5.1.2, and replay protection guidelines are in Section 5.4 of [RFC3830] ⭐ Below, we describe the components of MIKEY-SAKKE messages and specify message processing and parsing rules in addition to the ones in [RFC3830] 💜

(Part 1 of 5, more to come, stay tuned bestie 🫶✨)

2.2.1. Components of the I_MESSAGE ✨

MIKEY-SAKKE only needs one simplex transmission (a half roundtrip) to set up a shared TGK 🦋. The I_MESSAGE MUST contain the MIKEY Common Header Payload HDR defined in [RFC6043] along with the timestamp payload, which is what gives you replay protection 🔒. The HDR field holds a CSB_ID (Crypto Session Bundle ID) that the Initiator picks at random. The V bit in the HDR payload MUST be set to '0' and ignored by the Responder, since a response is not expected in this mode 🙈. The timestamp payload MUST use TS type NTP-UTC (TS type 0) or NTP (TS type 1) as defined in Section 6.6 of [RFC3830], so the Responder can work out which Identifiers the Initiator used (see Section 3.2) 🕰️. It is RECOMMENDED that the time always be specified in UTC 🌍.

The I_MESSAGE MUST be signed by the Initiator, either using the procedure for signing MIKEY messages specified in [RFC3830] or using [RFC6507] as specified in this document ✍️. The SIGN payload carries this signature, so the I_MESSAGE is integrity and replay protected 💅. The ECCSI signature scheme [RFC6507] SHOULD be used. If this signature scheme is used, then the Initiator MUST NOT include a CERT payload. To form this signature type, the Initiator needs a Secret Signing Key, which is provided by the KMS 🔑.

Other signature types defined for use with MIKEY MAY be used. If signature types 0 or 1 (RSA) are used, then the Initiator SHOULD include a CERT payload. In that case, the CERT payload MAY be left out if it is expected that the Responder can get the certificate some other way. If a CERT payload is included, it MUST correspond to the private key used to sign the I_MESSAGE 📜.

The Initiator MUST include a RAND payload in the I_MESSAGE, because this is what's used to derive session keys 🎲.

The identities of the Initiator, the Responder, the Initiator's KMS (the root of trust for authenticating the Initiator), and the Responder's KMS (the root of trust for authenticating the Responder) MAY be contained in the IDRi, IDRr, IDRkmsi, and IDRkmsr I_MESSAGEs, respectively 🪪. The ID Payload with Role Indicator (IDR) is defined in [RFC6043] and modified in Section 4.4. When it's used, this payload provides the Identifier for any of the Initiator, the Responder, and their respective KMSs 💫.

The ID Role MUST be the Initiator (value 1) for the IDRi payload and the Responder (value 2) for the IDRr payload. The Initiator's ID is used to validate signatures [RFC6507]. If included, the IDRi payload MUST contain the URI of the Initiator incorporated in the Identifier used to sign the I_MESSAGE (see Section 3.2). If included, the IDRr payload MUST contain the URI of the Responder incorporated in the Identifier that the Initiator used in SAKKE (see Section 3.2). If included, the ID Role MUST be the Initiator's KMS (value 6) for the IDRkmsi payload and the Responder's KMS (value 7) for the IDRkmsr payload, and it MUST correspond to the KMS used as root of trust for the signature (for the IDRkmsi payload) and the KMS used as the root of trust for the SAKKE key exchange (for the IDRkmsr payload) 🎯.

It is OPTIONAL to include any IDR payloads, because in some user groups the Identifiers could be inferred by other means, e.g., through the signaling used to set up a call 📞. Also, a closed user group could rely on only one KMS, whose identity will be understood and so doesn't need to be included in the signaling 🫶.

The I_MESSAGE MUST contain a SAKKE payload constructed as defined in Section 4.2 🧁.

The Initiator MAY also send security policy (SP) payload(s) containing all the security policies that it supports 📋. If the Responder doesn't support any of the policies included, it SHOULD reply with an error message of type "Invalid SPpar" (Error no. 10) 🙅‍♀️. The Responder has the option not to send that error message in MIKEY if a generic session establishment failure indication is considered appropriate and is communicated via other means (see Section 4.1.2 of [RFC4567] for additional guidance) 🌸.

2.2.2. Processing the I_MESSAGE 🔍

The Responder MUST process the I_MESSAGE according to the rules specified in Section 5.3 of [RFC3830]. The following additional processing MUST also be applied 💖.

  • If the Responder does not support the MIKEY-SAKKE mode of operation, or otherwise cannot correctly parse the received MIKEY message, then it SHOULD send an error message "Unsupported message type" (Error no. 13) 😭. Error no. 13 is not defined in [RFC3830], so implementations compliant with [RFC3830] MAY return an "Unspecified error" (Error no. 12) 🤷‍♀️.
  • The Responder MAY compare the IDi payload against its local policy to decide whether it wants to establish secure communications from the Initiator 👀. If the Responder's policy does not allow this communication, then the Responder MAY respond with an "Auth failure" error (Error no. 0) 🚫.
  • If the Responder supports MIKEY-SAKKE and has determined that it wishes to establish secure communications with the Initiator, then it MUST verify the signature according to the method described in Section 5.2.2 of [RFC6507] if it is of type 2, or according to the certificate used if a signature of type 0 or 1 is used 🕵️‍♀️. If the signature verification fails, then an "Auth failure" error (Error no. 0) MAY be sent to the Initiator 💀.
  • If the authentication is successful, then the Responder SHALL process the SAKKE payload and derive the SSV according to the method described in [RFC6508] 🏆.

2.3. Forking and Retargeting 🌀

Where forking is to be supported, Receiver Secret Keys can be held by multiple devices 📱📱. To make this work, the Responder needs to load their Receiver Secret Key into each device that they want to receive MIKEY-SAKKE communications on 🔐. If forking happens, each of these devices can process the SAKKE payload, and each can verify the Identifier of the Initiator because they all hold the KMS Public Authentication Key ✅. That means the traffic keys could be derived by any of these devices 🫣. However, this is true for any scheme that uses simplex transmission, and it's considered that the advantages of this type of scheme are significant for many users 🌈. Also, it's up to the owner of the Identifier to decide which devices are allowed to load their Receiver Secret Key, so it's expected that they would have control over every device that holds it 👑. This reasoning also applies to things like call centers, where the security relationship is typically between the call center and the person calling in, rather than the particular operator who picks up 📞💅.

Devices holding the same Receiver Secret Key ought to each hold a different Secret Signing Key that corresponds to the same Identifier 🗝️. This works because the Elliptic Curve-based Certificateless Signatures for Identity-based Encryption (ECCSI) scheme lets the KMS generate multiple keys for the same Identifier ✨.

Secure retargeted calls can only be set up when the Initiator knows the Identifier of the device the call is being retargeted to. In that case, the Initiator ought to start a new MIKEY-SAKKE session with the device it has been retargeted to (if it's willing to) 🎯. Retargeting an Initiator's call to another device (with a different Identifier) is to be viewed as insecure when the Initiator is unaware that this has happened, because it prevents authentication of the Responder 😱.

2.4. Group Communications 👯‍♀️

SAKKE supports key establishment for group communications 💞. The Initiator needs to form an I_MESSAGE for each member of the group, all using the same SSV 📨. Alternatively, a bridge can be used. In that case, the bridge forms an I_MESSAGE for each member of the group 🌉. Any member of the group can invite new members directly by forming an I_MESSAGE using the group SSV 🎀.

2.5. Deferred Delivery 💌

Deferred delivery (secure voicemail) is fully supported by MIKEY-SAKKE 📼. A deferred delivery server that supports MIKEY-SAKKE needs to store the MIKEY-SAKKE I_MESSAGE along with the encrypted data 🗄️. When the recipient of the voicemail requests their data, the server needs to initiate MIKEY-SAKKE using the stored I_MESSAGE 🔁. That means the data can be received and decrypted only by a legitimate recipient, who can also verify the Identifier of the sender 🥰. This requires no additional support from the KMS, and the deferred delivery server doesn't need to be trusted, since it can't read or tamper with the messages it receives 🛡️. Note that the deferred delivery server does not need to fully implement MIKEY-SAKKE just to store and forward the I_MESSAGE 🧚.

The deferred delivery message needs to be collected by its recipient before the key period in which it was sent expires (see Section 3.3 for a discussion of key periods) ⏳. Alternatively, if you want greater longevity for deferred delivery payloads, the Initiator needs to include an I_MESSAGE for each key period during the lifetime of the deferred delivery message, all using the same SSV 🔄. In that case, the deferred delivery server needs to forward the I_MESSAGE for the current key period to the recipient 📬.

3. Key Management 🔑

3.1. Generating Keys from the Shared Secret Value 🌟

Once a MIKEY-SAKKE I_MESSAGE has been successfully processed by the Responder, the Responder will share an authenticated SSV with the Initiator 🤝. This SSV is used as the TGK 🎀. The keys used to protect application traffic are derived as specified in [RFC3830] 💜.

3.2. Identifiers ✨

okay so the big flex of Identity-Based Encryption (IBE) is that your public key IS your Identifier 🔑 and your peers can build it themselves! no Public Key or Certificate servers needed, so all the data transmission per session can happen directly between the peers, and you don't need high-availability security infrastructure 🫶 but for Identifiers to be constructable they have to be unambiguously defined, so this section lays out the format for MIKEY-SAKKE Identifiers 💅

if keys get updated regularly, a KMS can revoke devices, and that's the whole point 🙈 so every Identifier for use in MIKEY-SAKKE MUST contain a timestamp showing the key period it's valid for (see Section 3.3). this document uses a year and month format to enforce monthly changes of key material. further Identifier schemes MAY be defined for communities that need different key longevity ✨

an Identifier for use in MIKEY-SAKKE MUST take the form of a timestamp formatted as a US-ASCII string [ASCII] and terminated by a null byte, followed by identifying data which relates to the identity of the device or user. that identifying data is also a US-ASCII string terminated by a null byte 🎀

for this document, the timestamp MUST take the form of a year and month value, formatted according to [ISO8601], with the format "YYYY-MM". that means a four-digit year, then a hyphen "-", then a two-digit month 🌸

for the Identifier scheme defined here, the identifying data MUST take the form of a constrained "tel" URI. if somebody wants to use an alternative URI scheme to form SAKKE Identifiers, a subsequent RFC MUST define constraints so the URI can be formed unambiguously. the normalization procedures described in Section 6 of [RFC3986] MUST be used as part of the constraining rules for the URI format. it would also be possible to define Identifier types that use identifying data other than a URI 🧚

the restrictions for the "tel" URI scheme [RFC3966] when used in MIKEY-SAKKE Identifiers are:

  • the "tel" URI for use in MIKEY-SAKKE MUST be formed in global notation,
  • visual separators MUST NOT be included,
  • the "tel" URI MUST NOT include additional parameters, and
  • the "tel" URI MUST NOT include phone-context parameters.

these constraints are necessary so that all parties can unambiguously form the "tel" URI 💜

for example, say a user's telephone number is +447700900123 and the month is 2011-02. then the user's Identifier is defined as this ASCII string, where \0 means the null 8-bit ASCII character 0x00 🍓

2011-02\0tel:+447700900123\0

if it's included in I_MESSAGE, the IDRi and IDRr payloads MUST contain the URI used to form the Identifier. and the month used to form the Identifiers MUST be equal to the month specified by the data in the timestamp payload. no mismatches, bestie 😭

3.3. Key Longevity and Update 🌈

Identifiers for use in MIKEY-SAKKE change regularly so users are forced to keep updating their key material. we call the interval a key is valid a "key period" 📅 this means that if a device is compromised (and that gets reported procedurally), it can keep communicating with other users for at most one key period 💀

key periods SHOULD be indicated by the granularity of the timestamp format used in the Identifier. the Identifier scheme in this document uses monthly key periods. implementations MUST allow devices to hold two periods' keys at the same time, to allow for differences in system time between the Initiator and Responder ⏰

where a monthly key period applies, it is RECOMMENDED that implementations receive the new key material before the second-to-last day of the old month. they should start allowing receipt of calls with the new key material on the second-to-last day of the old month, and keep allowing receipt of calls with the old key material on the first and second days of the new month. devices SHOULD cease to receive calls with key material for the previous month on the third day of the month. this is so compromised devices can get keyed out of the communicating user group 🔥

KMSs MAY update their KMS Master Secret Keys and KMS Master Secret Authentication Keys. if that update isn't deemed necessary, the corresponding KMS Public Keys and KMS Public Authentication Keys will be fixed. if KMS keys are going to be updated, that update MUST happen at the change of a key period, and new KMS Public Key(s) and KMS Public Authentication Key(s) MUST be provided to all users with their user key material 👑

it is NOT RECOMMENDED for KMSs to distribute multiple key periods' keys at the same time, because that stops the periodic change of keys from excluding compromised devices 🙅‍♀️

3.4. Key Delivery 🎁

this document doesn't try to restrict the mechanisms used to get the necessary key material from the KMS. the mechanisms of [RFC5408] aren't suitable for this application, because the MIKEY-SAKKE protocol doesn't require public parameters to be obtained from a server. those are fixed for all users so things stay interoperable and simple to implement 🧁

the delivery mechanism used MUST provide confidentiality to all secret keys, integrity protection to all keys, and mutual authentication of the device and the KMS. no shortcuts here 🛡️

4. Payload Encoding 🎀

this section describes the new SAKKE payload, plus the payloads that changed compared to [RFC3830]. a detailed description of MIKEY payloads is in [RFC3830] 📖

4.1. Common Header Payload (HDR)

an additional value is added to the data type and next payload fields 💖

  • Data type (8 bits): describes the type of message.
Data type | Value | Comment
-----------------------------------------------
SAKKE msg |  26   | Initiator's SAKKE message

Table 1: Data type (additions)

  • Next payload (8 bits): identifies the payload that is added after this payload.
Next payload | Value | Section
-------------------------------
SAKKE        |  26   | 4.2

Table 2: Next payload (additions)

  • V (1 bit): flag to indicate whether a response message is expected ('1') or not ('0'). it MUST be set to '0' and ignored by the Responder in a SAKKE message 🙅‍♀️

4.2. SAKKE Payload 🧚

the SAKKE payload contains the SAKKE Encapsulated Data as defined in [RFC6508] 🦋

 1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
! Next payload  ! SAKKE params  !   ID scheme   !  SAKKE data   ~
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
~ length (cont) !                  SAKKE data                   ~
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

Table 3: SAKKE payload

  • Next payload (8 bits): identifies the payload that is added after this payload.
  • SAKKE params (8 bits): indicates the SAKKE parameter set to be used.
SAKKE params                       | Value
------------------------------------------
Parameter Set 1 (See Appendix A)   |     1

Table 4: SAKKE params

  • ID scheme (8 bits): indicates the SAKKE identifier scheme to be used.
ID scheme                                    | Value
----------------------------------------------------
tel URI with monthly keys (See Section 3.2)  |     1

Table 5: ID scheme

  • SAKKE data length (16 bits): length of SAKKE data (in bytes).
  • SAKKE data (variable): the SAKKE Encapsulated Data, formatted as defined in Section 4 of [RFC6508].

4.3. SIGN Payload ✍️

to enable use of the ECCSI signature algorithm, which has efficiency benefits for use with Identity-based encryption, we define an additional signature type 🌟

  • S type (4 bits): indicates the signature algorithm applied by the Signer.
S type  | Value | Comments
-----------------------------------
 ECCSI  |   2   | ECCSI signature

Table 6: S type (additions)

4.4. IDR Payload 🪪

the IDR payload was defined in [RFC6043], but its definition only provided the facility to identify one KMS per exchange. since different KMSs could be used by the Initiator and Responder, this payload gets extended to define an ID Role for the KMS of the Initiator and the KMS of the Responder 💅

  • ID Role (8 bits): specifies the sort of identity.
ID Role                   | Value
---------------------------------
  Initiator's KMS (IDRkmsi) |  6
  Responder's KMS (IDRkmsr) |  7

Table 7: ID Role (additions)

5. Applicability of MIKEY-SAKKE Mode 🦋

MIKEY-SAKKE is suitable for a range of applications where secure communications under a clear trust model are needed 🔐 the KMS doesn't need high availability, since it only has to provide a periodic refresh of key material. devices get a high level of authentication, because the KMS acts as a root of trust for both key exchange and signatures 👑

6. Security Considerations ✨

Okay bestie, this section is SERIOUS but also iconic 💅 Unless it's explicitly said otherwise, all the security properties of the MIKEY protocol from [RFC3830] apply to MIKEY-SAKKE too 🔐 On top of that, MIKEY-SAKKE picks up some vibes from Identity-based cryptography 🦋 For example, by sticking the "date" onto the URI to make the Identifier, you basically don't need any key revocation mechanisms anymore 🙈 It is NOT RECOMMENDED for KMSs to hand out multiple months' keys at once in an IBE system, because then the monthly key change can't kick out compromised devices 💀

This solution gives protection that's suitable for high-security user groups, but it's also scalable enough for a LOT of users 😭🔥 Traffic keys cannot be derived by any infrastructure component other than the KMS 🫶

The effective security of the public parameters defined in this document is 112 bits 🌸, because that's what the 1024-bit prime p used in SAKKE gives you (see Section 7 of [RFC6508]). For similar parameter sizes, MIKEY-SAKKE gives you equivalent levels of effective security compared to other schemes of this type (like [RFC6267]) ✨ For efficiency and security reasons, it is RECOMMENDED to use a mode of AES-128 [AES] in the traffic application that MIKEY-SAKKE supplies key material to 💖 But users SHOULD be aware that the defined public parameters only offer 112 bits of security 👑 Following [SP800-57], this security strength is appropriate for protecting data until 2030 🎀

User identities cannot be spoofed, because the Public Authentication Token is tied to the sender's Identifier by the KMS 🧚 Specifically, the Initiator gets assurance that nobody other than a holder of the legitimate Receiver Secret Key can process the SAKKE Encapsulated Data, and the signature binds the holder of the Initiator's Secret Signing Key to the I_MESSAGE 🦋 Since the KMS hands these keys over through a secure channel, mutual authentication is provided 🫶 This mechanism protects against both passive and active attacks 💜

Okay, quick aside: if a caller needed to stay anonymous from every called party, the signature could be removed from the protocol 👀 A called user could then decide, based on local policy, whether to accept that secure session 🙈

6.1. Forking 🍓

Where forking is used, the view is that each device does NOT need its own separate Receiver Secret Key 💅 Instead, if a user wants their calls forked between their devices, they load the same Receiver Secret Key onto each one ✨ This doesn't compromise their security, because they control every one of those devices, and it matches the Initiator's expectation that they're authenticated to the owner of the Identifier they picked when starting the call 🌈

6.2. Retargeting 🎯

Since the forwarding server tells the Initiator about the change to the Responder's Identifier, the Initiator creates an I_MESSAGE that can ONLY be processed by this legitimate Responder 🔐 The Initiator MAY also choose to end the session after checking their local policy 🫶

6.3. Group Calls 👯‍♀️

Any device that has an SSV can potentially share it securely with any other device using SAKKE 🦋 So group calls can either be set up by an Initiator, or be extended to more Responders by any party that the original Initiator sent an I_MESSAGE to 💖

The Initiator in this context MAY be a conference bridge 🎀 If you need a mode where a bridge has no knowledge of the SSV, the role of the MIKEY-SAKKE Initiator MUST be carried out by one or more of the communicating parties, NOT by the bridge 😭

Where multi-way communications (rather than broadcast) are needed, the application using the supplied key material MUST make sure a suitable Initialization Vector (IV) scheme is used to prevent cryptovariable re-use 💀🔥

6.4. Deferred Delivery 📬

Secure deferred delivery is supported in a way where NO trust is placed on the deferred delivery server 👑 This is a HUGE advantage, because it removes the need for any secure infrastructure components beyond the KMS 🌟

7. IANA Considerations 📋

This document defines new values for the Data Type, Next Payload, and S type namespaces defined in [RFC3830], and for the ID Role namespace defined in [RFC6043] 🎀 IANA has added these assignments to the MIKEY Payload registry:

  • 26 - Data type (see Table 1) 💜
  • 26 - Next payload (see Table 2) 💜
  • 2 - S type (see Table 6) 💜
  • ID Role (see Table 7) 💜
    • 6 - Initiator's KMS (IDRkmsi) 🧚
    • 7 - Responder's KMS (IDRkmsr) 🧚

The SAKKE payload defined in Section 4.2 has two fields that IANA created and now maintains namespaces for in the MIKEY Payload registry 🌸 These are the 8-bit SAKKE Params field and the 8-bit ID Scheme field 🦋 IANA recorded the pre-defined values from Section 4.2 for each of the two namespaces 💅 Values in the range 1-239 SHOULD be approved through the Specification Required process, values in the range 240-254 are for Private Use, and the values 0 and 255 are Reserved according to [RFC5226] ✨

Here are the initial values for the SAKKE Params registry 👇 Each assignment is a SAKKE parameters name plus its associated value 🎀

   Value    SAKKE params      Definition
   -----    ------------      ----------
   0        Reserved
   1        Parameter Set 1   See Appendix A
   2-239    Unassigned
   240-254  Private Use
   255      Reserved

And here are the initial values for the ID scheme registry 🍓 Each assignment is an identifier scheme name plus its associated value 💖

   Value    ID Scheme                    Definition
   -----    ------------                 ----------
   0        Reserved
   1        tel URI with monthly keys    See Section 3.2
   2-239    Unassigned
   240-254  Private Use
   255      Reserved

8. References 📚

8.1. Normative References 🔥

  • [AES] NIST, "Advanced Encryption Standard (AES)", FIPS PUB 197, November 2001, http://www.itl.nist.gov/fipspubs/by-num.htm.
  • [ASCII] American National Standards Institute, "Coded Character Sets - 7-Bit American National Standard Code for Information Interchange (7-Bit ASCII)", ANSI X3.4, 1986.
  • [FIPS180-3] Federal Information Processing Standards Publication (FIPS PUB) 180-3, "Secure Hash Standard (SHS)", October 2008.
  • [FIPS186-3] Federal Information Processing Standards Publication (FIPS PUB) 186-3, "Digital Signature Standard (DSS)", June 2009.
  • [ISO8601] "Data elements and interchange formats -- Information interchange -- Representation of dates and times", ISO 8601:2004(E), International Organization for Standardization, December 2004.
  • [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997.
  • [RFC3830] Arkko, J., Carrara, E., Lindholm, F., Naslund, M., and K. Norrman, "MIKEY: Multimedia Internet KEYing", RFC 3830, August 2004.
  • [RFC3966] Schulzrinne, H., "The tel URI for Telephone Numbers", RFC 3966, December 2004.
  • [RFC3986] Berners-Lee, T., Fielding, R., and L. Masinter, "Uniform Resource Identifier (URI): Generic Syntax", STD 66, RFC 3986, January 2005.
  • [RFC6043] Mattsson, J. and T. Tian, "MIKEY-TICKET: Ticket-Based Modes of Key Distribution in Multimedia Internet KEYing (MIKEY)", RFC 6043, March 2011.
  • [RFC6507] Groves, M., "Elliptic Curve-Based Certificateless Signatures for Identity-Based Encryption (ECCSI)", RFC 6507, February 2012.
  • [RFC6508] Groves, M., "Sakai-Kasahara Key Encryption (SAKKE)", RFC 6508, February 2012.
  • [SP800-57] Barker, E., Barker, W., Burr, W., Polk, W., and M. Smid, "Recommendation for Key Management - Part 1: General (Revised)", NIST Special Publication 800-57, March 2007.

8.2. Informative References 📖

  • [3GPP.33.328] 3GPP, "IP Multimedia Subsystem (IMS) media plane security", 3GPP TS 33.328 10.0.0, April 2011.
  • [RFC4567] Arkko, J., Lindholm, F., Naslund, M., Norrman, K., and E. Carrara, "Key Management Extensions for Session Description Protocol (SDP) and Real Time Streaming Protocol (RTSP)", RFC 4567, July 2006.
  • [RFC4650] Euchner, M., "HMAC-Authenticated Diffie-Hellman for Multimedia Internet KEYing (MIKEY)", RFC 4650, September 2006.
  • [RFC4738] Ignjatic, D., Dondeti, L., Audet, F., and P. Lin, "MIKEY-RSA-R: An Additional Mode of Key Distribution in Multimedia Internet KEYing (MIKEY)", RFC 4738, November 2006.
  • [RFC5226] Narten, T. and H. Alvestrand, "Guidelines for Writing an IANA Considerations Section in RFCs", BCP 26, RFC 5226, May 2008.
  • [RFC5408] Appenzeller, G., Martin, L., and M. Schertler, "Identity-Based Encryption Architecture and Supporting Data Structures", RFC 5408, January 2009.
  • [RFC6267] Cakulev, V. and G. Sundaram, "MIKEY-IBAKE: Identity-Based Authenticated Key Exchange (IBAKE) Mode of Key Distribution in Multimedia Internet KEYing (MIKEY)", RFC 6267, June 2011.
  • [S-K] Sakai, R., Ohgishi, K., and M. Kasahara, "ID based cryptosystem based on pairing on elliptic curves", Symposium on Cryptography and Information Security - SCIS, 2001.

Appendix A. Parameters for Use in MIKEY-SAKKE 🧚✨

okay bestie, so this is the cheat sheet 📋💅 [RFC6508] says every app has to pick its own set of public parameters, and this appendix is where Parameter Set 1 lives 🎀. the little descriptions for each one are over in Section 2.1 of [RFC6508] 🦋

n      = 128

p      = 997ABB1F 0A563FDA 65C61198 DAD0657A
         416C0CE1 9CB48261 BE9AE358 B3E01A2E
         F40AAB27 E2FC0F1B 228730D5 31A59CB0
         E791B39F F7C88A19 356D27F4 A666A6D0
         E26C6487 326B4CD4 512AC5CD 65681CE1
         B6AFF4A8 31852A82 A7CF3C52 1C3C09AA
         9F94D6AF 56971F1F FCE3E823 89857DB0
         80C5DF10 AC7ACE87 666D807A FEA85FEB

q      = 265EAEC7 C2958FF6 99718466 36B4195E
         905B0338 672D2098 6FA6B8D6 2CF8068B
         BD02AAC9 F8BF03C6 C8A1CC35 4C69672C
         39E46CE7 FDF22286 4D5B49FD 2999A9B4
         389B1921 CC9AD335 144AB173 595A0738
         6DABFD2A 0C614AA0 A9F3CF14 870F026A
         A7E535AB D5A5C7C7 FF38FA08 E2615F6C
         203177C4 2B1EB3A1 D99B601E BFAA17FB

Px     = 53FC09EE 332C29AD 0A799005 3ED9B52A
         2B1A2FD6 0AEC69C6 98B2F204 B6FF7CBF
         B5EDB6C0 F6CE2308 AB10DB90 30B09E10
         43D5F22C DB9DFA55 718BD9E7 406CE890
         9760AF76 5DD5BCCB 337C8654 8B72F2E1
         A702C339 7A60DE74 A7C1514D BA66910D
         D5CFB4CC 80728D87 EE9163A5 B63F73EC
         80EC46C4 967E0979 880DC8AB EAE63895

Py     = 0A824906 3F6009F1 F9F1F053 3634A135
         D3E82016 02990696 3D778D82 1E141178
         F5EA69F4 654EC2B9 E7F7F5E5 F0DE55F6
         6B598CCF 9A140B2E 416CFF0C A9E032B9
         70DAE117 AD547C6C CAD696B5 B7652FE0
         AC6F1E80 164AA989 492D979F C5A4D5F2
         13515AD7 E9CB99A9 80BDAD5A D5BB4636
         ADB9B570 6A67DCDE 75573FD7 1BEF16D7

g      = 66FC2A43 2B6EA392 148F1586 7D623068
         C6A87BD1 FB94C41E 27FABE65 8E015A87
         371E9474 4C96FEDA 449AE956 3F8BC446
         CBFDA85D 5D00EF57 7072DA8F 541721BE
         EE0FAED1 828EAB90 B99DFB01 38C78433
         55DF0460 B4A9FD74 B4F1A32B CAFA1FFA
         D682C033 A7942BCC E3720F20 B9B7B040
         3C8CAE87 B7A0042A CDE0FAB3 6461EA46

and the hash is Hash = SHA-256 (defined in [FIPS180-3]). 🔥 that's the whole set, periodt 💖

Author's Address 🌸

Michael Groves
CESG
Hubble Road
Cheltenham
GL51 8HJ
UK
EMail: Michael.Groves@cesg.gsi.gov.uk
📦 where this page comes from