Internet-Draft EAP-AKA' Large Identity November 2026
Wan Expires 20 May 2027 [Page]
Workgroup:
EMU
Internet-Draft:
draft-wan-emu-aka-prime-identity-fragmentation-01
Updates:
9048 (if approved)
Published:
Intended Status:
Standards Track
Expires:
Author:
T. Wan
CableLabs

EAP-AKA' Large Identity

Abstract

This document updates EAP-AKA’ (RFC 9048) so that a peer can send an identity that is too large for the initial EAP-Response/Identity packet, such as a Subscription Concealed Identifier (SUCI) in Network Access Identifier (NAI) format protected by a Post-Quantum Cryptography (PQC) scheme. The peer sends a realm-only identity in EAP-Response/Identity and the large identity in EAP-Response/AKA-Identity. If the identity fits in an AT_IDENTITY attribute, the peer sends it there. Otherwise, the peer sends it in a new attribute, AT_LARGE_IDENTITY, which is fragmented using the AT_FRAGMENT attribute defined in I-D.ietf-emu-pqc-eapaka. A peer that supports several SUCI protection schemes (for example PQC and classical schemes) uses the presence or absence of the AT_LARGE_IDENTITY_SUPPORTED attribute in the server’s request to select a scheme whose SUCI can be carried in an identity attribute that the server can process. These procedures support large SUCI values, and do not change the EAP-AKA’ authentication or key derivation.

Status of This Memo

This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.

Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.

Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."

This Internet-Draft will expire on 20 May 2027.

▲

Table of Contents

1. Introduction

EAP-AKA’ [RFC9048] is an Extensible Authentication Protocol (EAP) [RFC3748] method based on the 3GPP Authentication and Key Agreement (AKA) protocol. It supports 5G identifiers, including the Subscription Concealed Identifier (SUCI). A peer can send its identity in the initial EAP-Response/Identity packet or in the AT_IDENTITY attribute of an EAP-Response/AKA-Identity packet. In 5G, the identity is normally sent outside EAP. This document applies when the identity is carried in EAP, as described in Section 5.3 of [RFC9048].

The identity in the initial EAP-Response/Identity packet is usually copied into the RADIUS User-Name attribute [RFC2865], which is at most 253 octets long, so RADIUS cannot carry a longer NAI [RFC7542]. [RFC7542] requires devices to support NAIs of at least 72 octets and recommends support for 253 octets. EAP [RFC3748] itself limits this identity only by the EAP packet length. A peer therefore limits the NAI in EAP-Response/Identity to 253 octets by default. This document calls this limit the initial NAI limit.

A SUCI in NAI format can be longer than the initial NAI limit. [TS23003] writes the binary fields of the scheme output in hexadecimal digits, so a field of n octets takes 2n octets in the NAI. There are two cases:

The sizes above assume the hexadecimal encoding of [TS23003]. The procedures in this document depend only on the length of the NAI in octets, not on the encoding.

An AT_IDENTITY attribute cannot carry such an identity. The Length field of AT_IDENTITY is one octet and counts units of four octets, so an AT_IDENTITY attribute is at most 255 x 4 = 1020 octets long, and the identity in it is at most 1016 octets long [RFC4187]. The two-octet Actual Identity Length field cannot raise this limit, because it counts octets inside the attribute. Changing the format of AT_IDENTITY would violate [RFC4187]. This document therefore defines a new attribute, AT_LARGE_IDENTITY, which has a two-octet Length field and can carry a large identity of more than 1008 octets, which does not fit in an AT_IDENTITY attribute in a 1020-octet EAP packet. EAP does not define generic fragmentation [RFC3748], so this document fragments AT_LARGE_IDENTITY using the AT_FRAGMENT attribute of [I-D.ietf-emu-pqc-eapaka].

This document updates RFC 9048 as follows:

The mechanism updates only the selection and transmission of a large identity in RFC 9048. It does not change any other aspect of RFC 9048.

2. Requirements Language

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 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.

3. Terminology

This document uses the terminology of [RFC3748], [RFC4187], [RFC7542], and [RFC9048]. “Server” means the EAP server.

