Method and system for using parallel Datagram Transport Layer Security (DTLS) connections over Stream Control Transmission Protocol (SCTP) - Patent Application 20070123333
By establishing parallel DTLS connections over SCTP associations, the method addresses the limitations of DTLS in SCTP, enabling secure and efficient data transmission in long-lived SCTP associations without suspending or delaying data transfer during key changes.
Patent Information
- Application Number
- JP2024520798
- Authority / Receiving Office
- JP · JP
- Patent Type
- Applications
- Current Assignee / Owner
- Priority Date
- 2021-10-21
- Filing Date
- 2022-08-17
- Publication Date
- 2024-11-13
- Estimated Expiration
- 2042-08-17
AI Technical Summary
Existing technologies face challenges in implementing long-lived Stream Control Transmission Protocol (SCTP) associations due to limitations in Datagram Transport Layer Security (DTLS) versions, such as DTLS 1.3, which do not support mutual re-authentication and rekeying, leading to delays and impacts on data transmission during key changes.
Establishing a new DTLS connection in parallel with an existing DTLS connection on the same SCTP association, enabling re-keying and mutual re-authentication with minimal impact on applications, using DTLS 1.2 or 1.3, and ensuring secure coexistence through SCTP-AUTH keyed by the existing DTLS connection.
This approach allows for secure, efficient, and uninterrupted data transmission in long-lived SCTP associations by avoiding the draining phase during key changes, ensuring data delivery confirmation before closing the old connection, and maintaining transport semantics.
Smart Images

