in Index   Prev   Next

RFC 3711

The Secure Real-time Transport Protocol (SRTP)

Pages: 56
Proposed Standard
Updated by:  550669049335
Part 3 of 3 – Pages 37 to 56
First   Prev   None

Top   ToC   RFC3711 - Page 37   prevText

9. Security Considerations

9.1. SSRC collision and two-time pad

Any fixed keystream output, generated from the same key and index MUST only be used to encrypt once. Re-using such keystream (jokingly called a "two-time pad" system by cryptographers), can seriously compromise security. The NSA's VENONA project [C99] provides a historical example of such a compromise. It is REQUIRED that automatic key management be used for establishing and maintaining SRTP and SRTCP keying material; this requirement is to avoid keystream reuse, which is more likely to occur with manual key management. Furthermore, in SRTP, a "two-time pad" is avoided by requiring the key, or some other parameter of cryptographic significance, to be unique per RTP/RTCP stream and packet. The pre- defined SRTP transforms accomplish packet-uniqueness by including the packet index and stream-uniqueness by inclusion of the SSRC. The pre-defined transforms (AES-CM and AES-f8) allow master keys to be shared across streams belonging to the same RTP session by the inclusion of the SSRC in the IV. A master key MUST NOT be shared among different RTP sessions. Thus, the SSRC MUST be unique between all the RTP streams within the same RTP session that share the same master key. RTP itself provides an algorithm for detecting SSRC collisions within the same RTP session. Thus, temporary collisions could lead to temporary two-time pad, in the unfortunate event that SSRCs collide at a point in time when the streams also have identical sequence numbers (occurring with probability roughly 2^(-48)). Therefore, the key management SHOULD take care of avoiding such SSRC collisions by including the SSRCs to be used in the session as negotiation parameters, proactively assuring their uniqueness. This is a strong requirements in scenarios where for example, there are multiple senders that can start to transmit simultaneously, before SSRC collision are detected at the RTP level. Note also that even with distinct SSRCs, extensive use of the same key might improve chances of probabilistic collision and time- memory-tradeoff attacks succeeding. As described, master keys MAY be shared between streams belonging to the same RTP session, but it is RECOMMENDED that each SSRC have its own master key. When master keys are shared among SSRC participants and SSRCs are managed by a key management module as recommended above, the RECOMMENDED policy for an SSRC collision error is for the participant to leave the SRTP session as it is a sign of malfunction.
Top   ToC   RFC3711 - Page 38

9.2. Key Usage

The effective key size is determined (upper bounded) by the size of the master key and, for encryption, the size of the salting key. Any additive stream cipher is vulnerable to attacks that use statistical knowledge about the plaintext source to enable key collision and time-memory tradeoff attacks [MF00] [H80] [BS00]. These attacks take advantage of commonalities among plaintexts, and provide a way for a cryptanalyst to amortize the computational effort of decryption over many keys, or over many bytes of output, thus reducing the effective key size of the cipher. A detailed analysis of these attacks and their applicability to the encryption of Internet traffic is provided in [MF00]. In summary, the effective key size of SRTP when used in a security system in which m distinct keys are used, is equal to the key size of the cipher less the logarithm (base two) of m. Protection against such attacks can be provided simply by increasing the size of the keys used, which here can be accomplished by the use of the salting key. Note that the salting key MUST be random but MAY be public. A salt size of (the suggested) size 112 bits protects against attacks in scenarios where at most 2^112 keys are in use. This is sufficient for all practical purposes. Implementations SHOULD use keys that are as large as possible. Please note that in many cases increasing the key size of a cipher does not affect the throughput of that cipher. The use of the SRTP and SRTCP indices in the pre-defined transforms fixes the maximum number of packets that can be secured with the same key. This limit is fixed to 2^48 SRTP packets for an SRTP stream, and 2^31 SRTCP packets, when SRTP and SRTCP are considered independently. Due to for example re-keying, reaching this limit may or may not coincide with wrapping of the indices, and thus the sender MUST keep packet counts. However, when the session keys for related SRTP and SRTCP streams are derived from the same master key (the default behavior, Section 4.3), the upper bound that has to be considered is in practice the minimum of the two quantities. That is, when 2^48 SRTP packets or 2^31 SRTCP packets have been secured with the same key (whichever occurs before), the key management MUST be called to provide new master key(s) (previously stored and used keys MUST NOT be used again), or the session MUST be terminated. If a sender of RTCP discovers that the sender of SRTP (or SRTCP) has not updated the master or session key prior to sending 2^48 SRTP (or 2^31 SRTCP) packets belonging to the same SRTP (SRTCP) stream, it is up to the security policy of the RTCP sender how to behave, e.g., whether an RTCP BYE-packet should be sent and/or if the event should be logged.
Top   ToC   RFC3711 - Page 39
   Note: in most typical applications (assuming at least one RTCP packet
   for every 128,000 RTP packets), it will be the SRTCP index that first
   reaches the upper limit, although the time until this occurs is very
   long: even at 200 SRTCP packets/sec, the 2^31 index space of SRTCP is
   enough to secure approximately 4 months of communication.

   Note that if the master key is to be shared between SRTP streams
   within the same RTP session (Section 9.1), although the above bounds
   are on a per stream (i.e., per SSRC) basis, the sender MUST base re-
   key decision on the stream whose sequence number space is the first
   to be exhausted.

   Key derivation limits the amount of plaintext that is encrypted with
   a fixed session key, and made available to an attacker for analysis,
   but key derivation does not extend the master key's lifetime.  To see
   this, simply consider our requirements to avoid two-time pad:  two
   distinct packets MUST either be processed with distinct IVs, or with
   distinct session keys, and both the distinctness of IV and of the
   session keys are (for the pre-defined transforms) dependent on the
   distinctness of the packet indices.

   Note that with the key derivation, the effective key size is at most
   that of the master key, even if the derived session key is
   considerably longer.  With the pre-defined authentication transform,
   the session authentication key is 160 bits, but the master key by
   default is only 128 bits.  This design choice was made to comply with
   certain recommendations in [RFC2104] so that an existing HMAC
   implementation can be plugged into SRTP without problems.  Since the
   default tag size is 80 bits, it is, for the applications in mind,
   also considered acceptable from security point of view.  Users having
   concerns about this are RECOMMENDED to instead use a 192 bit master
   key in the key derivation.  It was, however, chosen not to mandate
   192-bit keys since existing AES implementations to be used in the
   key-derivation may not always support key-lengths other than 128
   bits.  Since AES is not defined (or properly analyzed) for use with
   160 bit keys it is NOT RECOMMENDED that ad-hoc key-padding schemes
   are used to pad shorter keys to 192 or 256 bits.