Initial NAI limit:
The longest NAI, in octets, that a peer sends in EAP-Response/Identity. The default is 253 octets. A peer MAY use a smaller value, but not less than 72 octets, if devices on the path support only the minimum NAI length required by [RFC7542]. This is a local parameter, not a protocol field.
Large identity:
An identity, for example a PQC protected SUCI in NAI format, that is longer than the initial NAI limit.
Single-packet large identity:
A large identity that fits in one AT_IDENTITY attribute within a 1020-octet EAP-Response/AKA-Identity packet. It is sent in AT_IDENTITY.
Multi-packet large identity:
A large identity that does not fit in one AT_IDENTITY attribute within a 1020-octet EAP-Response/AKA-Identity packet. It is sent in an AT_LARGE_IDENTITY attribute, which is fragmented.
Realm-only identity:
An identity in EAP-Response/Identity of the form “@realm”. The username is omitted, so the identity does not contain the peer’s permanent or concealed subscriber identifier, and AAA entities can route the exchange using the realm.

4. Large Identity

4.1. Overview

A peer MUST NOT send an identity longer than the initial NAI limit in EAP-Response/Identity. EAP does not define fragmentation, so a large identity cannot be split across EAP-Response/Identity packets. A peer with a large identity therefore sends a realm-only identity in EAP-Response/Identity, and sends the large identity in EAP-Response/AKA-Identity: in the AT_IDENTITY attribute if it fits, and otherwise in the AT_LARGE_IDENTITY attribute, which is fragmented.

4.2. Message Flow

Figure 1 shows the message flow. Case A and case B in the figure are alternatives. Attributes in square brackets are present only if the server sent AT_LARGE_IDENTITY_SUPPORTED.