Figure 2024541821000001_ABST
Abstract
Description
[Technical field]
[0001] CROSS-REFERENCE TO RELATED APPLICATIONS This application claims the benefit of U.S. Provisional Application No. 63 / 270,064, filed October 21, 2021, which is incorporated herein by reference.
[0002] FIELD OF THE DISCLOSURE
[0002] Embodiments of the present invention relate to the field of networking, and more specifically, to using parallel Datagram Transport Layer Security (DTLS) connections over Stream Control Transmission Protocol (SCTP). [Background technology]
[0003] Signaling protocols in fifth generation (5G) networks use interfaces such as Next Generation Control Plane Interface (NG-C), Xn, E1, and F1 in the 5G Radio Access Network (RAN) to transport sensible data that can be utilized to obtain information about mobile devices, their locations, and the like. Signaling data is coded in Abstract Syntax Notation One (ASN.1) and transferred between nodes via Stream Control Transmission Protocol (SCTP). The Third Generation Partnership Project (3GPP) recommends protecting the data with Internet Protocol Security (IPSec) for security and confidentiality. Signals can be of any length, and there may be signals up to 144K bytes in size.
[0004] Because the connection between the IPSec gateway and the node is not protected, 3GPP also recommends adopting DTLS / SCTP for end-to-end protection. According to 3GPP, DTLS / SCTP protection is mandatory for node implementers and optional for operators to activate. However, because SCTP associations can be very long lived, in some cases with lifetimes measured in weeks or months, peer nodes in an end-to-end node connection need to have a solution for long-lived SCTP associations that support large SCTP messages. Summary of the Invention
[0005] Embodiments include methods, network nodes, storage media, and computer programs for implementing a parallel Datagram Transport Layer Security (DTLS) connection on a Stream Control Transmission Protocol (SCTP) association. In one embodiment, a method in a first network node for encoding a user message for secure transmission to a second network node includes initiating a Datagram Transport Layer Security (DTLS) connection on the Stream Control Transmission Protocol (SCTP) association through a DTLS handshake using an existing Authenticated Chunk for SCTP (SCTP-AUTH) key from an existing DTLS connection on the SCTP association to send the user message, deriving a new SCTP-AUTH key from the initiated DTLS connection, sending a further user message over the initiated DTLS connection using the new SCTP-AUTH key (210), and closing the existing DTLS connection on the SCTP association in response to confirmation that the SCTP packets encrypted with the existing DTLS connection and authenticated by the existing SCTP-AUTH key have been delivered.
[0006] An embodiment includes a network node for implementing a parallel Datagram Transport Layer Security (DTLS) connection on a Stream Control Transmission Protocol (SCTP) association. In one embodiment, the network node comprises a processor and a non-transitory machine-readable storage medium providing instructions that, when executed by the processor, cause the network node to: initiate a Datagram Transport Layer Security (DTLS) connection on a Stream Control Transmission Protocol (SCTP) association through a DTLS handshake using an existing Authenticated Chunk for SCTP (SCTP-AUTH) key from an existing DTLS connection on the SCTP association to send a user message; derive a new SCTP-AUTH key from the initiated DTLS connection; transmit a further user message over the initiated DTLS connection using the new SCTP-AUTH key; and, in response to determining that the SCTP packets encrypted with the existing DTLS connection and authenticated by the existing SCTP-AUTH key have been delivered, close the existing DTLS connection on the SCTP association.
[0007] An embodiment includes a machine-readable storage medium for implementing a parallel Datagram Transport Layer Security (DTLS) connection on a Stream Control Transmission Protocol (SCTP) association. In one embodiment, the machine-readable storage medium provides instructions that can cause a network node, upon which the instructions are executed, to initiate a Datagram Transport Layer Security (DTLS) connection on the Stream Control Transmission Protocol (SCTP) association through a DTLS handshake using an existing Authenticated Chunk for SCTP (SCTP-AUTH) key from an existing DTLS connection on the SCTP association to send a user message, derive a new SCTP-AUTH key from the initiated DTLS connection, send a further user message over the initiated DTLS connection using the new SCTP-AUTH key, and close the existing DTLS connection on the SCTP association in response to determining that the SCTP packets encrypted with the existing DTLS connection and the SCTP packets authenticated by the existing SCTP-AUTH key have been delivered.
[0008] The present invention avoids the impact of applications pausing or at least delaying data transmission in a DTLS / SCTP session during the data draining phase upon key change with existing solutions. The draining phase is avoided because DTLS protection records are self-describing and can coexist. Furthermore, independent DTLS connection management allows explicit asynchronous close signaling when each side knows that all data using this key has been delivered first, thus closing down the connection and discarding the private key material. [Brief description of the drawings]
[0009] The invention may be best understood by referring to the following description and the accompanying drawings, which are used to illustrate embodiments of the invention. In the drawings: [Figure 1] FIG. 1 illustrates a system diagram for providing extended DTLS / SCTP signaling and messaging according to some embodiments. [Diagram 2] FIG. 2 illustrates operations for establishing a parallel DTLS connection on an SCTP association according to some embodiments. [Diagram 3] FIG. 3 illustrates a signaling diagram 300 between a first node and a second node in accordance with some embodiments of the disclosure. [Figure 4] FIG. 4 illustrates a network node implementing a parallel DTLS connection over an SCTP association according to some embodiments. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
[0010] In general, all terms used herein should be interpreted according to their ordinary meaning in the relevant technical field unless a different meaning is expressly given and / or implied from the context in which it is used. Any reference to an element, apparatus, component, means, step, etc. should be openly interpreted as referring to at least one instance of the element, apparatus, component, means, step, etc., unless otherwise specified. The steps of any method disclosed herein need not be performed in the exact order disclosed, unless a step is explicitly described as after or before another step and / or it is implicit that a step must be after or before another step. Any feature of any of the embodiments disclosed herein may be applied to any other embodiment, where appropriate. Similarly, any advantage of any embodiment may be applied to any other embodiment, and vice versa. Other objects, features, and advantages of the included embodiments will become apparent from the following description.
[0011] 1. Introduction It is difficult to implement long-lived Stream Control Transmission Protocol (SCTP) associations in existing technologies. For example, Datagram Transport Layer Security (DTLS) 1.3 does not support mutual reauthentication, nor does it enable rekeying (using Diffie-Hellman) of DTLS itself, making it unsuitable for protecting long-lived (weeks and months) SCTP associations, such as the basic form used in mobile networks. The procedure for DTLS (1.0 and 1.2) renegotiation according to Internet Engineering Task Force (IETF) Request for Comment (RFC) 6083, which handles key changes, requires draining, i.e., stopping transmission until all data is received, before key changes, which may impact applications. Note that the terms "association" and "SCTP association" are used interchangeably in this specification.
[0012] 1.1 Overview To overcome such challenges, embodiments of the present invention establish new DTLS connections in parallel with existing DTLS connections on the same SCTP association, thereby enabling re-keying, mutual re-authentication, and renewed certificates for DTLS-protected SCTP associations with minimal impact to applications for long-lived SCTP associations.
[0013] This can be done securely due to the mutual authentication in the DTLS handshake and the integrity and source authentication provided by the SCTP-AUTH keyed by the existing DTLS connection. When a new handshake is performed and the security context and keys are in place, both network node endpoints switch to using the new keys for both DTLS records and the exported keys for SCTP-AUTH. The DTLS record uses the DTLS connection identification (ID) function, and SCTP-AUTH uses its key-id mechanism to identify the correct context.
[0014] The old DTLS connection is closed in one direction when each sender guarantees that all DTLS records and SCTP packets protected by the old SCTP-AUTH key have been successfully delivered. When both endpoints close the DTLS connection, all keys associated with this DTLS connection may be deleted. Thus, embodiments of the present invention allow the coexistence of two DTLS connections with minimal impact to applications, while still maintaining the assumed transport semantics for any SCTP messages that must be delivered reliably.
[0015] In some embodiments, DTLS over SCTP is used with Authenticated Chunks for SCTP (SCTP-AUTH). DTLS may be implemented as specified in DTLS 1.2 [IETF RFC 6347] or DTLS 1.3 [IETF RFC 9147], while SCTP may be implemented with SCTP-AUTH [IETF RFC 4895] as specified in [IETF RFC 4960]. Applications that use SCTP as a transport protocol may use these and other embodiments to provide mutual authentication of endpoints, confidentiality, integrity protection, and replay protection of user messages.
[0016] DTLS / SCTP uses SCTP and SCTP-AUTH for integrity and replay protection of user messages. Applications using DTLS over SCTP can use almost all transport features provided by SCTP and its extensions. DTLS / SCTP supports features including 1) preservation of message boundaries, 2) multiple unidirectional and bidirectional streams, 3) ordered and unordered delivery of SCTP user messages, 4) partial reliability extensions as specified in [IETF RFC 3758], 5) dynamic address reconfiguration extensions as specified in [IETF RFC 5061], and 6) user message sizes up to 2^64-1. Unless otherwise specified, a stream in this specification is a unidirectional stream of an SCTP association and is uniquely identified by a stream identifier.
[0017] Some embodiments may require that SCTP implementations support the optional feature of fragmentation of SCTP user messages as specified in [IETF RFC 4960]. Implementations are required to have an SCTP API that supports partial user message delivery (e.g., as described in [IETF RFC 6458]), and are encouraged to use I-DATA chunks as specified in [IETF RFC 8260] to efficiently implement and support larger user messages.
[0018] Figure 1 illustrates a system diagram for providing enhanced DTLS / SCTP signaling and messaging according to some embodiments. Figure 1 illustrates a node 100 implementing traffic flow, where an application programming interface (API) 101 is an interface between an SCTP functional block (or module) 120 and the higher layer protocol over which messages are received or recovered. Between the API 101 and the SCTP functional block 120 is a DTLS / SCTP functional block (or module) 110. In some embodiments, the API 101 includes a DTLS API and an SCTP API.
[0019] The DTLS / SCTP functional block 110 uses DTLS and SCTP together to protect user messages and SCTP-AUTH keys. The DTLS / SCTP functional block 110 includes a parallel DTLS connection coordinator module 112 that implements embodiments of the present invention. In some embodiments, the DTLS / SCTP functional block 110 fragments messages from upper layer protocols and provides the fragments to SCTP 120, defragments messages (SCTP packets) from SCTP 120, assembles them, and provides the assembled messages to the upper layer protocols.
[0020] The DTLS / SCTP functional block 110 includes a DTLS module 115, which implements the DTLS protocol and provides DTLS records of up to 2^14 bytes in size. The DTLS module 115 includes, in some embodiments, a TLS exporter 114, which exports a shared authentication key from the DTLS connection. The shared authentication key is paired with a key-id at 116 and provides the key and the corresponding key-id to the SCTP 120.
[0021] SCTP 120 is a functional block that implements the SCTP protocol, for example, in accordance with IETF RFC 4960 and various extensions or other IETF standard proposals. In some embodiments, SCTP functional block 120 includes an SCTP-AUTH module 124 for accepting a shared authentication key and a corresponding key-id used for integrity protection, as described in more detail in Section 4.7 below.
[0022] To simplify implementation and reduce the risk of security holes, restrictions are specified such that STARTTLS as specified in [IETF RFC 3788] is no longer supported in some embodiments.
[0023] Comparison with TLS for SCTP DTLS, as derived from TLS, is designed to run on top of a byte-stream oriented transport protocol that provides reliable in-sequence delivery. TLS over SCTP, as described in [IETF RFC 3436], has several significant limitations: - does not support unordered delivery of SCTP user messages; - does not support partial reliability as specified in [IETF RFC 3758]; - only supports the use of the same number of streams in each direction; and - Uses a TLS connection for each bidirectional stream, which requires a significant amount of resources and message exchange when a large number of streams are used.
[0024] Changes since IETF RFC 6083 The DTLS over SCTP solution specified in IETF RFC 6083 had the following limitations: The maximum user message size was 2^14 (16384) bytes, which is the limit of a single DTLS record.
[0025] An embodiment of the present invention may replace IETF RFC 6083 and may include the following modifications: - removing the limitation on user message size by defining a secure fragmentation mechanism; - Mandate that a more recent DTLS version is required (DTLS 1.2 or 1.3); - Mandating the use of the latest hash-based message authentication code (HMAC) algorithm (SHA-256) in the SCTP authentication extension [IETF RFC 4895]; - recommends support for [IETF RFC 8260], which allows interleaving of large SCTP user messages to avoid scheduling problems; - Applying stricter requirements to always use DTLS for all user messages within an SCTP association; - requires that SCTP-AUTH be applied to all SCTP chunks where authentication can be performed; and - Request support for partial delivery of user messages.
[0026] DTLS Versions DTLS / SCTP as defined in this document may use either DTLS 1.2 [IETF RFC 6347] or DTLS 1.3 [IETF RFC 9147]. In general, DTLS 1.3 is preferred as it is a newer protocol that addresses known vulnerabilities and defines only strong algorithms that have no known major weaknesses at the time of publication.
[0027] Using DTLS 1.2 instead of DTLS 1.0 limits the lifetime of a DTLS connection and the amount of data that can be transferred over a DTLS connection. This is due to the following: - The number of renegotiations in DTLS 1.2 is limited to 65534 compared to unlimited in DTLS 1.0; and - The authenticated encryption with associated data (AEAD) limits of DTLS 1.3 do not formally apply to DTLS 1.2, but the mathematical limitations apply to DTLS 1.2 as well.
[0028] DTLS 1.3 has a number of important changes: - Renegotiations are not supported and are instead partially replaced by KeyUpdates, the number of KeyUpdates is limited to 2^64. - Strict AEAD severely limits the number of packets that can be sent before re-keying.
[0029] Many applications that use DTLS / SCTP are semi-persistent in nature, using SCTP associations that have expected lifetimes of months or years, and where taking down an SCTP association in order to restart it can be quite costly. Such use of DTLS / SCTP is necessary: - Periodic reauthentication of both endpoints (not just the DTLS client); - Providing Perfect Forward Secrecy (PFS) by periodically replaying the Diffie-Hellman key exchange to reduce the impact of any key disclosure; and - Perform SCTP-AUTH re-keying.
[0030] At the time of publication, DTLS 1.3 does not support any of these, but the renegotiation feature of DTLS 1.2 could provide this functionality in the context of DTLS / SCTP. To address these requirements from semi-persistent applications, embodiments of the present invention use several overlapping DTLS connections with either DTLS 1.2 or 1.3. Having a unified procedure reduces the impact when upgrading from 1.2 to 1.3 and avoids the use of the renegotiation mechanism, which is disabled by default in many DTLS implementations.
[0031] To address known vulnerabilities in DTLS 1.2, this specification describes and requires implementation constraints on the usage of ciphers, protocol options, and DTLS renegotiation mechanisms.
[0032] In the remainder of this specification, the text applies to both versions of DTLS unless a version of DTLS is specifically stated.
[0033] 2. Convention 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 BCP 14 [IETF RFC 2119] [IETF RFC 8174] only when they appear in all uppercase as shown below.
[0034] 3. DTLS considerations DTLS Versions This document defines the use of DTLS 1.3 [ID.ietf-tls-dtls13] or DTLS 1.2 [IETF RFC 6347]. Earlier versions of DTLS MUST NOT be used (see [IETF RFC 8996]). DTLS / SCTP as described in this document is expected to work with future versions of DTLS.
[0035] 3.2. Cipher Suites and Cryptographic Parameters For DTLS 1.2, cipher suites prohibited by [IETF RFC 7540] MUST NOT be used. For all versions of DTLS, cryptographic parameters that provide confidentiality and Perfect Forward Secrecy (PFS) MUST be used.
[0036] Message Size DTLS / SCTP automatically fragments and reassembles user messages. This specification defines how user messages are split into DTLS records, where each DTLS 1.3 record can use up to 2^14 protected bytes. Each DTLS record adds some overhead, so using the largest possible size record is recommended to minimize transmitted overhead.
[0037] The sequence of DTLS records is then fragmented by SCTP into Data or I-Data chunks to fit into the Path MTU. The largest user message possible using the mechanisms defined in this specification is 2^64-1 bytes.
[0038] The security operations and reassembly process require that protected user messages, i.e., messages with DTLS record overhead, are buffered at the receiver. This buffer space therefore imposes a limit on the maximum size of a plaintext user message that can be securely transferred. However, by requiring the use of partial delivery of user messages from SCTP and assuming that two messages received on the same stream are not interleaved (as when using the APIs defined in [IETF RFC 6458]), the buffering required before DTLS processing can be limited to a single DTLS record per incoming stream used.
[0039] This allows a DTLS / SCTP implementation to provide the contents of each DTLS record, once decrypted and its integrity verified, to the Upper Layer Protocol (ULP), allowing partial user message delivery to the ULP. An implementation may trade off buffer memory requirements and transport overhead at the DTLS layer by using smaller DTLS records.
[0040] DTLS / SCTP implementations are expected to behave very similarly to SCTP with respect to handling of user messages, handling of large user messages, and their reassembly and processing, simply letting the ULP be involved in handling the resource contention associated with large user messages.
[0041] 3.4. Replay Protection SCTP-AUTH [IETF RFC 4895] does not have explicit replay protection. However, the combination of SCTP-AUTH's protection of DATA or I-DATA chunks and SCTP user message processing prevents attempts by a third party to inject or replay SCTP packets and affect received protected user messages. In fact, the solution in this document relies on SCTP-AUTH and SCTP to prevent reordering, duplication, and deletion of DTLS records within each protected user message. This includes detecting changes to which DTLS records begin and end an SCTP user message, and deleting DTLS records before incrementing the epoch. Without SCTP-AUTH, all of this requires explicit processing.
[0042] DTLS optionally supports record replay detection. Such replay detection could result in the DTLS layer dropping valid messages received outside the DTLS replay window. Since DTLS / SCTP provides replay protection without DTLS replay protection, DTLS replay detection MUST NOT be used.
[0043] 3.5. Path MTU Discovery DTLS Path MTU Discovery MUST NOT be used. Since SCTP provides path MTU discovery and fragmentation / reassembly for user messages, DTLS may send maximum-sized DTLS records per Section 3.3.
[0044] 3.6. Resending a Message SCTP provides a reliable, in-sequence transport service for DTLS messages that require it, see Section 4.4, therefore the DTLS procedures for retransmission MUST NOT be used.
[0045] 4. SCTP considerations 4.1. Mapping of DTLS Records An SCTP implementation MUST support fragmentation of user messages using DATA [IETF RFC 4960] and, optionally, I-DATA [IETF RFC 8260] chunks.
[0046] DTLS / SCTP acts as a shim layer between the user message API and SCTP. Fragmentation works similarly to DTLS fragmentation of handshake messages. On the sending side, the user message is fragmented into fragments m0, m1, and m2, each of less than 2^14=16384 bytes. m0 | m1 | m2 | ... = user_message The resulting fragments are protected with DTLS and the records are concatenated. user_message' = DTLS( m0 ) | DTLS( m1 ) | DTLS( m2 ) ... The new user_message', ie the protected user message, is the input to SCTP. On the receiving side, DTLS is used to decrypt each record. There are three failure cases that an implementation must detect and subsequently take action against:
[0047] 1. Failure of the DTLS record decryption and integrity verification process: Because SCTP-AUTH prevents delivery of injected or corrupted fragments of protected user messages, this should only occur in case of implementation error or internal hardware failure, or if the necessary security context is prematurely destroyed.
[0048] 2. When the SCTP layer receives MSG_EOR on a recvmsg() call when using the APIs described in [IETF RFC 6458], indicating the end of a user message, the length field of the last buffered DTLS record does not match, i.e., the DTLS record is incomplete.
[0049] 3. Due to lack of resources, such as memory, the decryption process cannot be performed and user message fragments must be discarded. This specification defines the resources required for DTLS / SCTP operation to be bounded for a given number of simultaneously transmitted SCTP streams or unordered user messages.
[0050] All of the above failure cases result in the receiver being unable to reconstruct the complete user message. This is a transport service failure that cannot be restored at the DTLS / SCTP layer, and the sender may consider the complete message to have been delivered. This error MUST NOT be ignored, since SCTP lacks the ability to declare a failure on a particular stream or user message, and the DTLS connection and the SCTP association SHOULD be terminated. A valid exception to termination of the SCTP association is when the receiver is able to inform the ULP about the delivery failure and the ULP is able to recover from this failure.
[0051] Note that if the SCTP extension for Partial Reliability (PR-SCTP) [IETF RFC 3758] is used for user messages, user messages may be partially delivered or discarded: these failures are not a reason to terminate the DTLS connection and the SCTP association.
[0052] A DTLS connection ID MUST be negotiated ([draft-ietf-tls-dtls-connection-id] or Section 9 of [ID.ietf-tls-dtls13]). If DTLS 1.3 is used, a length field MUST be included and a 16-bit sequence number SHOULD be used.
[0053] Section 4 of [draft-ietf-tls-dtls-connection-id] states that "However, if an implementation chooses to receive CIDs of different lengths, the assigned CID value MUST be self-delineating, since there is no other mechanism available to determine which connection (and therefore which CID length) is being used." Because this solution requires multiple connection IDs, using a zero-length CID would be very problematic, as a DTLS record with a zero-length CID could end up in a different DTLS connection context, causing decryption and integrity verification to fail. In that case, to avoid losing the DTLS record, it must be transferred using the DTLS connection to the zero-length CID, and decryption and verification must be attempted. This would improve resource utilization. Therefore, it is RECOMMENDED not to use zero-length CID values, and instead to use a single common length for CID values. Reuse of old CIDs is possible as long as the implementation ensures that they are not used too close to previous uses, so one byte should be sufficient.
[0054] 4.2 Handling DTLS connections A DTLS connection MUST be established at the start of an SCTP association. If an SCTP association is terminated, all DTLS connections are terminated. A DTLS connection MUST NOT span multiple SCTP associations.
[0055] Since a DTLS connection is required to be established at the start of an SCTP association, neither peer should send any SCTP user messages that are not protected by DTLS. Thus, it is a protocol violation for an endpoint to receive data that is neither a DTLS message on stream 0 nor a protected user message in the form of a sequence of DTLS records on any stream. The recipient MAY terminate the SCTP association due to this protocol violation.
[0056] Whenever mutual authentication, updated security parameters, re-performed Diffie-Hellman key exchange, or SCTP-AUTH re-keying is required, a new DTLS connection is set up in parallel to the old one (i.e., there can be at most two simultaneous DTLS connections within one association).
[0057] 4.3 Use of Payload Protocol Identifiers SCTP Payload Protocol Identifiers are assigned by IANA. Application protocols that use DTLS over SCTP SHOULD register and use a distinct Payload Protocol Identifier (PPID) and SHOULD NOT reuse registered PPIDs to run directly over SCTP.
[0058] As long as the application can determine whether DTLS is used or not, there is no harm in using the same PPID, but for example for protocol analyzers it is much easier if separate PPIDs are used.
[0059] This means, among other things, that there is no unique PPID for DTLS.
[0060] 4.4 Using Streams All DTLS handshake, alert, or ChangeCipherSpec (DTLS 1.2 only) messages MUST be transmitted over Stream 0, which provides unlimited reliable and ordered delivery.
[0061] Record protocol DTLS messages carrying protected user messages SHOULD use streams other than stream 0, and MAY use stream 0. Head of line blocking can occur in stream 0 due to the intermixing of protected user messages with non-record protocol DTLS messages.
[0062] 4.5 Chunk Handling SCTP DATA chunks MUST be transmitted in an authenticated manner as described in [IETF RFC 4895]. All other chunks that may be authenticated, i.e., all chunk types that may be listed in the Chunk List Parameter [IETF RFC 4895], MUST also be transmitted in an authenticated manner. This ensures that an attacker cannot modify the stream on which messages are transmitted or affect ordered / unordered delivery of messages.
[0063] When partially reliable SCTP (PR-SCTP), as defined in [IETF RFC 3758], is used, the FORWARD-TSN chunk MUST also be sent in an authenticated manner as described in [IETF RFC 4895]. This ensures that an attacker cannot drop a message and hide this drop using forged FORWARD-TSN, SACK, and / or SHUTDOWN chunks.
[0064] The I-DATA chunk type defined in [IETF RFC 8260] is RECOMMENDED to be supported to avoid some of the downsides that large user messages have in blocking the transmission of later arriving higher priority user messages, but support is not required and is not negotiated independently of DTLS / SCTP. If I-DATA chunks are used, they MUST be sent in an authenticated manner as described in [IETF RFC 4895].
[0065] 4.6 SCTP-AUTH Hash Functions The SHA-256 message digest algorithm MUST be supported in SCTP-AUTH [IETF RFC 4895] implementations when using DTLS / SCTP. SHA-1 MUST NOT be used when using DTLS / SCTP. [IETF RFC 4895] requires support for and inclusion of the HMAC-ALGO parameter, therefore, to satisfy both requirements, the HMAC-ALGO parameter includes both SHA-256 and SHA-1 with SHA-256 listed before SHA-1 to indicate preference.
[0066] 4.7 Parallel DTLS Connections To enable rekeying of SCTP-AUTH, periodic authentication of both endpoints, and forcing an attacker to dynamically extract keys, DTLS / SCTP according to this specification defines the use of a parallel DTLS connection on the same SCTP association. This solution ensures that there is no limit on the lifetime of an SCTP association with DTLS, and also avoids reliance on the rekeying property of DTLS 1.3 that does not allow DTLS renegotiation (DTLS 1.2 only) or mutual endpoint reauthentication. While the existing DTLS is maintained as is, the parallel DTLS connection allows opening a new DTLS connection that performs a full handshake and may use resumption. Upon handshake completion, it switches to the security context of the new DTLS connection and ensures delivery of all SCTP chunks using the security context of the old DTLS connection. Once this is achieved, it closes the old DTLS connection and destroys the associated security context.
[0067] The use of the DTLS connection ID, as specified in Section 4.1, is required to ensure that the receiver can correctly identify the DTLS connection and its security context when performing its de-protection operations. Also, only one SCTP-AUTH key is exported per DTLS connection, which ensures that for each key-id, there is an unambiguous mapping between the DTLS connection and the SCTP-AUTH security context, unless DTLS 1.2 renegotiation is used where multiple keys may be exported.
[0068] Application writers should be aware that establishing a new DTLS connection may change security parameters - see Section 8 for security considerations regarding re-keying.
[0069] A DTLS / SCTP endpoint MUST NOT open more than one DTLS connection at a time. Either endpoint MAY initiate a new DTLS connection by performing a full DTLS handshake and MAY use DTLS resumption, if applicable. Since either endpoint may initiate a DTLS handshake on both sides at the same time, either endpoint may receive a DTLS ClientHello when it has sent its own ClientHello. In this case, the ClientHello from the endpoint that has the role of DTLS client in the existing DTLS connection establishment should continue to be processed and the other one dropped.
[0070] When performing a DTLS handshake, an endpoint MUST verify that the peer identifies itself using the same identity as in the previous DTLS connection.
[0071] Once the DTLS handshake is complete, a new SCTP-AUTH key (as shown in Figure 1) is exported according to Section 4.9, and the new DTLS connection MUST be used for DTLS protected operations on future protected SCTP messages. It is RECOMMENDED that the endpoints use the security context of the new DTLS connection for DTLS protected operations that occur after the handshake is complete. The new SCTP-AUTH key SHALL be used for any SCTP messages sent after the DTLS handshake is complete. There is a possibility to use the new SCTP-AUTH key for any SCTP packet portion of an SCTP message that was initiated but not yet completely transmitted before the new DTLS handshake is complete, but the API defined in [IETF RFC 6458] does not support this unless the extensions in Section 6 are supported.
[0072] An SCTP endpoint informs its peer when a previous DTLS connection and its context are no longer needed to receive further data from this endpoint. This is done by having DTLS send a DTLS close_notify alert. An endpoint MUST NOT send a close_notify until the following two conditions are met: - all SCTP packets that contain part of any DTLS record or message protected using the security context of this DTLS connection are acknowledged in a non-reproducible manner; and - All SCTP packets that use the security context of this DTLS connection and the associated SCTP-AUTH key are acknowledged in a non-reproducible manner.
[0073] Here is a very basic way to determine the above condition for an implementation that allows using the new DTLS connection security context for all future DTLS records to be protected, and simultaneously activating the associated new SCTP-AUTH key, and not using the old context for future protection operations. Mark the time when the first SCTP chunk that is part of the first (partial) SCTP messaging call that uses the new security context is sent. That SCTP chunk, and therefore all previous chunks that use the old security context, must be delivered to the peer before an endpoint failure detection (see Section 8.1 of [IETF RFC 4960]) triggers and terminates the SCTP association. Calculate an upper bound on this timeout period, which depends on two configurable parameters: The maximum endpoint failure timeout period is the product of the 'Association.Max.Retrans' and RTO.Max parameters. For default values of RTO.Max = 60 seconds and a time of 10 attempts (i.e., 10 minutes) per [IETF RFC 4960].
[0074] For SCTP implementations that expose an API like [IETF RFC 6458], it is not possible to change the SCTP-AUTH key for partial SCTP messages that were started before the security context was changed, so they are forced to track the SCTP messages to determine when all messages using the old security context have been sent. This may not be possible to do completely reliably without a tighter integration between the DTLS / SCTP layer and the SCTP implementation. This type of implementation also has implicit limitations on the size of the SCTP messages it can support. Each SCTP message needs to be delivered to completion and allow the previous DTLS connection to be closed before yet another DTLS connection needs to be created. For this reason, an SCTP message cannot be larger than the time required for transmission to be completed in less time than the duration between re-keying or re-authentication for this SCTP association.
[0075] If a DTLS / SCTP implementation were more tightly integrated with the SCTP stack, or had a more complete API that allowed it to know when SCTP messages were delivered, it could close old DTLS connections in a more timely manner, and therefore support more frequent re-keying, etc., if necessary.
[0076] Sending a DTLS close_notify alert on an old DTLS connection before the receiver has received any data may result in failure case 1 described in Section 4.1, which may lead to the termination of the SCTP association.
[0077] 4.7b. Renegotiation and KeyUpdate DTLS 1.2 renegotiation allows DTLS re-keying (using ephemeral Diffie-Hellman) as well as mutual reauthentication within a DTLS 1.2 connection. Renegotiation has been removed from DTLS 1.3 and partially replaced with post-handshake messages such as KeyUpdate. The parallel DTLS connection solution was specified due to the absence of necessary features in DTLS 1.3, such as mutual reauthentication as well as re-keying (using ephemeral Diffie-Hellman), which are considered necessary for long-lived SCTP associations.
[0078] This document recommends not using either of these mechanisms and relying instead on parallel DTLS connections. In the case of DTLS 1.3, there is no feature parity. Both have the problem that DTLS implementations following standards, including IETF RFCs, may assume windows that are too restrictive for SCTP, where security context from previous epochs is maintained, thus necessitating changes to epoch handling (Section 4.8). Thus, there is a risk that senders will lose data that was assumed to be reliably delivered, unless more applications, specified below, that affect draining are used.
[0079] 4.7b.1 DTLS 1.2 Considerations An endpoint MUST NOT initiate a DTLS renegotiation on an existing / old DTLS connection after it initiates the establishment of a new parallel DTLS connection on this SCTP association. If a new DTLS connection handshake is received after an endpoint initiates a DTLS renegotiation on an existing DTLS connection, both parties SHOULD complete the renegotiation, the SCPT-AUTH key identifier SHOULD be n+1, and the new DTLS connection SHOULD use n+2. This can be achieved by first terminating the renegotiation and then holding off on the new DTLS handshake process until the renegotiation is complete.
[0080] Before sending a ClientHello or ServerHello message during a renegotiation, a DTLS endpoint MUST ensure that all DTLS messages using the previous epoch have been irrevocably acknowledged by its SCTP peer.
[0081] Before processing a received ClientHello or ServerHello message, all other received SCTP user messages that may be buffered at the SCTP layer and delivered to the DTLS layer MUST be read and processed by DTLS.
[0082] 4.7b.2 DTLS 1.3 Considerations Before sending a KeyUpdate message, a DTLS endpoint MUST ensure that all DTLS messages have been irrevocably acknowledged by the SCTP peer. After sending a KeyUpdate message, it stops sending DTLS messages until the corresponding Ack message has been processed.
[0083] Before processing a received KeyUpdate message, all other received SCTP user messages that may be buffered at the SCTP layer and delivered to the DTLS layer MUST be read and processed by DTLS.
[0084] 4.7c Operational Flow In some embodiments, establishing two parallel DTLS connections over an SCTP association includes the following operations:
[0085] 1. Initiate a new DTLS handshake protected by the existing SCTP-AUTH key. 2. Complete the DTLS handshake, establishing a new security context and exporting a new SCTP-AUTH key given the key identifier. 3. Start using a new DTLS connection and the established security context to protect the entire message or a fragment of it from upper layer protocols, and stop using the previous DTLS connection to protect any new ULP messages. 4. Start using the new SCPT-AUTH key in any future SCTP packets or messages and do not use the old key for any new SCTP messages. 5. Each endpoint determines when all protected message fragments and SCTP packets have been delivered and closes the old DTLS connection in that direction. 6. When the DTLS connection is closed, delete the security context and the SCTP-AUTH keys exported for this DTLS connection.
[0086] 2 illustrates operations for establishing a parallel DTLS connection over an SCTP association according to some embodiments. The operations may be performed by a network node implementing a parallel DTLS connection coordinator 112. The network node, in some embodiments, is a first network node that encodes a user message for secure transmission to a second network node.
[0087] At reference 202, a network node establishes a Datagram Transport Layer Security (DTLS) connection over a Stream Control Transmission Protocol (SCTP) association to transmit user messages for one or more applications, where the DTLS connection is the first of two parallel DTLS connections over the same SCTP association and may also be referred to as an existing DTLS connection.
[0088] At reference 204, a network node initiates a Datagram Transport Layer Security (DTLS) connection on a Stream Control Transmission Protocol (SCTP) association through a DTLS handshake using an existing Authenticated Chunks for SCTP (SCTP-AUTH) key from an existing DTLS connection on the SCTP association to send a user message. The initiated DTLS connection is the second of two parallel DTLS connections on the same SCTP association.
[0089] At reference 206, the network node derives a new SCTP-AUTH key from the initiated DTLS connection. Optionally, at reference 208, the network node, in some embodiments, sends an ongoing SCTP packet that includes a further portion of the user message protected by the initiated DTLS connection but authenticated with the existing SCTP-AUTH key. Alternatively, the network node may send an ongoing SCTP packet that includes a further portion of the user message that is protected by the existing DTLS connection and that should be authenticated with the existing SCTP-AUTH key.
[0090] At reference 210, the network node sends further user messages over the opened DTLS connection using the new SCTP-AUTH key. At reference 212, the network node closes the existing DTLS connection on the SCTP association upon verifying delivery of SCTP packets encrypted over the existing DTLS connection and authenticated by the existing SCTP-AUTH key.
[0091] In some embodiments, closing the existing DTLS connection on the SCTP association includes sending a first DTLS connection close notification to the second network node. The first DTLS connection close notification may be a DTLS close_notify alert as described above.
[0092] In some embodiments, closing the existing DTLS connection on the SCTP association further includes receiving a second DTLS connection close notification from the second network node.
[0093] In some embodiments, sending the first DTLS connection close notification includes verifying that transmissions in the existing DTLS connection have been acknowledged by the second network node in a non-reproducible manner prior to sending the first DTLS connection close notification, such as verifying that 1) all SCTP packets that contain part of any DTLS record or message protected using the security context of the DTLS connection have been acknowledged in a non-reproducible manner, and / or 2) all SCTP packets that use an SCTP-AUTH key associated with the security context of the DTLS connection have been acknowledged in a non-reproducible manner.
[0094] In some embodiments, the existing and new SCTP-AUTH keys are identified by corresponding existing and new key identifiers (IDs), where the new identifier is the existing key identifier incremented by one. As the above example shows, if the previous shared secret used shared key identifier n, the new one uses shared key identifier n+1. In some embodiments, a modulo operation may be performed, e.g., the new shared key identifier is (n+1) mod 65535 in the case of a 16-bit implementation (if the result=0, it is set to 1; e.g., if n=65534, n+1=65535, and (n+1) mod(65535)=0, then the new key ID is 1). If the key ID is implemented with a different bit width, the divisor is also changed. For example, if the key ID is implemented with 8 bits, the divisor is 255.
[0095] In some embodiments, the DTLS connection is established before one or more certificates of an existing DTLS connection on the SCTP association expire. In some embodiments, initiating the DTLS connection on the SCTP association via a DTLS handshake includes maintaining the one or more certificates of the existing DTLS connection, including timestamps in the one or more certificates.
[0096] In some embodiments, performing a handshake between the first network node and the second network node includes initiating a handshake and, in response to receiving an initiation of the handshake, continuing the initiated handshake if the first network node acts as a DTLS client for the DTLS connection.
[0097] In some embodiments, existing SCTP-AUTH keys are deleted in response to closing an existing DTLS connection.
[0098] The present invention avoids the impact of applications pausing or at least delaying data transmission in a DTLS / SCTP session during the data draining drain phase on key change with existing solutions. The drain phase is avoided because DTLS protection records are self-describing (a feature of DTLS 1.3 and an extension of DTLS 1.2) and can coexist when session IDs are enabled. Furthermore, independent DTLS connection management allows explicit asynchronous close signaling when each side knows that all data using this key has been delivered first, thus closing down the connection and discarding the private key material. Thus, parallel DTLS connections avoid some of the problems of using DTLS 1.2 with renegotiation. It also ensures that important features can be achieved when using DTLS 1.3.
[0099] 4.8 DTLS Epoch In general, DTLS implementations SHOULD discard records from previous epochs, but in the context of reliable communications this is not appropriate.
[0100] 4.8.1 DTLS 1.2 Considerations The procedures in Section 4.1 of [IETF RFC 6347] MUST NOT be followed.
[0101] Instead, if epoch n is currently in use, then for n>1, DTLS packets from epochs n-1 and n MUST be processed.
[0102] 4.8.2. DTLS 1.3 Considerations The procedures in Section 4.2.1 of [ID.ietf-tls-dtls13] are irrelevant: when receiving a DTLS packet using epoch n, no DTLS packets from previous epochs are received.
[0103] 4.9. Handling Endpoint Pair Shared Secrets SCTP-AUTH [IETF RFC 4895] is keyed using an endpoint pair shared secret. For SCTP associations where DTLS is used, DTLS is used to establish these secrets. Endpoints MUST NOT use another mechanism to establish a shared secret for SCTP-AUTH. The endpoint pair shared secret for shared key identifier 0 is empty and MUST be used when establishing the first DTLS connection.
[0104] The initial DTLS connection is used to establish a new shared secret as specified according to the DTLS version below, and MUST use shared key identifier 1. After sending the DTLS Finished message, the active SCTP-AUTH key MUST be switched to the new one. Once the initial Finished message from the peer has been processed by DTLS, the SCTP-AUTH key with shared key identifier 0 MUST be deleted.
[0105] When a subsequent DTLS connection is set up, a new 64-byte shared secret is derived using the TLS-Exporter. The shared secret identifiers form a sequence. If the previous shared secret used shared key identifier n, then the new one MUST use shared key identifier n+1.
[0106] After sending the DTLS Finished message, the active SCTP-AUTH key MUST be switched to the new one. If the endpoint both sent and received a closeNotify on the old DTLS connection, the endpoint SHOULD delete the shared secret(s) associated with the old DTLS connection.
[0107] 4.9.1. DTLS 1.2 Considerations Each time the master secret is changed, i.e., due to either a DTLS renegotiation or the establishment of a new DTLS connection, a 64-byte shared secret is derived from every master secret and provided as the new endpoint pair shared secret by using the TLS-Exporter described in [IETF RFC 5705].
[0108] The 64-byte shared secret MUST be provided to the SCTP stack as soon as it is possible to compute it. The exporter MUST use the label given in Section 7 and MUST NOT use a context. The shared key identifier is chosen according to the above such that it remains n+1 across epoch changes due to renegotiations.
[0109] When a Finished message using a DTLS epoch m>2 is processed by DTLS, the SCTP-AUTH keys with the shared key identifier for this DTLS connection and epoch m-2 MUST be deleted.
[0110] When a DTLS connection is closed and it uses renegotiation, all outstanding shared keys MUST be deleted when a new DTLS connection is created, n+1, which should be n and n-1.
[0111] 4.9.2. DTLS 1.3 Considerations If the exporter_secret can be computed, a 64-byte shared secret is derived from it and provided as the new endpoint pair shared secret by using the TLS exporter described in [IETF RFC 8446]. The 64-byte shared secret MUST be provided to the SCTP stack as soon as it can be computed. The exporter MUST use the label given in Section 7 and MUST NOT use the context.
[0112] Shutdown To prevent DTLS from discarding DTLS user messages during shutdown, a CloseNotify message MUST be sent only after all outstanding SCTP user messages have been irrevocably acknowledged by the SCTP peer.
[0113] Before processing a received CloseNotify, all other received SCTP user messages buffered at the SCTP layer MUST be read and processed by DTLS.
[0114] 5. DTLS over SCTP Service Adopting DTLS over SCTP as currently described would mean adding an option to SCTP for transporting encrypted data.
[0115] When DTLS over SCTP is used, all data transferred MUST be protected by chunk authentication and DTLS encryption. The chunks that need to be received in an authenticated manner are specified in the CHUNK list parameter according to [IETF RFC 4895]. Error handling for authenticated chunks follows [IETF RFC 4895].
[0116] 5.1. Adaptation Layer Indication in INIT / INIT-ACK When initializing an association, a sender of an INIT or INIT ACK chunk that wishes to use DTLS / SCTP as specified in this specification MUST include an Adaptation Layer Indication Parameter with the IANA assigned value TBD (Section 7.2) to inform the peer that it can support DTLS over SCTP in accordance with this specification.
[0117] 5.2. Initialization of DTLS over SCTP 3 illustrates a signaling diagram 300 between a first node and a second node according to some embodiments of the present disclosure. Diagram 300 illustrates an initialization between a first node (network node 1) 310 and a second node (network node 2) 320. Network node 1 and network node 2 may be any type of nodes that communicate with each other, such as nodes in a communication network.
[0118] DTLS / SCTP initialization requires all of the following options as part of the INIT / INIT-ACK handshake: - RANDOM: defined in [IETF RFC 4895] - CHUNKS: A list of allowed chunks as defined in [IETF RFC 4895]. - HMAC-ALGO: defined in [IETF RFC 4895] ‐ADAPTATION-LAYER-INDICATION: defined in [IETF RFC 5061]
[0119] If all of the above options are present, the association starts with support for DTLS / SCTP. The set of options shown are DTLS / SCTP required options. No data transfer is allowed before the DTLS handshake is complete. Chunk bundling is allowed as per [[IETF RFC 4960]. The DTLS handshake allows authentication of both peers and also declares their supported message sizes.
[0120] It should be understood that other options or alternative techniques may be implemented. In the presence of the above options, the association begins with node 320 initiating signaling. A DTLS support indication (or a similar alternative) in INIT S301 informs node 310 that node 320 supports extended DTLS / SCTP. In some embodiments, the DTLS support indication is an Adaptation-Layer-Indication with a value indicating DTLS / SCTP capabilities. No data transfer is allowed before the DTLS handshake is completed. Data chunks received before the DTLS handshake may be silently discarded. Chunk bundling is allowed according to IETF RFC 4960. The DTLS handshake allows authentication of both peers as well as their supported message sizes.
[0121] When the SCTP client node 320 initiates an association S301, a DTLS-Supported indication signals to the node 310 that the client supports the extended DTLS / SCTP options, and DTLS-Supported may further indicate the size of messages it can receive, or alternatively, the number of DTLS fragments it can receive. Various factors may limit the message size or number of fragments that can be received. In response, the server node 310 indicates that the node 310 is capable of extensions and will not revert to legacy use of only a single DTLS segment by sending an INIT-ACK S302 that also includes the extended DTLS / SCTP options. In some embodiments, DTLS-Supported may only include information related to the ability to implement extended DTLS / SCTP. In that case, information regarding message / fragment sizes may be exchanged in a later handshake signal, as described below. The DTLS-Supported signaling may include other information for transfer between the two nodes as well.
[0122] Node 320 may indicate that node 310 is capable of extensions and will not revert to legacy use of only a single DTLS segment by sending an INIT-ACK S302 that also includes the extended DTLS / SCTP option. The term "option" refers to instances where, in some embodiments, there is an option to use legacy or extended technology. In some embodiments, the extended technology may be a mandatory requirement. If node 310 responds with an INIT-ACK that does not include the extended DTLS / SCTP option, node 320 may decide to continue operating with legacy IETF RFC 6083 (e.g., single DTLS), continue operating with plain data only, or abort the association.
[0123] If node 310 (e.g., an SCTP server) supports extended DTLS / SCTP, upon receiving INIT signaling S301 with the DTLS / SCTP option, it may indicate that node 310 can send extended DTLS / SCTP by responding with INIT-ACK signaling S302 that also includes the extended DTLS / SCTP option. Node 310 may follow the sequence for DTLS initialization and associated traffic cases. After forwarding SCTP COOKIE-ECHO S303 and COOKIE-ACK S304 signaling, node 320 may initiate DTLS forwarding by sending a DTLS handshake S305. In response, node 310 may send messages with extended DTLS / SCTP based on the size restrictions indicated by node 320 in S306.
[0124] As noted above, in some embodiments, signaling of the message size or number of fragments that node 320 can receive may be included with the DTLS-Supported indication in S301. However, in some embodiments, this information may be sent during the initiation of the DTLS handshake S305 instead of DTLS-Supported. Additionally, other embodiments may provide this information in other signaling.
[0125] 5.3 Client Use Cases If a client initiates an SCTP association with DTLS protection, i.e., an SCTP INIT that includes the DTLS / SCTP-required option, the client can receive an INIT-ACK that also includes the DTLS / SCTP-required option, in which case the association proceeds as specified above in Section 5.2. If the peer responds with an INIT-ACK that does not include any DTLS / SCTP-required options, the client SHOULD respond with an SCTP ABORT.
[0126] 5.4. Server Use Cases If an SCTP server supports DTLS / SCTP, i.e., according to this specification, when it receives an INIT chunk with all DTLS / SCTP-required options, it responds with an INIT-ACK that also includes all DTLS / SCTP-required options, following the DTLS initialization sequence and related traffic cases of Section 5.2. If an SCTP server that supports and is configured to use DTLS receives an INIT chunk without all DTLS / SCTP-required options, it SHOULD respond with an SCTP ABORT.
[0127] 5.5 IETF RFC 6083 Fallback This section describes how endpoints that support this specification can fall back to the DTLS / SCTP behavior of IETF RFC 6083. It is recommended to define a configuration to indicate whether or not fallback is allowed. However, the possibility of using fallback is based on the ULP being able to operate using user messages of 16384 bytes or less, and security issues can be mitigated or deemed acceptable.
[0128] considered acceptable. It is NOT RECOMMENDED to enable fallbacks as they allow downgrades to weaker algorithms and versions of DTLS.
[0129] An SCTP endpoint that receives an INIT or INIT-ACK chunk that does not contain an SCTP adaptation indication parameter with a DTLS / SCTP adaptation layer codepoint (see Section 7.2) could potentially fall back to IETF RFC 6083 behavior in some cases, but a fallback attempt SHOULD only be performed if policy states that it is acceptable.
[0130] If fallback is allowed, the client can send plaintext user messages before the DTLS handshake, as allowed according to IETF RFC 6083, so that should be part of the considerations of the policy that allows fallback.
[0131] 6. Socket API Considerations This section describes how to extend the sockets API defined in [IETF RFC6458] to provide a way for applications to observe the HMAC algorithm used to send and receive AUTH chunks.
[0132] This section is for informational purposes only.
[0133] Socket API implementations based on [IETF RFC 6458] are extended with the existing SCTP_AUTHENTICATION_EVENT event to provide event notification whenever a new HMAC algorithm is used in a received AUTH chunk.
[0134] Additionally, two new socket options for level IPPROTO_SCTP and names SCTP_SEND_HMAC_IDENT and SCTP_EXPOSE_HMAC_IDENT_CHANGES are defined as described below. The first socket option is used to query the HMAC algorithm used to send AUTH chunks. The second socket option enables monitoring of the HMAC algorithm used in AUTH chunks received via the SCTP_AUTHENTICATION_EVENT event.
[0135] Support for the SCTP_SEND_HMAC_IDENT and SCTP_EXPOSE_HMAC_IDENT_CHANGES socket options also needs to be added to the function sctp_opt_info().
[0136] 6.1. Socket option to get the HMAC identifier to be sent (SCTP_SEND_HMAC_IDENT) During SCTP association establishment, an HMAC identifier is selected that is used by the SCTP endpoint when sending AUTH chunks.
[0137] An application can access the result of this selection by using this read-only socket option, which uses level IPPROTO_SCTP and name SCTP_SEND_HMAC_IDENT.Devices.
[0138] The following configuration is used to access the HMAC identifier used to send the AUTH chunk: struct sctp_assoc_value { sctp_assoc_t assoc_id; uint32_t assoc_value; };
[0139] assoc_id: This parameter is ignored for one-to-one style sockets.
[0140] For one-to-many style sockets, the application enters an association identifier. It is an error to use SCTP_{FUTURE|CURRENT|ALL}_ASSOC in assoc_id.
[0141] assoc_value: This parameter contains the HMAC identifier used to send the AUTH chunk.
[0142] 6.2. Disclosure of Received HMAC Identifiers Section 6.1.8 of [IETF RFC 6458] defines the SCTP_AUTHENTICATION_EVENT event, which uses the following structure: struct sctp_authkey_event { uint16_t auth_type; uint16_t auth_flags; uint32_t auth_length; uint16_t auth_keynumber; uint32_t auth_indication; sctp_assoc_t auth_assoc_id; };
[0143] This specification struct sctp_authkey_event { uint16_t auth_type; uint16_t auth_flags; uint32_t auth_length; uint16_t auth_identifier; / * Previous auth_keynumber * / uint32_t auth_indication; sctp_assoc_t auth_assoc_id; }; For SCTP_AUTHENTICATION_EVENT, update this structure by renaming auth_keynumber to auth_identifier. Renaming auth_keynumber to auth_identifier simply replaces auth_keynumber in the context of [IETF RFC 6458]. In addition, the SCTP_AUTHENTICATION_EVENT event is further extended to indicate when a new HMAC identifier is received and such reporting is explicitly enabled as described in Section 6.3. In this case, auth_indication is SCTP_AUTH_NEW_HMAC and the new HMAC identifier is reported in auth_identifier.
[0144] 6.3. Socket Option to Expose Use of HMAC Identifier (SCTP_EXPOSE_HMAC_IDENT_CHANGES) This option allows an application to enable or disable the receipt of SCTP_AUTHENTICATION_EVENT events when a new HMAC identifier is received in an AUTH chunk (see Section 6.2).
[0145] This read / write socket option uses level IPPROTO_SCTP and name SCTP_EXPOSE_HMAC_IDENT_CHANGES. To provide backward compatibility, by default these events are not reported.
[0146] The following structure is used to enable or disable reporting of newly received HMAC identifiers in AUTH chunks: struct sctp_assoc_value { sctp_assoc_t assoc_id; uint32_t assoc_value; };
[0147] assoc_id: This parameter is ignored for one-to-one style sockets.
[0148] For one-to-many style sockets, the application may input an association identifier or SCTP_{FUTURE|CURRENT|ALL}_ASSOC.
[0149] assoc_value: The newly received HMAC identifier is reported if and only if this parameter is non-zero.
[0150] 7. IANA Considerations 7.1. TLS Exporter Label IETF RFC 6083 defined the TLS exporter label registry as described in [IETF RFC 5705]. IANA is requested to update the label "EXPORTER_DTLS_OVER_SCTP" to reference this specification.
[0151] 7.2. SCTP Adaptation Layer Indication Codepoints [IETF RFC 5061] defined an IANA registry for adaptation codepoints used in adaptation layer indication parameters.
[0152] 8. Security Considerations The security considerations given in [ID.ietf-tls-dtls13], [IETF RFC 4895], and [IETF RFC 4960] also apply to this document.
[0153] 8.1. Encryption Considerations Over the years, there have been several serious attacks against previous versions of Transport Layer Security (TLS), including attacks against the most commonly used ciphers and modes of operation. [IETF RFC 7457] summarizes the attacks that were known at the time of its publication, and BCP 195 [IETF RFC 7525] [IETF RFC 8996] provides recommendations for improving the security of deployed services that use TLS.
[0154] When DTLS / SCTP is used with DTLS 1.2 [IETF RFC 6347], DTLS 1.2 MUST be configured to disable options that are known to provide insufficient security.
[0155] HTTP / 2 [IETF RFC 7540] gives good minimum requirements based on publicly known attacks in 2015. DTLS 1.3 [ID.ietf-tls-dtls13] only defines strong algorithms that had no major weaknesses at the time of publication. Many of the TLS registries have a "recommended" column.
[0156] Parameters not marked with "Y" are NOT RECOMMENDED to be supported. DTLS 1.3 is preferably a newer protocol that addresses known vulnerabilities and defines only strong algorithms that have no known major weaknesses at the time of publication.
[0157] DTLS 1.3 requires a rekey before reaching the algorithm-specific AEAD limit. The AEAD limit formula is equally valid for DTLS 1.2 and SHOULD be followed for DTLS / SCTP, but is not mandated by the DTLS 1.2 specification.
[0158] HMAC-SHA-256, used in SCTP-AUTH, has a very large tag length and very good integrity properties. SCTP-AUTH keys can be used longer than current algorithms in the TLS record layer. SCTP-AUTH keys are re-keyed when a new connection is set up, at which point new SCTP-AUTH keys are derived using the TLS exporter.
[0159] DTLS / SCTP is being widely deployed as an alternative to IPsec. For IPsec, NIST (US), BSI (Germany), and ANSSI (France) recommend frequent reruns of Diffie-Hellman to provide perfect forward secrecy and force attackers to dynamically extract keys. ANSSI states that "to limit the impact of a key leak, it is recommended to enforce periodic updating of keys (e.g., hourly and after 100 GB of data)." [ANSSI-DAT-NT-003]
[0160] In many DTLS / SCTP deployments, DTLS connections are expected to have very long lifetimes, on the order of months or years. For such long-lived connections, both the client and the server need to be reauthenticated frequently. TLS certificate lifetimes of less than a year are common, which is shorter than many anticipated DTLS / SCTP associations.
[0161] Re-keying of SCTP-AUTH, periodic authentication of both endpoints, and frequent replay of Diffie-Hellman to force an attacker to perform dynamic key derivation are achieved in DTLS / SCTP according to this specification by setting up a new DTLS connection on the same SCTP association. Implementations SHOULD set up new connections frequently to force an attacker to perform dynamic key derivation. Implementations MUST set up new connections before any of the certificates expire. When the certificates are new, it is RECOMMENDED that all parameters negotiated and exchanged are the same, except for the timestamp in the certificate. Note that some parameters are typically changed in the new handshake, such as the random number and the connection id. Note that some parameters are typically changed in the new certificate, such as the serial number. Clients and servers MUST NOT accept identity changes during the setup of a new connection, but MAY accept negotiation of stronger algorithms and security parameters, which could be motivated by new attacks.
[0162] When using DTLS 1.2 [IETF RFC 6347], AEAD limits, frequent reauthentication, and frequent Diffie-Hellman replays can also be achieved by renegotiation (see TLS 1.2 [IETF RFC 5246]). If renegotiation is used, both the client and the server MUST use the renegotiation_info extension [IETF RFC 5746] and MUST follow the renegotiation guidelines in BCP 195 [IETF RFC 7525]. In particular, both the client and the server MUST NOT accept identity changes during renegotiation. In many DTLS implementations, renegotiation is disabled by default. While renegotiation updates the exporter_secret, DTLS / SCTP according to this specification only derives new SCTP-AUTH keys when a new connection is set up.
[0163] In DTLS 1.3, renegotiations were removed from DTLS 1.3 and partially replaced with Post-Handshake KeyUpdate. When using DTLS 1.3 [ID.ietf-tls-dtls13], AEAD limits can also be achieved by sending frequent post-handshake KeyUpdate messages.
[0164] Symmetric rekeying provides significantly less protection against key leakage than re-running Diffie-Hellman. After leaking application_traffic_secret_N, a passive attacker can
[0165] It may passively intercept all future application data sent on the connection, including application data encrypted with application_traffic_secret_N+1, application_traffic_secret_N+2, etc.
[0166] Note that KeyUpdate does not update the exporter_secret.
[0167] Allowing client-initiated renegotiations and client-initiated new connections can enable denial-of-service attacks. Servers SHOULD limit the rate of client-initiated renegotiations and new connections.
[0168] When DTLS / SCTP is used with DTLS 1.2 [IETF RFC 6347], the TLS session hash and extended master secret extensions [IETF RFC 7627] MUST be used to prevent unknown key sharing attacks where an attacker establishes the same key across multiple connections. DTLS 1.3 always prevents these types of attacks. The use of SCTP-AUTH cryptographically binds the new connection to the old connection. This, together with mandatory mutual authentication (above the DTLS layer) and the requirement not to accept new identities, mitigates the MITM attacks that plague renegotiation [3SHAKE].
[0169] 8.2. Downgrade Attacks Peers that support DTLS / SCTP in accordance with this specification, DTLS / SCTP in accordance with [IETF RFC 6083], and / or SCTP without DTLS may be vulnerable to downgrade attacks where an on-path attacker interferes with the protocol setup to reduce or disable security. When possible, it is RECOMMENDED that peers have a policy that only allows DTLS / SCTP in accordance with this specification.
[0170] 8.3. Authentication and Policy Decisions DTLS / SCTP MUST be mutually authenticated. It is RECOMMENDED that DTLS / SCTP be used with certificate-based authentication. All security decisions MUST be based on the authenticated identity of the peer, not its transport-layer identity.
[0171] It is possible to authenticate a DTLS endpoint based on the IP address in the certificate. An SCTP association can use multiple IP addresses per SCTP endpoint. Thus, a DTLS record may be sent from a different source IP address or to a different destination IP address than the one originally authenticated. This is not a problem as long as security decisions are not made based on the source or destination IP addresses.
[0172] 8.4. Privacy Considerations [IETF RFC 6973] proposes to document privacy considerations for IETF protocols.
[0173] For each SCTP user message, the user also provides a stream identifier, a flag indicating whether the message is ordered or unordered, and a payload protocol identifier. Although DTLS / SCTP provides privacy for the actual user message, the other three information fields are not confidentiality protected: they are part of the SCTP DATA chunk header and are therefore sent in the clear.
[0174] It is RECOMMENDED that DTLS / SCTP be used in conjunction with the certificate-based authentication in DTLS 1.3 [ID.ietf-tls-dtls13] to provide identity protection. DTLS / SCTP MUST be used in conjunction with a key exchange method that provides perfect forward secrecy, which significantly limits the amount of data that can be leaked due to key compromise.
[0175] 8.5. Pervasive Monitoring As required by [IETF RFC 7258], work on IETF protocols needs to consider the effects of pervasive monitoring and, where possible, mitigate them.
[0176] Pervasive monitoring is the widespread surveillance of users. By encrypting more information, including user identity, DTLS 1.3 provides much better protection against pervasive monitoring.
[0177] Large-scale pervasive monitoring attacks have been reported that rely on key exchanges without forward secrecy. By mandating perfect forward secrecy, DTLS / SCTP effectively mitigates many forms of passive pervasive monitoring and limits the amount of data that can be leaked due to key compromise.
[0178] An important mitigation for pervasive monitoring is to force implementations to perform dynamic key derivation instead of static key derivation. Dynamic key derivation increases the risk of detection for an attacker [IETF RFC 7624]. DTLS / SCTP in this specification encourages implementations to frequently set up new DTLS connections over the same SCTP association to force an attacker to perform dynamic key derivation.
[0179] In addition to the privacy attacks mentioned above, large-scale surveillance may allow tracking of users over larger geographic areas and across different access networks. Using information from DTLS / SCTP, together with information collected from other protocols, increases the risk of identifying individual users.
[0180] 9. Implementation of the embodiments of the present invention 4 illustrates a network node implementing parallel DTLS connections over SCTP associations according to some embodiments. Network node 402 may be implemented using a custom application-specific integrated circuit (ASIC), as a processor and dedicated operating system (OS), or as a common off-the-shelf (COTS) processor and standard OS.
[0181] Network node 402 includes hardware 440 comprising one or more processors 442 (typically COTS processors or processor cores or ASICs) and a set of physical NIs 446, and a non-transitory machine-readable storage medium 449 having software 450 stored therein. In operation, one or more processors 442 may execute software 450 to instantiate one or more sets of one or more applications 464A-R. One embodiment does not implement virtualization, but alternative embodiments may use different forms of virtualization. For example, in one such alternative embodiment, virtualization layer 454 represents a kernel of an operating system (or a shim running on a base operating system) that enables the creation of multiple instances 462A-R, referred to as software containers, each of which may be used to run one (or more) of the set of applications 464A-R. The multiple software containers (also referred to as virtualization engines, virtual private servers, or jails) are user spaces (typically virtual memory spaces) separate from the kernel space in which the operating system runs. A set of applications running in a given user space cannot access the memory of other processes unless explicitly allowed. In another such alternative embodiment, virtualization layer 454 represents a hypervisor (sometimes referred to as a virtual machine monitor (VMM)) or a hypervisor running on top of a host operating system, and each of the set of applications 464A-R runs on top of guest operating systems within instances referred to as virtual machines 462A-R running on top of the hypervisor (which may be considered in some cases as strictly isolated forms of software containers) - the guest operating systems and applications may be unaware that they are running on a virtual machine as opposed to running on a "bare metal" host electronic device, or, through paravirtualization, the operating system and / or applications may be aware of the presence of virtualization for optimization purposes.In yet other alternative embodiments, one, some, or all of the applications are implemented as a unikernel(s), where the unikernel may be generated by directly compiling the application with only a limited set of libraries (e.g., from a library operating system (LibOS) that includes drivers / libraries for the OS services) that provide the particular OS services required by the application. Since a unikernel may be implemented to run directly on the hardware 440, directly on the hypervisor (in which case the unikernel is sometimes described as running within a LibOS virtual machine), or within a software container, an embodiment may be implemented entirely as a unikernel running directly on the hypervisor represented by virtualization layer 454, a unikernel running within a software container represented by instances 462A-R, or a combination of a unikernel and the above techniques (e.g., a unikernel and a set of applications running within different software containers, where both the unikernel and the virtual machine run directly on the hypervisor).
[0182] The software 450 includes a parallel DTLS connection coordinator 112 that performs the operations described herein above. The parallel DTLS connection coordinator 112 may be instantiated within applications 464A-R. An instantiation, and if implemented, a virtualization of one or more sets of one or more applications 464A-R is collectively referred to as software instance(s) 452. Each set of applications 464A-R, its corresponding virtualization construct if implemented (e.g., instances 462A-R), and that portion of the hardware 440 on which they execute (be it hardware dedicated to that execution and / or time slice of time-shared hardware) form a separate virtual electronic device 460A-R.
[0183] A network interface (NI) can be physical or virtual. In the context of IP, an interface address is an IP address assigned to an NI, which can be a physical NI or a virtual NI. A virtual NI can be associated with a physical NI, associated with another virtual interface, or on its own (e.g., a loopback interface, a point-to-point protocol interface). NIs (physical or virtual) can be numbered (NIs with IP addresses) or unnumbered (NIs without IP addresses).
[0184] term In general, all terms used herein should be interpreted according to their ordinary meaning in the relevant technical field unless a different meaning is expressly given and / or implied from the context in which it is used. Any reference to an element, apparatus, component, means, step, etc. should be openly interpreted as referring to at least one instance of the element, apparatus, component, means, step, etc., unless otherwise specified. The steps of any method disclosed herein need not be performed in the exact order disclosed, unless a step is explicitly described as after or before another step and / or it is implicit that a step must be after or before another step. Any feature of any of the embodiments disclosed herein may be applied to any other embodiment, where appropriate. Similarly, any advantage of any embodiment may be applied to any other embodiment, and vice versa. Other objects, features, and advantages of the included embodiments will become apparent from the following description.
[0185] References herein to "one embodiment," "embodiment," "exemplary embodiment," and the like indicate that the described embodiment may include a particular feature, structure, or characteristic, but not all embodiments may necessarily include that particular feature, structure, or characteristic. Moreover, such phrases do not necessarily refer to the same embodiment. Moreover, when a particular feature, structure, or characteristic is described in connection with an embodiment, it is within the knowledge of one of ordinary skill in the art to affect such feature, structure, or characteristic in connection with other embodiments, whether or not explicitly described.
[0186] The present specification and claims may use the terms "coupled" and "connected," along with their derivatives. These terms are not intended as synonyms for each other. "Coupled" is used to indicate that two or more elements cooperate or interact with each other, which may or may not be in direct physical or electrical contact with each other. "Connected" is used to indicate the establishment of wireless or wired communication between two or more elements that are coupled with each other. As used herein, a "set" refers to any positive integer number of items, including one item.
[0187] An electronic device stores and transmits (internally and / or with other electronic devices over a network) code (consisting of software instructions and which may be referred to as computer program code or computer programs) and / or data using machine-readable media (also referred to as computer-readable media), such as machine-readable storage media (e.g., magnetic disks, optical disks, solid-state drives, read-only memories (ROMs), flash memory devices, phase-change memories), and machine-readable transmission media (also referred to as carriers) (e.g., electrical, optical, radio, acoustic, or other forms of propagated signals, such as carrier waves, infrared signals, etc.). Thus, an electronic device (e.g., a computer) includes hardware and software, such as a set of one or more processors (e.g., one of which may be a microprocessor, controller, microcontroller, central processing unit, digital signal processor, application specific integrated circuit (ASIC), field programmable gate array (FPGA), other electronic circuitry, or a combination of one or more of the preceding), coupled to one or more machine-readable storage media for storing code for execution on the set of processors and / or for storing data. For example, an electronic device includes a non-volatile memory that contains the code because the non-volatile memory can persist the code / data even when the electronic device is turned off (when power is removed). When the electronic device is turned on, the portion of the code that is executed by the processor(s) of the electronic device is typically copied from the slower non-volatile memory to the volatile memory of the electronic device (e.g., dynamic random access memory (DRAM), static random access memory (SRAM)). A typical electronic device also includes a set of one or more physical network interfaces (NIs) for establishing network connections (for transmitting and / or receiving code and / or data using propagated signals) with other electronic devices.For example, a set of physical NIs (or a set of physical NIs in combination with a set of processors executing code) may perform any formatting, coding, or conversion to enable an electronic device to transmit and receive data over wired and / or wireless connections. In some embodiments, a physical NI may include radio circuitry capable of (1) receiving data from other electronic devices over a wireless connection and / or (2) transmitting data to other devices through a wireless connection. The radio circuitry may include transmitter(s), receiver(s), and / or transceiver(s) suitable for radio frequency communication. The radio circuitry may convert digital data into radio signals having appropriate parameters (e.g., frequency, timing, channel, bandwidth, etc.). The radio signals may then be transmitted through an antenna to appropriate recipient(s). In some embodiments, a set of physical NIs may include network interface controller(s) (NIC), also known as a network interface controller card, network adapter, or local area network (LAN) adapter. The NIC(s) can facilitate connecting electronic devices to other electronic devices, allowing electronic devices to communicate wired through the plugging of cables into physical ports connected to the NIC. One or more portions of the embodiments of the present invention may be implemented using different combinations of software, firmware, and / or hardware.
[0188] A network node (also referred to as a network device or simply a node) is an electronic device that communicatively interconnects other electronic devices (e.g., other network devices, end-user devices) on a network. Some network nodes are "multiple services network nodes" that provide support for multiple networking functions (e.g., routing, bridging, switching, Layer 2 aggregation, session border control, quality of service, and / or subscriber management) and / or provide support for multiple application services (e.g., data, voice, and video).
[0189] As used herein, the terms "module," "logic," and "unit" may refer to circuitry for performing a specified function. In some embodiments, the specified function may be performed by circuitry in combination with software, such as by software executed by a general-purpose processor.
[0190] Any suitable step, method, feature, function, or effect disclosed herein may be performed through one or more functional units or modules of one or more virtual devices. Each virtual device may include several of these functional units. These functional units may be implemented using processing circuitry, which may include one or more microprocessors or microcontrollers, and other digital hardware, which may include digital signal processors (DSPs), dedicated digital logic, and the like. The processing circuitry may be configured to execute program code stored in memory, which may include one or more types of memory, such as read-only memory (ROM), random access memory (RAM), cache memory, flash memory devices, optical storage devices, and the like. The program code stored in memory includes program instructions for implementing one or more telecommunications and / or data communication protocols and instructions for implementing one or more of the techniques described herein. In some implementations, the processing circuitry may be used to cause individual functional units to perform corresponding functions in accordance with one or more embodiments of the present disclosure.
[0191] The term unit may have its conventional meaning in the field of electronic equipment, electrical devices, and / or electronic devices, and may include, for example, electrical and / or electronic circuits, devices, modules, processors, memories, logic solid state and / or discrete devices, computer programs or instructions for performing respective tasks, procedures, calculations, output and / or display functions, etc., as described herein.
Claims
1. 1. A method in a first network node for encoding a user message for secure transmission to a second network node, comprising: Initiating (204) a Datagram Transport Layer Security (DTLS) connection on a Stream Control Transmission Protocol (SCTP) association through a DTLS handshake using an existing Authenticated Chunk for SCTP (SCTP-AUTH) key from an existing DTLS connection on the SCTP association to send a user message; Deriving (206) a new SCTP-AUTH key from the initiated DTLS connection; Sending further user messages over the initiated DTLS connection using the new SCTP-AUTH key (210); and in response to determining that the SCTP packets encrypted over the existing DTLS connection and authenticated by the existing SCTP-AUTH key have been delivered, closing (212) the existing DTLS connection on the SCTP association; A method comprising:
2. 2. The method of claim 1 , The method further includes sending (208) an ongoing SCTP packet including a further portion of a user message protected by the initiated DLTS connection but authenticated with the existing SCTP-AUTH key.
3. 3. The method according to claim 1 or 2, The method, wherein closing the existing DTLS connection on the SCTP association includes sending a first DTLS connection close notification to the second network node.
4. 4. The method according to any one of claims 1 to 3, The method, wherein closing the existing DTLS connection on the SCTP association further includes receiving a second DTLS connection close notification from the second network node.
5. 5. The method according to any one of claims 1 to 4, The method, wherein sending the first DTLS connection close notification includes verifying that transmitted data in the existing DTLS connection has been acknowledged by the second network node in a non-reproducible manner before sending the first DTLS connection close notification.
6. 6. The method according to any one of claims 1 to 5, The method, wherein the existing SCTP-AUTH key and the new SCTP-AUTH key are identified by corresponding existing and new key identifiers (IDs), and the new key identifier is a value incremented by one from the existing key identifier.
7. 7. The method according to any one of claims 1 to 6, comprising: The method of claim 1, wherein the DTLS connection is established before one or more certificates of the existing DTLS connection on the SCTP association expire.
8. 8. The method according to any one of claims 1 to 7, comprising: The method of claim 1, wherein initiating the DTLS connection on the SCTP association via the DTLS handshake includes maintaining the one or more certificates of the existing DTLS connection, including a timestamp in the one or more certificates.
9. 9. The method according to any one of claims 1 to 8, comprising: Performing the handshake between the first network node and the second network node comprises: initiating the handshake and, in response to receiving an initiation of the handshake, continuing the initiated handshake if the first network node acts as a DTLS client for the DTLS connection.
10. 10. The method according to any one of claims 1 to 9, comprising: The existing SCTP-AUTH key is deleted in response to closing the existing DTLS connection.
11. A network node (402), a processor (442) and a non-transitory machine-readable storage medium (449) providing instructions that, when executed by the processor (442), cause the processor (442) to: Initiating (204) a Datagram Transport Layer Security (DTLS) connection on a Stream Control Transmission Protocol (SCTP) association through a DTLS handshake using an existing Authenticated Chunk for SCTP (SCTP-AUTH) key from an existing DTLS connection on the SCTP association to send a user message; Deriving (206) a new SCTP-AUTH key from the initiated DTLS connection; Sending further user messages over the initiated DTLS connection using the new SCTP-AUTH key (210); and in response to determining that the SCTP packets encrypted over the existing DTLS connection and authenticated by the existing SCTP-AUTH key have been delivered, closing (212) the existing DTLS connection on the SCTP association; A network node that can execute the following:
12. A network node (402) according to claim 11, comprising: The non-transitory machine-readable storage medium, when executed by the processor, causes the processor to: Sending (208) an ongoing SCTP packet including a further portion of a user message protected by the initiated DLTS connection but authenticated with the existing SCTP-AUTH key; The network node further comprises:
13. A network node (402) according to claim 11 or 12, comprising: The network node, wherein closing the existing DTLS connection on the SCTP association includes sending a first DTLS connection close notification to the second network node.
14. A network node (402) according to any one of claims 11 to 13, comprising: The network node, wherein closing the existing DTLS connection on the SCTP association further includes receiving a second DTLS connection close notification from the second network node.
15. A network node (402) according to any one of claims 11 to 14, comprising: A network node, wherein sending the first DTLS connection close notification includes verifying that transmitted data in the existing DTLS connection has been acknowledged by the second network node in a non-reproducible manner before sending the first DTLS connection close notification.
16. A network node (402) according to any one of claims 11 to 15, comprising: The existing SCTP-AUTH key and the new SCTP-AUTH key are identified by corresponding existing and new key identifiers (IDs), the new key identifier being a value incremented by one from the existing key identifier.
17. A network node (402) according to any one of claims 11 to 16, comprising: The DTLS connection is established before one or more certificates of the existing DTLS connection on the SCTP association expire.
18. A network node (402) according to any one of claims 11 to 17, comprising: The network node, wherein initiating the DTLS connection on the SCTP association through the DTLS handshake includes maintaining the one or more certificates of the existing DTLS connection, including a timestamp in the one or more certificates.
19. A network node (402) according to any one of claims 11 to 18, comprising: Performing the handshake between the first network node and the second network node comprises: a network node for initiating the handshake and, in response to receiving an initiation of the handshake, continuing the initiated handshake if the first network node acts as a DTLS client for the DTLS connection.
20. A network node (402) according to any one of claims 11 to 19, comprising: The network node, wherein the existing SCTP-AUTH key is deleted in response to closing the existing DTLS connection.
21. A non-transitory machine-readable storage medium (449) providing instructions that, when executed by a processor (442), cause the processor (442) to perform any of methods 1-10.
22. A computer program comprising instructions which, when executed by a network node (402), cause said device to perform any of the methods 1 to 10.
Citation Information
Patent Citations
Security system
JP2007043297A
Encryption key update system and encryption key update method
JP2009284086A
Master electronic controller, slave electronic controller, electronic control system, communication control method, and communication control program
JP2019161605A