9.3. Confidentiality of the RTP Payload

SRTP's pre-defined ciphers are "seekable" stream ciphers, i.e., ciphers able to efficiently seek to arbitrary locations in their keystream (so that the encryption or decryption of one packet does not depend on preceding packets). By using seekable stream ciphers, SRTP avoids the denial of service attacks that are possible on stream ciphers that lack this property. It is important to be aware that, as with any stream cipher, the exact length of the payload is revealed by the encryption. This means that it may be possible to
Top   ToC   RFC3711 - Page 40
   deduce certain "formatting bits" of the payload, as the length of the
   codec output might vary due to certain parameter settings etc.  This,
   in turn, implies that the corresponding bit of the keystream can be
   deduced.  However, if the stream cipher is secure (counter mode and
   f8 are provably secure under certain assumptions [BDJR] [KSYH] [IK]),
   knowledge of a few bits of the keystream will not aid an attacker in
   predicting subsequent keystream bits.  Thus, the payload length (and
   information deducible from this) will leak, but nothing else.

   As some RTP packet could contain highly predictable data, e.g., SID,
   it is important to use a cipher designed to resist known plaintext
   attacks (which is the current practice).

9.4. Confidentiality of the RTP Header

In SRTP, RTP headers are sent in the clear to allow for header compression. This means that data such as payload type, synchronization source identifier, and timestamp are available to an eavesdropper. Moreover, since RTP allows for future extensions of headers, we cannot foresee what kind of possibly sensitive information might also be "leaked". SRTP is a low-cost method, which allows header compression to reduce bandwidth. It is up to the endpoints' policies to decide about the security protocol to employ. If one really needs to protect headers, and is allowed to do so by the surrounding environment, then one should also look at alternatives, e.g., IPsec [RFC2401].

9.5. Integrity of the RTP payload and header