Peer Server 1. EAP-Request/Identity 2. EAP-Response/Identity realm-only identity 3. EAP-Request/AKA-Identity AT_ANY_ID_REQ [AT_LARGE_IDENTITY_SUPPORTED] Case A: the identity fits in AT_IDENTITY 4. EAP-Response/AKA-Identity AT_IDENTITY (full identity) Case B: the identity does not fit in AT_IDENTITY 4. EAP-Response/AKA-Identity AT_FRAGMENT (first fragment of AT_LARGE_IDENTITY) 5. EAP-Request/AKA-Identity (acknowledgement, no attributes) 6. EAP-Response/AKA-Identity AT_FRAGMENT (next fragment of AT_LARGE_IDENTITY) 7. EAP-Request/AKA-Identity (acknowledgement, no attributes) 8. EAP-Response/AKA-Identity AT_FRAGMENT (final fragment of AT_LARGE_IDENTITY) 9. EAP-Request/AKA-Challenge AT_RAND, AT_AUTN, AT_KDF, ... [AT_CHECKCODE], AT_MAC 10. EAP-Response AKA-Challenge AT_RES, [AT_CHECKCODE], AT_MAC 11. EAP-Success
Figure 1: Large Identity during EAP-AKA' Identity Exchange
  1. The server sends EAP-Request/Identity.

  2. The peer sends EAP-Response/Identity with a realm-only identity. This identity only routes the EAP exchange to the server, and it does not identify the peer. An AAA proxy that routes on the realm treats the username part as opaque and forwards it unchanged. A peer SHOULD send a realm-only identity, because Section 2.4 of [RFC7542] recommends omitting the username in this case: a fixed username such as “anonymous” cannot be distinguished from the name of a real user. A peer MAY instead send a NAI with a fixed username, such as “anonymous@realm”, if its deployment or access technology requires it, for example the anonymous SUCI in [TS23003]. A server MUST accept both forms, and MUST NOT use the username part to identify the peer.

  3. The server sends EAP-Request/AKA-Identity with AT_ANY_ID_REQ (or another identity request attribute permitted by [RFC9048]). A server that can process AT_LARGE_IDENTITY also includes AT_LARGE_IDENTITY_SUPPORTED, which carries Max-Identity-Length (see Section 4.4).

    The peer then selects the identity to send. A peer can support several SUCI protection schemes, for example PQC schemes and classical ECIES schemes, which produce identities of different lengths. Local policy decides which scheme the peer prefers. An example is a priority list of protection schemes, as in [TS33501].

    The peer uses the presence or absence of AT_LARGE_IDENTITY_SUPPORTED to select a scheme whose SUCI can be carried in an identity attribute that the server can process. Every server can process AT_IDENTITY. The presence of AT_LARGE_IDENTITY_SUPPORTED tells the peer that the server can also process AT_LARGE_IDENTITY, fragmented using AT_FRAGMENT, and so that the peer can send a multi-packet large identity. The peer first determines which identities it can send to this server:

    • If the server did not send AT_LARGE_IDENTITY_SUPPORTED, the peer treats the server as unable to process AT_LARGE_IDENTITY. The peer MUST NOT select a multi-packet large identity. It can select only an identity that fits in AT_IDENTITY.

    • If the server sent AT_LARGE_IDENTITY_SUPPORTED, the peer can select any identity that is not longer than Max-Identity-Length, including a multi-packet large identity. The peer MUST NOT select an identity longer than Max-Identity-Length.

    Among the identities that it can send to this server, the peer selects the one that local policy prefers. If the policy is a priority list, the peer selects the highest-priority scheme that can be used. For example, if the list has PQC schemes before ECIES schemes and the server did not send AT_LARGE_IDENTITY_SUPPORTED, the peer skips the PQC schemes and selects the highest-priority ECIES scheme. If the server sent AT_LARGE_IDENTITY_SUPPORTED, the peer selects the highest-priority scheme whose identity is not longer than Max-Identity-Length, which here is a PQC scheme if the server’s maximum is large enough for it.

    The peer decides whether an identity fits in AT_IDENTITY by the length of the EAP-Response/AKA-Identity packet that would carry it. The packet consists of the 8-octet EAP-AKA’ header and the AT_IDENTITY attribute, which is a 4-octet attribute header, the identity, and padding to a multiple of four octets. The identity fits if the packet is at most 1020 octets, the minimum EAP MTU, which means that the identity is at most 1008 octets long. A longer identity is sent in AT_LARGE_IDENTITY.

    If the server rejects the exchange, for example because of its local limits, the peer MAY start a new exchange with another scheme, if local policy allows.

    The selection is always subject to local policy. The peer MUST NOT select a scheme in a way that violates local policy, for example a policy that requires a PQC scheme or a minimum security level. The peer MUST NOT fall back to an unconcealed identity unless local policy explicitly allows it. If no scheme can be used, the peer fails the authentication.

  4. The peer sends EAP-Response/AKA-Identity with the selected identity.

    • Case A, a single-packet large identity: the peer sends the full identity in one AT_IDENTITY attribute in one EAP-Response/AKA-Identity packet, as specified in [RFC9048]. The peer MUST NOT use AT_LARGE_IDENTITY or AT_FRAGMENT, whether or not the server sent AT_LARGE_IDENTITY_SUPPORTED. The limit on the RADIUS User-Name attribute does not apply to this identity, because it is carried in EAP-Message attributes [RFC3579]. The exchange skips steps 5 to 8, and continues at step 9.

    • Case B, a multi-packet large identity: the peer includes the full identity in an AT_LARGE_IDENTITY attribute (see Section 4.3) and fragments that attribute. This packet carries an AT_FRAGMENT attribute with the first fragment of AT_LARGE_IDENTITY. The peer follows the AT_FRAGMENT procedures specified in [I-D.ietf-emu-pqc-eapaka]. If the AT_LARGE_IDENTITY attribute fits in one EAP packet, the peer sends it unfragmented, as specified in that document.

  5. The server sends EAP-Request/AKA-Identity with no attributes, to acknowledge the fragment. This packet does not contain an identity-requesting attribute.

  6. The peer sends the next fragment of AT_LARGE_IDENTITY in EAP-Response/AKA-Identity.

  7. The server sends an acknowledgement, as in step 5.

  8. The peer sends the final fragment of AT_LARGE_IDENTITY in EAP-Response/AKA-Identity. The server then reassembles the AT_LARGE_IDENTITY attribute as specified in [I-D.ietf-emu-pqc-eapaka], and processes the identity in it as if it had been received in AT_IDENTITY, as specified in [RFC9048].

    The figure shows three fragments as an example. If AT_LARGE_IDENTITY needs more than three fragments, steps 6 and 7 repeat for each additional fragment before the final one. If it needs only two fragments, steps 6 and 7 are omitted.

    The fragments are parts of one AT_LARGE_IDENTITY attribute, so steps 3 to 8 are one EAP/AKA-Identity round. The EAP-Request/AKA-Identity packets in steps 5 and 7 only acknowledge fragments, as specified in [I-D.ietf-emu-pqc-eapaka]. They contain no attributes and do not request an identity, so they are not counted for the limit of three EAP-Request/AKA-Identity messages in Section 4.1.5 of [RFC4187], and the requirement of Section 9.1 of [RFC4187] for an identity-requesting attribute does not apply to them.

    The server processes the reassembled identity before any AT_MAC can be verified, because the keys for AT_MAC are derived from the authentication vector that the server obtains using the identity. Section 7.4 of [I-D.ietf-emu-pqc-eapaka] requires that data in a reassembled attribute be processed only after AT_MAC verification. It also requires every fragment, including the final one, to be acknowledged by a separate message. This document specifies AT_LARGE_IDENTITY as an exception to both rules. The EAP-Request/AKA-Challenge in step 9 acknowledges the final fragment, which avoids an extra round trip.

    The identity exchange happens before the peer is authenticated, so the server MUST be able to process an identity up to the Max-Identity-Length that it sent, and MUST enforce local limits on the length of the reassembled identity, the number of concurrent reassemblies, and the lifetime of an incomplete reassembly. The server MUST fail the EAP-AKA’ exchange if a limit is exceeded.

    [TS33501] limits the scheme output of a proprietary protection scheme to 3000 octets plus the size of the input. In the hexadecimal encoding of the NAI, this is up to 6000 octets plus twice the size of the input. A server that supports such schemes SHOULD send a Max-Identity-Length that is large enough for such an identity, including the other fields of the NAI-format SUCI.

  9. The server sends EAP-Request/AKA-Challenge. If the server sent AT_LARGE_IDENTITY_SUPPORTED in step 3, it MUST include AT_CHECKCODE, as specified in Section 3.4.3 of [RFC9048]. In case B, this also acknowledges the final fragment.

  10. The peer sends EAP-Response/AKA-Challenge. If the peer sent AT_LARGE_IDENTITY, the peer MUST include AT_CHECKCODE.

  11. The server sends EAP-Success.

4.3. AT_LARGE_IDENTITY

AT_LARGE_IDENTITY carries a multi-packet large identity. It has the same meaning as AT_IDENTITY, except that it carries an identity of more than 1008 octets, which does not fit in an AT_IDENTITY attribute in a 1020-octet EAP packet. The peer and the server use the identity in AT_LARGE_IDENTITY wherever [RFC9048] uses the identity in AT_IDENTITY: in the EAP-AKA’ key derivation (Section 5.3.1 of [RFC9048]) and as the exported Peer-Id (Section 6 of [RFC9048]), for which only the Actual Identity Length octets of the identity are used. This document does not change the key derivation.

The attribute has this format:

0 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 Type Reserved Length Actual Identity Length Identity (variable) and padding
Figure 2: AT_LARGE_IDENTITY
Type:
TBD1. The value is in the non-skippable range (0 to 127) of the attribute types [RFC4187].
Reserved:
One octet. The sender MUST set it to zero. The receiver MUST ignore it.
Length:
Two octets. The length of the attribute in units of four octets, including the Type, Reserved, Length, Actual Identity Length, Identity, and padding fields. The length of the attribute in octets is this value multiplied by 4. This differs from AT_IDENTITY, whose Length field is one octet and limits the attribute to 255 x 4 = 1020 octets. The attribute is at most 65535 octets long, because the Total Attribute Length field of AT_FRAGMENT in [I-D.ietf-emu-pqc-eapaka] has two octets.
Actual Identity Length:
Two octets. The length of the identity in octets, without padding.
Identity:
The identity, in the same format as the identity in AT_IDENTITY [RFC4187], followed by zero to three octets of padding, set to zero, so that the length of the attribute is a multiple of four octets.

A peer MUST NOT send AT_LARGE_IDENTITY unless the server sent AT_LARGE_IDENTITY_SUPPORTED in the same EAP-AKA’ exchange, because a server that does not implement this document does not recognize the attribute, which is non-skippable. A peer MUST NOT send AT_LARGE_IDENTITY and AT_IDENTITY in the same packet.

4.4. AT_LARGE_IDENTITY_SUPPORTED