SRTP messages are subject to attacks on their integrity and source identification, and these risks are discussed in Section 9.5.1. To protect against these attacks, each SRTP stream SHOULD be protected by HMAC-SHA1 [RFC2104] with an 80-bit output tag and a 160-bit key, or a message authentication code with equivalent strength. Secure RTP SHOULD NOT be used without message authentication, except under the circumstances described in this section. It is important to note that encryption algorithms, including AES Counter Mode and f8, do not provide message authentication. SRTCP MUST NOT be used with weak (or NULL) authentication. SRTP MAY be used with weak authentication (e.g., a 32-bit authentication tag), or with no authentication (the NULL authentication algorithm). These options allow SRTP to be used to provide confidentiality in situations where * weak or null authentication is an acceptable security risk, and * it is impractical to provide strong message authentication.
Top   ToC   RFC3711 - Page 41
   These conditions are described below and in Section 7.5.  Note that
   both conditions MUST hold in order for weak or null authentication to
   be used.  The risks associated with exercising the weak or null
   authentication options need to be considered by a security audit
   prior to their use for a particular application or environment given
   the risks, which are discussed in Section 9.5.1.

   Weak authentication is acceptable when the RTP application is such
   that the effect of a small fraction of successful forgeries is
   negligible.  If the application is stateless, then the effect of a
   single forged RTP packet is limited to the decoding of that
   particular packet.  Under this condition, the size of the
   authentication tag MUST ensure that only a negligible fraction of the
   packets passed to the RTP application by the SRTP receiver can be
   forgeries.  This fraction is negligible when an adversary, if given
   control of the forged packets, is not able to make a significant
   impact on the output of the RTP application (see the example of
   Section 7.5).

   Weak or null authentication MAY be acceptable when it is unlikely
   that an adversary can modify ciphertext so that it decrypts to an
   intelligible value.  One important case is when it is difficult for
   an adversary to acquire the RTP plaintext data, since for many
   codecs, an adversary that does not know the input signal cannot
   manipulate the output signal in a controlled way.  In many cases it
   may be difficult for the adversary to determine the actual value of
   the plaintext.  For example, a hidden snooping device might be
   required in order to know a live audio or video signal.  The
   adversary's signal must have a quality equivalent to or greater than
   that of the signal under attack, since otherwise the adversary would
   not have enough information to encode that signal with the codec used
   by the victim.  Plaintext prediction may also be especially difficult
   for an interactive application such as a telephone call.

   Weak or null authentication MUST NOT be used when the RTP application
   makes data forwarding or access control decisions based on the RTP
   data.  In such a case, an attacker may be able to subvert
   confidentiality by causing the receiver to forward data to an
   attacker.  See Section 3 of [B96] for a real-life example of such

   Null authentication MUST NOT be used when a replay attack, in which
   an adversary stores packets then replays them later in the session,
   could have a non-negligible impact on the receiver.  An example of a
   successful replay attack is the storing of the output of a
   surveillance camera for a period of time, later followed by the
Top   ToC   RFC3711 - Page 42
   injection of that output to the monitoring station to avoid
   surveillance.  Encryption does not protect against this attack, and
   non-null authentication is REQUIRED in order to defeat it.

   If existential message forgery is an issue, i.e., when the accuracy
   of the received data is of non-negligible importance, null
   authentication MUST NOT be used.

9.5.1. Risks of Weak or Null Message Authentication

During a security audit considering the use of weak or null authentication, it is important to keep in mind the following attacks which are possible when no message authentication algorithm is used. An attacker who cannot predict the plaintext is still always able to modify the message sent between the sender and the receiver so that it decrypts to a random plaintext value, or to send a stream of bogus packets to the receiver that will decrypt to random plaintext values. This attack is essentially a denial of service attack, though in the absence of message authentication, the RTP application will have inputs that are bit-wise correlated with the true value. Some multimedia codecs and common operating systems will crash when such data are accepted as valid video data. This denial of service attack may be a much larger threat than that due to an attacker dropping, delaying, or re-ordering packets. An attacker who cannot predict the plaintext can still replay a previous message with certainty that the receiver will accept it. Applications with stateless codecs might be robust against this type of attack, but for other, more complex applications these attacks may be far more grave. An attacker who can predict the plaintext can modify the ciphertext so that it will decrypt to any value of her choosing. With an additive stream cipher, an attacker will always be able to change individual bits. An attacker may be able to subvert confidentiality due to the lack of authentication when a data forwarding or access control decision is made on decrypted but unauthenticated plaintext. This is because the receiver may be fooled into forwarding data to an attacker, leading to an indirect breach of confidentiality (see Section 3 of [B96]). This is because data-forwarding decisions are made on the decrypted plaintext; information in the plaintext will determine to what subnet (or process) the plaintext is forwarded in ESP [RFC2401] tunnel mode (respectively, transport mode). When Secure RTP is used without
Top   ToC   RFC3711 - Page 43
   message authentication, it should be verified that the application
   does not make data forwarding or access control decisions based on
   the decrypted plaintext.

   Some cipher modes of operation that require padding, e.g., standard
   cipher block chaining (CBC) are very sensitive to attacks on
   confidentiality if certain padding types are used in the absence of
   integrity.  The attack [V02] shows that this is indeed the case for
   the standard RTP padding as discussed in reference to Figure 1, when
   used together with CBC mode.  Later transform additions to SRTP MUST
   therefore carefully consider the risk of using this padding without
   proper integrity protection.

9.5.2. Implicit Header Authentication

The IV formation of the f8-mode gives implicit authentication (IHA) of the RTP header, even when message authentication is not used. When IHA is used, an attacker that modifies the value of the RTP header will cause the decryption process at the receiver to produce random plaintext values. While this protection is not equivalent to message authentication, it may be useful for some applications.

10. Interaction with Forward Error Correction mechanisms