The server sends AT_LARGE_IDENTITY_SUPPORTED in an EAP-Request/AKA-Identity packet to tell the peer that it can process AT_LARGE_IDENTITY, fragmented using AT_FRAGMENT, during the identity exchange. The peer uses the presence or absence of the attribute to select a protection scheme whose SUCI can be carried in an identity attribute that the server can process.

The attribute has this format:

0 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 Type Length Max-Identity-Length
Figure 3: AT_LARGE_IDENTITY_SUPPORTED
Type:
TBD2. The value is in the skippable range (128 to 255) of the attribute types [RFC4187], so that a peer that does not implement this document ignores the attribute.
Length:
  1. The length of the attribute in units of four octets. The attribute is 4 octets long.

Max-Identity-Length:
Two octets. The maximum length, in octets, of an identity that the server can process in AT_LARGE_IDENTITY. It is in the same unit as the Actual Identity Length field of AT_LARGE_IDENTITY. A server MUST be able to process an identity up to this length. A server MUST NOT send a value larger than 65526, because the Total Attribute Length field of AT_FRAGMENT in [I-D.ietf-emu-pqc-eapaka] limits an AT_LARGE_IDENTITY attribute to 65535 octets, and the attribute has a header of 6 octets and is padded to a multiple of four octets.

The peer MUST NOT select an identity longer than Max-Identity-Length.

4.5. Error Handling

If a peer or a server detects an error in the identity exchange defined in this document, it MUST fail the EAP-AKA’ exchange as specified in [RFC9048].

A server SHOULD treat the following as errors:

  • AT_LARGE_IDENTITY or AT_FRAGMENT received without AT_LARGE_IDENTITY_SUPPORTED having been sent;

  • a malformed AT_LARGE_IDENTITY or AT_FRAGMENT attribute, including an Actual Identity Length that is inconsistent with the Length;

  • an identity in AT_LARGE_IDENTITY that is longer than Max-Identity-Length or another server limit;

  • an identity that has invalid syntax after reassembly;

  • a reassembly timeout;

  • a missing or invalid AT_CHECKCODE, if AT_LARGE_IDENTITY_SUPPORTED was sent.

The server MAY send EAP-Failure after it detects such an error.

4.6. Backward Compatibility

This document is backward compatible with existing EAP-AKA’ peers and servers.

  • A single-packet large identity is sent using only the messages and attributes already defined in [RFC9048].

  • A peer that does not implement this document ignores AT_LARGE_IDENTITY_SUPPORTED, because the attribute is skippable.

  • A peer that implements this document sends AT_LARGE_IDENTITY and AT_FRAGMENT only if the server sent AT_LARGE_IDENTITY_SUPPORTED.

  • A server that does not implement this document treats it as an error when receiving AT_FRAGMENT or AT_LARGE_IDENTITY.

5. Security Considerations

AT_LARGE_IDENTITY_SUPPORTED, AT_LARGE_IDENTITY, AT_FRAGMENT, and the EAP Request/Response messages that carry them are not protected by AT_MAC, because the keys do not exist yet. AT_CHECKCODE (see steps 9 and 10 in Section 4.2) lets the peer and the server detect, in the challenge round, that someone may have tampered with the other attributes. For example, an attacker could remove AT_LARGE_IDENTITY_SUPPORTED to downgrade a peer with several allowed protection schemes toward a scheme that needs no fragments, such as a classical ECIES scheme instead of a PQC scheme. AT_CHECKCODE detects such a change but does not prevent it. A peer whose local policy requires a PQC scheme does not fall back to a classical scheme.

The SUCI, carried in AT_LARGE_IDENTITY attribute, is integrity protected by its protection scheme. A modified SUCI therefore fails deconcealment at the home network, and the authentication fails. If the protection scheme does not provide integrity protection, a modified identity still leads to different keys, because the key derivation depends on the identity (see Section 5.3.1 of [RFC9048]), and the AT_MAC verification in the challenge round fails.

Fragments can increase the risk of denial of service, because the server holds state before the peer is authenticated. Servers MUST enforce the limits described in step 8 in Section 4.2.

The choice of protection scheme is a local decision of the peer. The peer needs to make sure that a fallback to a scheme that needs no fragments does not weaken its security or privacy beyond what its local policy allows.