The default processing when using Forward Error Correction (e.g., RFC 2733) processing with SRTP SHALL be to perform FEC processing prior to SRTP processing on the sender side and to perform SRTP processing prior to FEC processing on the receiver side. Any change to this ordering (reversing it, or, placing FEC between SRTP encryption and SRTP authentication) SHALL be signaled out of band.

11. Scenarios

SRTP can be used as security protocol for the RTP/RTCP traffic in many different scenarios. SRTP has a number of configuration options, in particular regarding key usage, and can have impact on the total performance of the application according to the way it is used. Hence, the use of SRTP is dependent on the kind of scenario and application it is used with. In the following, we briefly illustrate some use cases for SRTP, and give some guidelines for recommended setting of its options.

11.1. Unicast

A typical example would be a voice call or video-on-demand application.
Top   ToC   RFC3711 - Page 44
   Consider one bi-directional RTP stream, as one RTP session.  It is
   possible for the two parties to share the same master key in the two
   directions according to the principles of Section 9.1.  The first
   round of the key derivation splits the master key into any or all of
   the following session keys (according to the provided security

   SRTP_encr_key, SRTP_auth_key, SRTCP_encr_key, and SRTCP_auth key.

   (For simplicity, we omit discussion of the salts, which are also
   derived.)  In this scenario, it will in most cases suffice to have a
   single master key with the default lifetime.  This guarantees
   sufficiently long lifetime of the keys and a minimum set of keys in
   place for most practical purposes.  Also, in this case RTCP
   protection can be applied smoothly.  Under these assumptions, use of
   the MKI can be omitted.  As the key-derivation in combination with
   large difference in the packet rate in the respective directions may
   require simultaneous storage of several session keys, if storage is
   an issue, we recommended to use low-rate key derivation.

   The same considerations can be extended to the unicast scenario with
   multiple RTP sessions, where each session would have a distinct
   master key.

11.2. Multicast (one sender)

Just as with (unprotected) RTP, a scalability issue arises in big groups due to the possibly very large amount of SRTCP Receiver Reports that the sender might need to process. In SRTP, the sender may have to keep state (the cryptographic context) for each receiver, or more precisely, for the SRTCP used to protect Receiver Reports. The overhead increases proportionally to the size of the group. In particular, re-keying requires special concern, see below. Consider first a small group of receivers. There are a few possible setups with the distribution of master keys among the receivers. Given a single RTP session, one possibility is that the receivers share the same master key as per Section 9.1 to secure all their respective RTCP traffic. This shared master key could then be the same one used by the sender to protect its outbound SRTP traffic. Alternatively, it could be a master key shared only among the receivers and used solely for their SRTCP traffic. Both alternatives require the receivers to trust each other. Considering SRTCP and key storage, it is recommended to use low-rate (or zero) key_derivation (except the mandatory initial one), so that the sender does not need to store too many session keys (each SRTCP stream might otherwise have a different session key at a given point
Top   ToC   RFC3711 - Page 45
   in time, as the SRTCP sources send at different times).  Thus, in
   case key derivation is wanted for SRTP, the cryptographic context for
   SRTP can be kept separate from the SRTCP crypto context, so that it
   is possible to have a key_derivation_rate of 0 for SRTCP and a non-
   zero value for SRTP.

   Use of the MKI for re-keying is RECOMMENDED for most applications
   (see Section 8.1).

   If there are more than one SRTP/SRTCP stream (within the same RTP
   session) that share the master key, the upper limit of 2^48 SRTP
   packets / 2^31 SRTCP packets means that, before one of the streams
   reaches its maximum number of packets, re-keying MUST be triggered on
   ALL streams sharing the master key.  (From strict security point of
   view, only the stream reaching the maximum would need to be re-keyed,
   but then the streams would no longer be sharing master key, which is
   the intention.)  A local policy at the sender side should force
   rekeying in a way that the maximum packet limit is not reached on any
   of the streams.  Use of the MKI for re-keying is RECOMMENDED.

   In large multicast with one sender, the same considerations as for
   the small group multicast hold.  The biggest issue in this scenario
   is the additional load placed at the sender side, due to the state
   (cryptographic contexts) that has to be maintained for each receiver,
   sending back RTCP Receiver Reports.  At minimum, a replay window
   might need to be maintained for each RTCP source.

11.3. Re-keying and access control

Re-keying may occur due to access control (e.g., when a member is removed during a multicast RTP session), or for pure cryptographic reasons (e.g., the key is at the end of its lifetime). When using SRTP default transforms, the master key MUST be replaced before any of the index spaces are exhausted for any of the streams protected by one and the same master key. How key management re-keys SRTP implementations is out of scope, but it is clear that there are straightforward ways to manage keys for a multicast group. In one-sender multicast, for example, it is typically the responsibility of the sender to determine when a new key is needed. The sender is the one entity that can keep track of when the maximum number of packets has been sent, as receivers may join and leave the session at any time, there may be packet loss and delay etc. In scenarios other than one-sender multicast, other methods can be used. Here, one must take into consideration that key exchange can be a costly operation, taking several seconds for a single exchange. Hence, some time before the master key is exhausted/expires, out-of-band key management is initiated, resulting
Top   ToC   RFC3711 - Page 46
   in a new master key that is shared with the receiver(s).  In any
   event, to maintain synchronization when switching to the new key,
   group policy might choose between using the MKI and the <From, To>,
   as described in Section 8.1.

   For access control purposes, the <From, To> periods are set at the
   desired granularity, dependent on the packet rate.  High rate re-
   keying can be problematic for SRTCP in some large-group scenarios.
   As mentioned, there are potential problems in using the SRTP index,
   rather than the SRTCP index, for determining the master key.  In
   particular, for short periods during switching of master keys, it may
   be the case that SRTCP packets are not under the current master key
   of the correspondent SRTP.  Therefore, using the MKI for re-keying in
   such scenarios will produce better results.

11.4. Summary of basic scenarios

The description of these scenarios highlights some recommendations on the use of SRTP, mainly related to re-keying and large scale multicast: - Do not use fast re-keying with the <From, To> feature. It may, in particular, give problems in retrieving the correct SRTCP key, if an SRTCP packet arrives close to the re-keying time. The MKI SHOULD be used in this case. - If multiple SRTP streams in the same RTP session share the same master key, also moderate rate re-keying MAY have the same problems, and the MKI SHOULD be used. - Though offering increased security, a non-zero key_derivation_rate is NOT RECOMMENDED when trying to minimize the number of keys in use with multiple streams.

12. IANA Considerations

The RTP specification establishes a registry of profile names for use by higher-level control protocols, such as the Session Description Protocol (SDP), to refer to transport methods. This profile registers the name "RTP/SAVP". SRTP uses cryptographic transforms which a key management protocol signals. It is the task of each particular key management protocol to register the cryptographic transforms or suites of transforms with IANA. The key management protocol conveys these protocol numbers, not SRTP, and each key management protocol chooses the numbering scheme and syntax that it requires.
Top   ToC   RFC3711 - Page 47
   Specification of a key management protocol for SRTP is out of scope
   here.  Section 8.2, however, provides guidance on the parameters that
   need to be defined for the default and mandatory transforms.

13. Acknowledgements

David Oran (Cisco) and Rolf Blom (Ericsson) are co-authors of this document but their valuable contributions are acknowledged here to keep the length of the author list down. The authors would in addition like to thank Magnus Westerlund, Brian Weis, Ghyslain Pelletier, Morgan Lindqvist, Robert Fairlie- Cuninghame, Adrian Perrig, the AVT WG and in particular the chairmen Colin Perkins and Stephen Casner, the Transport and Security Area Directors, and Eric Rescorla for their reviews and support.

14. References

14.1. Normative References

[AES] NIST, "Advanced Encryption Standard (AES)", FIPS PUB 197, [RFC2104] Krawczyk, H., Bellare, M. and R. Canetti, "HMAC: Keyed- Hashing for Message Authentication", RFC 2104, February 1997. [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997. [RFC2401] Kent, S. and R. Atkinson, "Security Architecture for Internet Protocol", RFC 2401, November 1998. [RFC2828] Shirey, R., "Internet Security Glossary", FYI 36, RFC 2828, May 2000. [RFC3550] Schulzrinne, H., Casner, S., Frederick, R. and V. Jacobson, "RTP: A Transport Protocol for Real-time Applications", RFC 3550, July 2003. [RFC3551] Schulzrinne, H. and S. Casner, "RTP Profile for Audio and Video Conferences with Minimal Control", RFC 3551, July 2003.
Top   ToC   RFC3711 - Page 48

14.2. Informative References

[AES-CTR] Lipmaa, H., Rogaway, P. and D. Wagner, "CTR-Mode Encryption", NIST, workshop1/papers/lipmaa-ctr.pdf [B96] Bellovin, S., "Problem Areas for the IP Security Protocols," in Proceedings of the Sixth Usenix Unix Security Symposium, pp. 1-16, San Jose, CA, July 1996 ( [BDJR] Bellare, M., Desai, A., Jokipii, E. and P. Rogaway, "A Concrete Treatment of Symmetric Encryption: Analysis of DES Modes of Operation", Proceedings 38th IEEE FOCS, pp. 394- 403, 1997. [BS00] Biryukov, A. and A. Shamir, "Cryptanalytic Time/Memory/Data Tradeoffs for Stream Ciphers", Proceedings, ASIACRYPT 2000, LNCS 1976, pp. 1-13, Springer Verlag. [C99] Crowell, W. P., "Introduction to the VENONA Project", [CTR] Dworkin, M., NIST Special Publication 800-38A, "Recommendation for Block Cipher Modes of Operation: Methods and Techniques", 2001. 38a.pdf. [f8-a] 3GPP TS 35.201 V4.1.0 (2001-12) Technical Specification 3rd Generation Partnership Project; Technical Specification Group Services and System Aspects; 3G Security; Specification of the 3GPP Confidentiality and Integrity Algorithms; Document 1: f8 and f9 Specification (Release 4). [f8-b] 3GPP TR 33.908 V4.0.0 (2001-09) Technical Report 3rd Generation Partnership Project; Technical Specification Group Services and System Aspects; 3G Security; General Report on the Design, Specification and Evaluation of 3GPP Standard Confidentiality and Integrity Algorithms (Release 4). [GDOI] Baugher, M., Weis, B., Hardjono, T. and H. Harney, "The Group Domain of Interpretation, RFC 3547, July 2003.
Top   ToC   RFC3711 - Page 49
   [HAC]     Menezes, A., Van Oorschot, P. and  S. Vanstone, "Handbook
             of Applied Cryptography", CRC Press, 1997, ISBN 0-8493-

   [H80]     Hellman, M. E., "A cryptanalytic time-memory trade-off",
             IEEE Transactions on Information Theory, July 1980, pp.

   [IK]      T. Iwata and T. Kohno: "New Security Proofs for the 3GPP
             Confidentiality and Integrity Algorithms", Proceedings of
             FSE 2004.

   [KINK]    Thomas, M. and J. Vilhuber, "Kerberized Internet
             Negotiation of Keys (KINK)", Work in Progress.

   [KEYMGT]  Arrko, J., et al., "Key Management Extensions for Session
             Description Protocol (SDP) and Real Time Streaming Protocol
             (RTSP)", Work in Progress.

   [KSYH]    Kang, J-S., Shin, S-U., Hong, D. and O. Yi, "Provable
             Security of KASUMI and 3GPP Encryption Mode f8",
             Proceedings Asiacrypt 2001, Springer Verlag LNCS 2248, pp.
             255-271, 2001.

   [MIKEY]   Arrko, J., et. al., "MIKEY: Multimedia Internet KEYing",
             Work in Progress.

   [MF00]    McGrew, D. and S. Fluhrer, "Attacks on Encryption of
             Redundant Plaintext and Implications on Internet Security",
             the Proceedings of the Seventh Annual Workshop on Selected
             Areas in Cryptography (SAC 2000), Springer-Verlag.

   [PCST1]   Perrig, A., Canetti, R., Tygar, D. and D.  Song, "Efficient
             and Secure Source Authentication for Multicast", in Proc.
             of Network and Distributed System Security Symposium NDSS
             2001, pp. 35-46, 2001.

   [PCST2]   Perrig, A., Canetti, R., Tygar, D. and D. Song, "Efficient
             Authentication and Signing of Multicast Streams over Lossy
             Channels", in Proc. of IEEE Security and Privacy Symposium
             S&P2000, pp. 56-73, 2000.

   [RFC1750] Eastlake, D., Crocker, S. and J. Schiller, "Randomness
             Recommendations for Security", RFC 1750, December 1994.

   [RFC2675] Borman, D., Deering, S. and R. Hinden, "IPv6 Jumbograms",
             RFC 2675, August 1999.
Top   ToC   RFC3711 - Page 50
   [RFC3095] Bormann, C., Burmeister, C., Degermark, M., Fukuhsima, H.,
             Hannu, H., Jonsson, L-E., Hakenberg, R., Koren, T., Le, K.,
             Liu, Z., Martensson, A., Miyazaki, A., Svanbro, K., Wiebke,
             T., Yoshimura, T. and H. Zheng, "RObust Header Compression:
             Framework and Four Profiles: RTP, UDP, ESP, and
             uncompressed (ROHC)", RFC 3095, July 2001.

   [RFC3242] Jonsson, L-E. and G. Pelletier, "RObust Header Compression
             (ROHC): A Link-Layer Assisted Profile for IP/UDP/RTP ", RFC
             3242, April 2002.

   [SDMS]    Andreasen, F., Baugher, M. and D. Wing, "Session
             Description Protocol Security Descriptions for Media
             Streams", Work in Progress.

   [SWO]     Svanbro, K., Wiorek, J. and B. Olin, "Voice-over-IP-over-
             wireless", Proc.  PIMRC 2000, London, Sept. 2000.

   [V02]     Vaudenay, S., "Security Flaws Induced by CBC Padding -
             Application to SSL, IPsec, WTLS...", Advances in
             Cryptology, EUROCRYPT'02, LNCS 2332, pp. 534-545.

   [WC81]    Wegman, M. N., and  J.L. Carter, "New Hash Functions and
             Their Use in Authentication and Set Equality", JCSS 22,
             265-279, 1981.
Top   ToC   RFC3711 - Page 51

Appendix A: Pseudocode for Index Determination

The following is an example of pseudo-code for the algorithm to determine the index i of an SRTP packet with sequence number SEQ. In the following, signed arithmetic is assumed. if (s_l < 32,768) if (SEQ - s_l > 32,768) set v to (ROC-1) mod 2^32 else set v to ROC endif else if (s_l - 32,768 > SEQ) set v to (ROC+1) mod 2^32 else set v to ROC endif endif return SEQ + v*65,536

Appendix B: Test Vectors

All values are in hexadecimal.

B.1. AES-f8 Test Vectors

SRTP PREFIX LENGTH : 0 RTP packet header : 806e5cba50681de55c621599 RTP packet payload : 70736575646f72616e646f6d6e657373 20697320746865206e65787420626573 74207468696e67 ROC : d462564a key : 234829008467be186c3de14aae72d62c salt key : 32f2870d key-mask (m) : 32f2870d555555555555555555555555 key XOR key-mask : 11baae0dd132eb4d3968b41ffb278379 IV : 006e5cba50681de55c621599d462564a IV' : 595b699bbd3bc0df26062093c1ad8f73
Top   ToC   RFC3711 - Page 52
   j = 0
   IV' xor j           :   595b699bbd3bc0df26062093c1ad8f73
   S(-1)               :   00000000000000000000000000000000
   IV' xor S(-1) xor j :   595b699bbd3bc0df26062093c1ad8f73
   S(0)                :   71ef82d70a172660240709c7fbb19d8e
   plaintext           :   70736575646f72616e646f6d6e657373
   ciphertext          :   019ce7a26e7854014a6366aa95d4eefd

   j = 1
   IV' xor j           :   595b699bbd3bc0df26062093c1ad8f72
   S(0)                :   71ef82d70a172660240709c7fbb19d8e
   IV' xor S(0) xor j  :   28b4eb4cb72ce6bf020129543a1c12fc
   S(1)                :   3abd640a60919fd43bd289a09649b5fc
   plaintext           :   20697320746865206e65787420626573
   ciphertext          :   1ad4172a14f9faf455b7f1d4b62bd08f

   j = 2
   IV' xor j           :   595b699bbd3bc0df26062093c1ad8f71
   S(1)                :   3abd640a60919fd43bd289a09649b5fc
   IV' xor S(1) xor j  :   63e60d91ddaa5f0b1dd4a93357e43a8d
   S(2)                :   220c7a8715266565b09ecc8a2a62b11b
   plaintext           :   74207468696e67
   ciphertext          :   562c0eef7c4802

B.2. AES-CM Test Vectors

Keystream segment length: 1044512 octets (65282 AES blocks) Session Key: 2B7E151628AED2A6ABF7158809CF4F3C Rollover Counter: 00000000 Sequence Number: 0000 SSRC: 00000000 Session Salt: F0F1F2F3F4F5F6F7F8F9FAFBFCFD0000 (already shifted) Offset: F0F1F2F3F4F5F6F7F8F9FAFBFCFD0000 Counter Keystream F0F1F2F3F4F5F6F7F8F9FAFBFCFD0000 E03EAD0935C95E80E166B16DD92B4EB4 F0F1F2F3F4F5F6F7F8F9FAFBFCFD0001 D23513162B02D0F72A43A2FE4A5F97AB F0F1F2F3F4F5F6F7F8F9FAFBFCFD0002 41E95B3BB0A2E8DD477901E4FCA894C0 ... ... F0F1F2F3F4F5F6F7F8F9FAFBFCFDFEFF EC8CDF7398607CB0F2D21675EA9EA1E4 F0F1F2F3F4F5F6F7F8F9FAFBFCFDFF00 362B7C3C6773516318A077D7FC5073AE F0F1F2F3F4F5F6F7F8F9FAFBFCFDFF01 6A2CC3787889374FBEB4C81B17BA6C44 Nota Bene: this test case is contrived so that the latter part of the keystream segment coincides with the test case in Section F.5.1 of [CTR].
Top   ToC   RFC3711 - Page 53

B.3. Key Derivation Test Vectors

This section provides test data for the default key derivation function, which uses AES-128 in Counter Mode. In the following, we walk through the initial key derivation for the AES-128 Counter Mode cipher, which requires a 16 octet session encryption key and a 14 octet session salt, and an authentication function which requires a 94-octet session authentication key. These values are called the cipher key, the cipher salt, and the auth key in the following. Since this is the initial key derivation and the key derivation rate is equal to zero, the value of (index DIV key_derivation_rate) is zero (actually, a six-octet string of zeros). In the following, we shorten key_derivation_rate to kdr. The inputs to the key derivation function are the 16 octet master key and the 14 octet master salt: master key: E1F97A0D3E018BE0D64FA32C06DE4139 master salt: 0EC675AD498AFEEBB6960B3AABE6 We first show how the cipher key is generated. The input block for AES-CM is generated by exclusive-oring the master salt with the concatenation of the encryption key label 0x00 with (index DIV kdr), then padding on the right with two null octets (which implements the multiply-by-2^16 operation, see Section 4.3.3). The resulting value is then AES-CM- encrypted using the master key to get the cipher key. index DIV kdr: 000000000000 label: 00 master salt: 0EC675AD498AFEEBB6960B3AABE6 ----------------------------------------------- xor: 0EC675AD498AFEEBB6960B3AABE6 (x, PRF input) x*2^16: 0EC675AD498AFEEBB6960B3AABE60000 (AES-CM input) cipher key: C61E7A93744F39EE10734AFE3FF7A087 (AES-CM output)
Top   ToC   RFC3711 - Page 54
   Next, we show how the cipher salt is generated.  The input block for
   AES-CM is generated by exclusive-oring the master salt with the
   concatenation of the encryption salt label.  That value is padded and
   encrypted as above.

      index DIV kdr:                 000000000000
      label:                       02
      master salt:   0EC675AD498AFEEBB6960B3AABE6

      xor:           0EC675AD498AFEE9B6960B3AABE6     (x, PRF input)

      x*2^16:        0EC675AD498AFEE9B6960B3AABE60000 (AES-CM input)

                     30CBBC08863D8C85D49DB34A9AE17AC6 (AES-CM ouptut)

      cipher salt:   30CBBC08863D8C85D49DB34A9AE1

   We now show how the auth key is generated.  The input block for AES-
   CM is generated as above, but using the authentication key label.

      index DIV kdr:                   000000000000
      label:                         01
      master salt:     0EC675AD498AFEEBB6960B3AABE6
      xor:             0EC675AD498AFEEAB6960B3AABE6     (x, PRF input)

      x*2^16:          0EC675AD498AFEEAB6960B3AABE60000 (AES-CM input)

   Below, the auth key is shown on the left, while the corresponding AES
   input blocks are shown on the right.

   auth key                           AES input blocks
   CEBE321F6FF7716B6FD4AB49AF256A15   0EC675AD498AFEEAB6960B3AABE60000
   6D38BAA48F0A0ACF3C34E2359E6CDBCE   0EC675AD498AFEEAB6960B3AABE60001
   E049646C43D9327AD175578EF7227098   0EC675AD498AFEEAB6960B3AABE60002
   6371C10C9A369AC2F94A8C5FBCDDDC25   0EC675AD498AFEEAB6960B3AABE60003
   6D6E919A48B610EF17C2041E47403576   0EC675AD498AFEEAB6960B3AABE60004
   6B68642C59BBFC2F34DB60DBDFB2       0EC675AD498AFEEAB6960B3AABE60005
Top   ToC   RFC3711 - Page 55

Authors' Addresses

Questions and comments should be directed to the authors and Mark Baugher Cisco Systems, Inc. 5510 SW Orchid Street Portland, OR 97219 USA Phone: +1 408-853-4418 EMail: Elisabetta Carrara Ericsson Research SE-16480 Stockholm Sweden Phone: +46 8 50877040 EMail: David A. McGrew Cisco Systems, Inc. San Jose, CA 95134-1706 USA Phone: +1 301-349-5815 EMail: Mats Naslund Ericsson Research SE-16480 Stockholm Sweden Phone: +46 8 58533739 EMail: Karl Norrman Ericsson Research SE-16480 Stockholm Sweden Phone: +46 8 4044502 EMail:
Top   ToC   RFC3711 - Page 56
Full Copyright Statement

   Copyright (C) The Internet Society (2004).  This document is subject
   to the rights, licenses and restrictions contained in BCP 78 and
   except as set forth therein, the authors retain all their rights.

   This document and the information contained herein are provided on an

Intellectual Property

   The IETF takes no position regarding the validity or scope of any
   Intellectual Property Rights or other rights that might be claimed to
   pertain to the implementation or use of the technology described in
   this document or the extent to which any license under such rights
   might or might not be available; nor does it represent that it has
   made any independent effort to identify any such rights.  Information
   on the procedures with respect to rights in RFC documents can be
   found in BCP 78 and BCP 79.

   Copies of IPR disclosures made to the IETF Secretariat and any
   assurances of licenses to be made available, or the result of an
   attempt made to obtain a general license or permission for the use of
   such proprietary rights by implementers or users of this
   specification can be obtained from the IETF on-line IPR repository at

   The IETF invites any interested party to bring to its attention any
   copyrights, patents or patent applications, or other proprietary
   rights that may cover technology that may be required to implement
   this standard.  Please address the information to the IETF at ietf-


   Funding for the RFC Editor function is currently provided by the
   Internet Society.