6. Privacy Considerations

This document lets a peer keep using concealed identities when they become large. Without it, a peer that cannot send a large SUCI, because the SUCI exceeds the initial NAI limit or fragmentation is not available, might have to fail the authentication or use a less private identity.

The length of a concealed identity can reveal the approximate length of the identity. This document does not hide the length of the concealed identity. A peer MAY pad the identity before fragmenting it if local policy requires hiding the length. Padding is outside the scope of this document.

7. IANA Considerations

IANA is requested to allocate two Attribute Type values in the “EAP-AKA and EAP-SIM Parameters” registry. AT_LARGE_IDENTITY is allocated from the non-skippable range (0-127), as specified in Section 8.1 of [RFC4187]. AT_LARGE_IDENTITY_SUPPORTED is allocated from the skippable range (128-255), so that a peer that does not implement this document ignores it.

Table 1
Value Attribute Name Range Reference
TBD1 AT_LARGE_IDENTITY non-skippable RFC-TBD
TBD2 AT_LARGE_IDENTITY_SUPPORTED skippable RFC-TBD

8. References

8.1. Normative References

[I-D.ietf-emu-pqc-eapaka]
Reddy.K, T. and A. Banerjee, "Post-Quantum Key Encapsulation Mechanisms (PQ KEMs) in EAP-AKA prime", Work in Progress, Internet-Draft, draft-ietf-emu-pqc-eapaka-05, , <https://datatracker.ietf.org/doc/html/draft-ietf-emu-pqc-eapaka-05>.
[RFC2119]
Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, , <https://www.rfc-editor.org/info/rfc2119>.
[RFC3748]
Aboba, B., Blunk, L., Vollbrecht, J., Carlson, J., and H. Levkowetz, Ed., "Extensible Authentication Protocol (EAP)", RFC 3748, DOI 10.17487/RFC3748, , <https://www.rfc-editor.org/info/rfc3748>.
[RFC4187]
Arkko, J. and H. Haverinen, "Extensible Authentication Protocol Method for 3rd Generation Authentication and Key Agreement (EAP-AKA)", RFC 4187, DOI 10.17487/RFC4187, , <https://www.rfc-editor.org/info/rfc4187>.
[RFC7542]
DeKok, A., "The Network Access Identifier", RFC 7542, DOI 10.17487/RFC7542, , <https://www.rfc-editor.org/info/rfc7542>.
[RFC8174]
Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, , <https://www.rfc-editor.org/info/rfc8174>.
[RFC9048]
Arkko, J., Lehtovirta, V., Torvinen, V., and P. Eronen, "Improved Extensible Authentication Protocol Method for 3GPP Mobile Network Authentication and Key Agreement (EAP-AKA')", RFC 9048, DOI 10.17487/RFC9048, , <https://www.rfc-editor.org/info/rfc9048>.

8.2. Informative References

[FIPS203]
NIST, "Module-Lattice-Based Key-Encapsulation Mechanism Standard", , <https://csrc.nist.gov/pubs/fips/203/final>.
[RFC2865]
Rigney, C., Willens, S., Rubens, A., and W. Simpson, "Remote Authentication Dial In User Service (RADIUS)", RFC 2865, DOI 10.17487/RFC2865, , <https://www.rfc-editor.org/info/rfc2865>.
[RFC3579]
Aboba, B. and P. Calhoun, "RADIUS (Remote Authentication Dial In User Service) Support For Extensible Authentication Protocol (EAP)", RFC 3579, DOI 10.17487/RFC3579, , <https://www.rfc-editor.org/info/rfc3579>.
[TS23003]
3GPP, "3GPP TS 23.003: Numbering, addressing and identification", <https://www.3gpp.org/ftp/Specs/archive/23_series/23.003/>.
[TS33501]
3GPP, "3GPP TS 33.501: Security architecture and procedures for 5G System", <https://www.3gpp.org/ftp/Specs/archive/33_series/33.501/>.

Acknowledgments

The author thanks the participants of 3GPP SA3 and IETF EMU working groups for discussions on supporting large SUCI values. The author also thanks the authors of I-D.ietf-emu-pqc-eapaka for defining the AT_FRAGMENT mechanism that is reused in this document.

Author's Address

T. Wan
CableLabs