| RFC 9289 | RPC-With-TLS | September 2022 |
| Myklebust & Lever | Standards Track | [Page] |
This document describes a mechanism that, through the use of opportunisticTransport Layer Security (TLS), enables encryption of Remote Procedure Call(RPC) transactions while they are in transit. The proposed mechanisminteroperates with Open Network Computing (ONC) RPC implementations that donot support it. This document updates RFC 5531.¶
This is an Internet Standards Track document.¶
This document is a product of the Internet Engineering Task Force (IETF). It represents the consensus of the IETF community. It has received public review and has been approved for publication by the Internet Engineering Steering Group (IESG). Further information on Internet Standards is available in Section 2 of RFC 7841.¶
Information about the current status of this document, any errata, and how to provide feedback on it may be obtained athttps://www.rfc-editor.org/info/rfc9289.¶
Copyright (c) 2022 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License.¶
In 2014 the IETF published a document entitled "Pervasive Monitoring Is anAttack"[RFC7258], whichrecognized that unauthorized observation of network traffic had becomewidespread and was a subversive threat to all who make use of the Internet atlarge. It strongly recommended that newly defined Internet protocols shouldmake a genuine effort to mitigate monitoring attacks. Typically, thismitigation includes encrypting data in transit.¶
The Remote Procedure Call version 2 protocol has been a Proposed Standard forthree decades (see[RFC5531]and its antecedents). Over twenty years ago, Eisler et al. first introducedRPCSEC_GSS as an in-transit encryption mechanism for RPC[RFC2203]. However, experiencehas shown that RPCSEC_GSS with in-transit encryption can be challenging to usein practice due to the following:¶
However strong GSS-provided confidentiality is,it cannot provide any security if the challengesof using it result in choosing not to deploy it at all.¶
Moreover, the use of AUTH_SYSremains common despite the adverse effectsthat acceptance of User Identifiers (UIDs) and Group Identifiers (GIDs)from unauthenticated clients brings with it.Continued use is in part because:¶
In view of the challenges with the currently available mechanisms forauthenticating and protecting the confidentiality of RPC transactions, thisdocument specifies a transport-layer security mechanism that complements theexisting ones. The TLS[RFC8446] and Datagram Transport Layer Security (DTLS)[RFC9147]protocols are well-established Internet building blocks that protect manystandard Internet protocols such as the Hypertext Transfer Protocol (HTTP)[RFC9110].¶
Encrypting at the RPC transport layer accords several significant benefits:¶
Further,Section 6of the current document defines policies in line with[RFC7435]that enable RPC-with-TLS to be deployed opportunistically in environments thatcontain RPC implementations that do not support TLS. However, specificationsfor RPC-based upper-layer protocols should choose to require even stricterpolicies that guarantee encryption and host authentication are used for all RPCtransactions to mitigate against pervasive monitoring attacks[RFC7258]. Enforcing the use ofRPC-with-TLS is of particular importance for existing upper-layer protocolswhose security infrastructure is weak.¶
The protocol specification in the current document assumes that support forONC RPC[RFC5531], TLS[RFC8446], PKIX[RFC5280], DNSSEC/DNS-BasedAuthentication of Named Entities (DANE)[RFC6698], and optionally RPCSEC_GSS[RFC2203]is available within the platformwhere RPC-with-TLS support is to be added.¶
The key words "MUST", "MUST NOT","REQUIRED", "SHALL", "SHALL NOT","SHOULD", "SHOULD NOT","RECOMMENDED", "NOT RECOMMENDED","MAY", and "OPTIONAL" in this document are to beinterpreted as described in BCP 14[RFC2119][RFC8174]when, and only when, they appear in all capitals, as shown here.¶
This document adopts the terminology introduced inSection 3 of [RFC6973]and assumes a working knowledge ofthe RPC version 2 protocol[RFC5531]andthe TLS version 1.3 protocol[RFC8446].¶
Note also that the NFS community long ago adopted theuse of the term "privacy" from documents such as[RFC2203].In the current document, the authors use the term"privacy" only when referring specificallyto the historic GSS privacy service defined in[RFC2203].Otherwise, the authors use the term "confidentiality",following the practices of contemporary security communities.¶
We adhere to the convention that a "client"is a network host that actively initiates an association,anda "server" is a network host that passively accepts an association request.¶
RPC documentation historically refers tothe authentication of a connecting host as "machine authentication"or "host authentication".TLS documentation refers to the same as "peer authentication".In the current document, there is little distinction between these terms.¶
The term "user authentication" in the current document refers specifically tothe RPC caller's credential, provided in the "cred" and "verf" fields in eachRPC Call.¶
The mechanism described in the current documentinteroperates fully with RPC implementationsthat do not support RPC-with-TLS.When an RPC-with-TLS-enabled peer encounters a peer thatdoes not support RPC-with-TLS,policy settings on the RPC-with-TLS-enabled peer determinewhether RPC operation continues without the use of TLSor is discontinued altogether.¶
To achieve this interoperability,we introduce a new RPC authentication flavor called AUTH_TLS.The AUTH_TLS authentication flavor signals that the client wantsto initiate TLS negotiation if the server supports it.Except for the modifications described in this section,the RPC protocol is unaware of security encapsulationat the transport layer.The value of AUTH_TLS is defined inSection 7.1.¶
An RPC client begins its communication with an RPC serverby selecting a transport and destination port.The choice of transport and port istypically based on the RPC program that is to be used.The RPC client might query the RPC server's RPCBIND serviceto make this selection(The RPCBIND service is described in[RFC1833]).The mechanism described in the current documentdoes not support RPC transports other than TCP and UDP.In all cases, an RPC serverMUST listen on the same portsfor (D)TLS-protected RPC programsas the ports used when (D)TLS is not available.¶
To protect RPC traffic to a TCP port,the RPC client opens a TCP connection to that portand sends a NULL RPC procedurewith an auth_flavor of AUTH_TLS on that connection.To protect RPC traffic to a UDP port,the RPC client sends a UDP datagram to that portcontaining a NULL RPC procedure with an auth_flavor of AUTH_TLS.The client constructs this RPC procedure as follows:¶
The RPC server signals its corresponding support for RPC-with-TLSby replying witha reply_stat of MSG_ACCEPTEDandan AUTH_NONE verifier containing the "STARTTLS" token.The clientSHOULD proceed with TLS session establishment,even if the Reply's accept_stat is not SUCCESS.If the AUTH_TLS probe was done via TCP,the RPC clientMUST send the "ClientHello" messageon the same connection.If the AUTH_TLS probe was done via UDP,the RPC clientMUST send the "ClientHello" messageto the same UDP destination port.¶
Conversely,if the Reply's reply_stat is not MSG_ACCEPTED,if its verifier flavor is not AUTH_NONE,or if its verifier does not contain the "STARTTLS" token,the RPC clientMUST NOT send a "ClientHello" message.RPC operation may continue,depending on local policy, but withoutconfidentiality,integrity,orpeer authentication protectionfrom (D)TLS.¶
If, after a successful RPC AUTH_TLS probe,the subsequent (D)TLS handshake should fail for any reason,the RPC client reports this failureto the upper-layer applicationthe same way it reports an AUTH_ERROR rejectionfrom the RPC server.¶
If an RPC client uses the AUTH_TLS authentication flavoron any procedure other than the NULL procedure,or an RPC client sends an RPC AUTH_TLS probe withinan existing (D)TLS session,the RPC serverMUST reject that RPC Callby returning a reply_stat of MSG_DENIEDwith a reject_stat of AUTH_ERRORand an auth_stat of AUTH_BADCRED.¶
Once the TLS session handshake is complete,the RPC client and server have establisheda secure channel for exchanging RPC transactions.A successful AUTH_TLS probe on one particular port/transport tupledoes not imply that RPC-with-TLS is available on that same serverusing a different port/transport tuple,nor does it imply thatRPC-with-TLS will be available in the futureusing the successfully probed port.¶
There is some overlap between the authenticationcapabilities of RPC and TLS.The goal of interoperability with implementationsthat do not support TLS requireslimiting the combinations that are allowedandprecisely specifying the role that each layer plays.¶
Each RPC server that supports RPC-with-TLSMUST possess a unique global identity(e.g., a certificate that is signed by a well-known trust anchor).Such an RPC serverMUST request a TLS peer identity from each clientupon first contact.There are two different modes of client deployment:¶
In either of these modes, RPC user authentication is not affected by the useof transport layer security. When a client presents a TLS peer identity to anRPC server, the protocol extension described in the current document providesno way for the server to know whether that identity represents one RPC user onthat client or is shared amongst many RPC users. Therefore, a serverimplementation cannot utilize the remote TLS peer identity to authenticate RPCusers.¶
To use GSS, an RPC server has to possess a GSS service principal.On a TLS session, GSS mutual (peer) authentication occurs as usual,but only after a TLS session has been established for communication.Authentication of RPCSEC_GSS users is unchanged by the use of TLS.¶
RPCSEC_GSS can also perform per-request integrity or confidentialityprotection. When operating over a TLS session, these GSS services becomelargely redundant. An RPC implementation capable of concurrently using TLSand RPCSEC_GSSMUST use Generic Security Service ApplicationProgram Interface (GSS-API) channel binding, as defined in[RFC5056], to determine when anunderlying transport provides a sufficient degree of confidentiality.RPC-with-TLS implementationsMUST provide the "tls-exporter"channel binding type, as defined in[RFC9266].¶
When peers negotiate a TLS session that is to transport RPC,the following restrictions apply:¶
Client implementationsMUST include the"application_layer_protocol_negotiation(16)" extension[RFC7301]in their "ClientHello" messageandMUST include the protocol identifierdefined inSection 7.2in that message's ProtocolNameList value.¶
Similarly, in response to the "ClientHello" message,server implementationsMUST include the"application_layer_protocol_negotiation(16)" extension[RFC7301]in their "ServerHello" messageandMUST include only the protocol identifierdefined inSection 7.2in that message's ProtocolNameList value.¶
If the server responds incorrectly(for instance, if the "ServerHello" message does not conform to the above requirements),the clientMUST NOT establish a TLS session for use with RPCon this connection.See[RFC7301]for further details about how to form these messages properly.¶
There is frequently a strong association between an RPC program and aparticular destination port number. The use of TLS or DTLS does not change thatassociation. Thus, it is frequently, though not always, the case that asingle TLS session carries traffic for only one RPC program.¶
The use of the TLS protocol[RFC8446]protects RPC on TCP connections.Typically,once an RPC client completes the TCP handshake,it uses the mechanism described inSection 4.1to discover RPC-with-TLS support for that RPC program on that connection.Until an AUTH_TLS probe is done on a connection,the RPC server treats all traffic as RPC messages.If spurious traffic appears on a TCP connectionbetween the initial cleartext AUTH_TLS probeandthe TLS session handshake,receiversMUST discard that data without responseand thenSHOULD drop the connection.¶
The protocol convention specified in the current documentassumes there can be no more than one concurrent TLS sessionper TCP connection.This is true of current generations of TLS,but might be different in a future version of TLS.¶
Once a TLS session is established on a TCP connection,no further cleartext communication can occur on that connectionuntil the session is terminated.The use of TLS does not alter RPC record framing used on TCP transports.¶
Furthermore,if an RPC server responds with PROG_UNAVAILto an RPC Call within an established TLS session,that does not imply that RPC server will subsequentlyreject the same RPC program on a different TCP connection.¶
Reverse-direction operation occurs only on connected transports such as TCP(seeSection 2 of [RFC8167]). To protect reverse-direction RPC operations, the RPCserver does not establish a separate TLS session on the TCP connection butinstead uses the existing TLS session on that connection to protect theseoperations.¶
When operation is complete,an RPC peer terminates a TLS session by sending a TLS closure alert.It may then close the TCP connection.¶
The use of the DTLS protocol[RFC9147]protects RPC carried in UDP datagrams.As soon as a client initializes a UDP socketfor use with an RPC service,it uses the mechanism described inSection 4.1to discover RPC-with-DTLS support for that RPC program on that port.If spurious traffic appears on a 5-tuple betweenthe initial cleartext AUTH_TLS probeandthe DTLS association handshake,receiversMUSTdiscard that traffic without response.¶
Using DTLS does not introducereliableorin-ordersemantics to RPC on UDP.The use of DTLS record replay protection isREQUIREDwhen transporting RPC traffic.¶
Each RPC messageMUST fit in a single DTLS record.DTLS encapsulation has overhead,which reduces the Packetization Layer Path MTU (PLPMTU)and thus the maximum RPC payload size.A possible PLPMTU discovery mechanism is offered in[RFC8899].¶
The current document does not specify a mechanismthat enables a server to distinguish betweenDTLS trafficandunprotected RPC trafficdirected to the same port.To make this distinction,each peer matches ingress datagramsthat appear to be DTLS traffic to existing DTLS session state.A peer treats any datagram that fails the matching process as an RPC message.¶
Multihomed RPC clients and servers may send protected RPC messagesvia network interfaces that were not involved in the handshake thatestablished the DTLS session.Therefore, when protecting RPC traffic,each DTLS handshakeMUST include the "connection_id(54)" extensiondescribed inSection 9 of [RFC9147],and RPC-with-DTLS peer endpointsMUSTprovide a ConnectionIDwith a nonzero length.Endpoints implementing RPC programsthat expect a significant number of concurrent clientsSHOULDemploy ConnectionIDs of at least 4 bytes in length.¶
Sending a TLS closure alert terminates a DTLS session. Because neither DTLSnor UDP provide in-order delivery, after session closure there can beambiguity as to whether a datagram should be interpreted as DTLS protected ornot. Therefore, receiversMUST discard datagrams exchangedusing the same 5-tuple that just terminated the DTLS session for a sufficientlength of time to ensure that retransmissions have ceased and packets alreadyin the network have been delivered. In the absence of more specific data, aperiod of 60 seconds is expected to suffice.¶
Transports that provide intrinsic TLS-level security(e.g., QUIC)need to be addressed separately from the current document.In such cases, the use of TLS is not opportunisticas it can be for TCP or UDP.¶
RPC-over-RDMA can make use of transport layer securitybelow the RDMA transport layer[RFC8166].The exact mechanism is not within the scope of the current document.Because there might not be other provisionsto exchange client and server certificates,authentication material exchangeneeds to be provided by facilitieswithin a future versionof the RPC-over-RDMA transport protocol.¶
TLS can perform peer authenticationusing any of the following mechanisms.¶
X.509 certificates are specified in[X.509].[RFC5280]provides a profile of Internet PKI X.509 public key infrastructure.RPC-with-TLS implementations areREQUIREDto support the PKIX mechanism described in[RFC5280].¶
The rules and guidelines defined in[RFC6125]apply to RPC-with-TLS certificateswith the following considerations:¶
When validating a server certificate,an RPC-with-TLS client implementationtakes the following into account:¶
An RPC client's domain name and IP address are often assigned dynamically;thus, RPC servers cannot rely on those to verify client certificates.Therefore, when an RPC-with-TLS client presents a certificate to anRPC-with-TLS server, the server takes the following into account:¶
RPC-with-TLS implementationsMAYallow the configurationof a set of additional properties of the certificateto check for a peer's authorization to communicate(e.g.,a set of allowed values in subjectAltName:URI,a set of allowed X.509v3 Certificate Policies,ora set of extended key usages).¶
When the configured set of trust anchors changes (e.g., removal of aCertification Authority (CA) from the list of trusted CAs; issuance of a new Certificate Revocation List (CRL)for a given CA), implementationsSHOULD reevaluate thecertificate originally presented in the context of the new configuration andterminate the TLS session if the certificate is no longer trustworthy.¶
Section 4.2.1.12 of [RFC5280]specifies the extended key usage X.509 certificate extension.This extension, which may appear in end-entity certificates,indicates one or more purposes for which the certified public key may be usedin addition to or in place of the basic purposes indicated in the key usage extension.¶
The current document defines two new KeyPurposeId values:one that identifies the RPC-with-TLS peer as an RPC client,andone that identifies the RPC-with-TLS peer as an RPC server.¶
The inclusion of the RPC server value (id-kp-rpcTLSServer)indicates that the certificate has been issuedfor allowing the holder to process RPC transactions.¶
The inclusion of the RPC client value (id-kp-rpcTLSClient)indicates that the certificate has been issuedfor allowing the holder to request RPC transactions.¶
This mechanism isOPTIONAL to implement. In this mode, the RPCpeer can be uniquely identified by keying material that has been sharedout of band (seeSection 2.2 of [RFC8446]). The PSK IdentifierSHOULD be exposed at the RPC layer.¶
One purpose of the mechanism described in the current documentis to protect RPC-based applications against threatsto the confidentiality of RPC transactionsandRPC user identities.A taxonomy of these threats appears inSection 5 of [RFC6973].Also,Section 6 of [RFC7525]contains a detailed discussionof technologies used in conjunction with TLS.Section 8 of [RFC5280]covers important considerations about handling certificate material securely.Implementers should familiarize themselves with these materials.¶
Once a TLS session is established,the RPC payload carried on TLS version 1.3 is forward secure.However, implementers need to be aware that replay attackscan occur during session establishment.Remedies for such attacks are discussed in detail inSection 8 of [RFC8446].Further, the current document does notprovide a profile that defines the use of 0-RTT data(seeAppendix E.5 of [RFC8446]).Therefore, RPC-with-TLS implementationsMUST NOTuse 0-RTT data.¶
Readers can find the definition of Opportunistic Security in[RFC7435].A discussion of its underlying principlesappears in Section3 of that document.¶
The purpose of using an explicitly opportunistic approachis to enable interoperationwith implementations that do not support RPC-with-TLS.A range of options is allowed by this approach,from "no peer authentication or encryption"to"server-only authentication with encryption"to"mutual authentication with encryption".The actual security level may indeedbe selected based on policy and without user intervention.¶
In environments where interoperability is a priority,the security benefits of TLS are partially or entirely waived.Implementations of the mechanism described in the current documentmust take care to accurately represent to all RPC consumersthe level of security that is actually in effect,and areREQUIRED to provide an audit logof RPC-with-TLS security mode selection.¶
In all other cases,the adoption, implementation, and deployment ofRPC-based upper-layer protocols that enforce the use ofTLS authentication and encryption(when similar RPCSEC_GSS services are not in use)is strongly encouraged.¶
The initial AUTH_TLS probe occurs in cleartext.An on-path attacker can alter a cleartext handshake to make itappear as though TLS support is not available on one or both peers.Client implementers can choose from the following to mitigateSTRIPTLS attacks:¶
As mentioned earlier,communication between an RPC client and serverappears in the clear on the networkprior to the establishment of a TLS session.This cleartext information usually includestransport connection handshake exchanges,the RPC NULL procedure probing support for TLS,and the initial parts of TLS session establishment.Appendix C of [RFC8446]discusses precautions that can mitigate exposure during the exchange ofconnection handshake information and TLS certificate material that mightenable attackers to track the RPC client. Note that when PSK authenticationis used, the PSK identifier is exposed during the TLS handshake and can beused to track the RPC client.¶
Any RPC traffic that appears on the network beforea TLS session has been established is vulnerable tomonitoring or undetected modification.A secure client implementation limits or preventsany RPC exchanges that are not protected.¶
The exception to this edict isthe initial RPC NULL procedure that acts as a STARTTLS message,which cannot be protected.This RPC NULL procedure contains no arguments or results,and the AUTH_TLS authentication flavor it usesdoes not contain user information,so there is negligible privacy impact from this exception.¶
The goal of RPC-with-TLS is to hide the content of RPC requests while they arein transit. RPC-with-TLS protocol by itself cannot protect againstexposure of a user's RPC requests to other users on the same client.¶
Moreover, client implementations are free to transmit RPC requestsfor more than one RPC user using the same TLS session.Depending on the details of the client RPC implementation,this means that the client's TLS credentialsare potentially visible to every RPC user that shares a TLS session.Privileged users may also be able to access this TLS identity.¶
As a result,client implementations need to carefully segregateTLS credentials so that local access to itis restricted to only the local users that are authorizedto perform operations on the remote RPC server.¶
Using a TLS-protected transportwhen the AUTH_SYS authentication flavor is in useaddresses several longstanding weaknesses in AUTH_SYS(as detailed inAppendix A).TLS augments AUTH_SYS by providing bothintegrity protection and confidentialitythat AUTH_SYS lacks.TLS protectsdata payloads,RPC headers,anduser identitiesagainst monitoring and alteration while in transit.¶
TLS guards against in-transit insertion and deletion of RPC messages, thusensuring the integrity of the message stream between RPC client and server.DTLS does not provide full message stream protection, but it does enablereceivers to reject nonparticipant messages. In particular, transport-layerencryption plus peer authentication protects receiving eXternal DataRepresentation (XDR) decoders from deserializing untrusted data, a commoncoding vulnerability. However, these decoders would still be exposed tountrusted input in the case of the compromise of a trusted peer or CertificationAuthority.¶
The use of TLS enables strong authenticationof the communicating RPC peers,providing a degree of non-repudiation.When AUTH_SYS is used with TLS,but the RPC client is unauthenticated,the RPC server still acts on RPC requestsfor which there is no trustworthy authentication.In-transit traffic is protected, but the RPC client itselfcan still misrepresent user identity without server detection.TLS without authentication is an improvementfrom AUTH_SYS without encryption,but it leaves a critical security exposure.¶
In light of the above, when AUTH_SYS is used,the use of a TLS mutual authentication mechanism isRECOMMENDEDto prove that the RPC client is known to the RPC server.The server can then determine whether the UIDs and GIDsin AUTH_SYS requests from that client can be accepted,based on the authenticated identity of the client.¶
The use of TLS does not enable RPC clients to detect compromisethat leads to the impersonation of RPC users.Also, there continues to be a requirementthat the mapping of 32-bit user and group ID valuesto user identitiesis the same on both the RPC client and server.¶
RPC-with-TLS implementations and deploymentsare strongly encouraged to adhere to the following policiesto achieve the strongest possible security with RPC-with-TLS.¶
FollowingAppendix B of [RFC5531], an entry has been added to the "RPCAuthentication Flavor Numbers" registry. The purpose of the new authenticationflavor is to signal the use of TLS with RPC. This new flavor is not apseudo-flavor.¶
The fields in the new entry have been assigned as follows:¶
FollowingSection 6 of [RFC7301],the following value has been allocatedin the "TLS Application-Layer Protocol Negotiation (ALPN) Protocol IDs" registry.The "sunrpc" string identifies SunRPC when used over TLS.¶
Per the Specification Required policy defined inSection 4.6 of [RFC8126], the following new valueshave been registered in the "SMI Security for PKIX Extended Key Purpose"registry (1.3.6.1.5.5.7.3) (seeSection 5.2.1.1andAppendix B).¶
| Decimal | Description | Reference |
|---|---|---|
| 33 | id-kp-rpcTLSClient | RFC 9289 |
| 34 | id-kp-rpcTLSServer | RFC 9289 |
Per the Specification Required policy defined inSection 4.6 of [RFC8126], the following new value has been registered in the "SMI Security for PKIX Module Identifier" registry (1.3.6.1.5.5.7.0) (seeAppendix B).¶
| Decimal | Description | Reference |
|---|---|---|
| 105 | id-mod-rpcWithTLS-2021 | RFC 9289 |
The ONC RPC protocol, as specified in[RFC5531], provides several modes of security, commonlyreferred to as "authentication flavors". Some of these flavors provide muchmore than an authentication service. We refer to these as authenticationflavors, security flavors, or simply, flavors. One of the earliest and mostbasic flavors is AUTH_SYS, also known as AUTH_UNIX.Appendix A of [RFC5531]specifies AUTH_SYS.¶
AUTH_SYS assumes that the RPC client and serverboth use POSIX-style user and group identifiers(each user and group can be distinctly representedas a 32-bit unsigned integer).It also assumes that the client and serverboth use the same mapping of user and group to an integer.One user ID, one primary group ID, and up to 16 supplemental group IDsare associated with each RPC request.The combination of these identifies the entity on the clientthat is making the request.¶
A string identifies peers (hosts) in each RPC request.[RFC5531]does not specify any requirements for this stringother than that it is no longer than 255 octets.It does not have to be the same from request to request.Also, it does not have to match the DNS hostname of the sending host.For these reasons,even though most implementations fill in their hostname in this field,receivers typically ignore its content.¶
Appendix A of [RFC5531]contains a brief explanation of security considerations:¶
It should be noted that use of this flavor of authentication does notguarantee any security for the users or providers of a service, initself. The authentication provided by this scheme can be consideredlegitimate only when applications using this scheme and the networkcan be secured externally, and privileged transport addresses areused for the communicating end-points (an example of this is the useof privileged TCP/UDP ports in UNIX systems -- note that not allsystems enforce privileged transport address mechanisms).¶
It should be clear, therefore, that AUTH_SYS by itself(i.e., without strong client authentication)offers little to no communication security:¶
The following module adheres to ASN.1 specifications[X.680] and[X.690].¶
<CODE BEGINS>RPCwithTLS-2021 { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) id-mod(0) id-mod-rpcWithTLS-2021(105) }DEFINITIONS IMPLICIT TAGS ::=BEGIN-- OID Arcid-kp OBJECT IDENTIFIER ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) kp(3) }-- Extended Key Usage Valuesid-kp-rpcTLSClient OBJECT IDENTIFIER ::= { id-kp 33 }id-kp-rpcTLSServer OBJECT IDENTIFIER ::= { id-kp 34 }END<CODE ENDS>¶Special mention goes toCharles Fisher,author of"Encrypting NFSv4 with Stunnel TLS". His article inspired themechanism described in the current document.¶
Many thanks toBenjamin Coddington,Tigran Mkrtchyan,andRick Macklemfor their work on prototype implementations and feedback on the current document.Also, thanks toBenjamin Kadukfor his expert guidance on the use of PKIX and TLSand toRuss Housley for his ASN.1 expertise and for providing other proper finishing touches.In addition, the authors thank the other members of the IESG fortheir astute review comments. These contributors made this a significantly better document.¶
Thanks toDerrell Piperfor numerous suggestions that improved boththis simple mechanismandthe current document's security-related discussion.¶
Many thanks toTransport Area DirectorMagnus Westerlundfor his sharp questions and careful readingof the final revisions of the current document.The text ofSection 5.1.2is mostly his contribution.¶
The authors are additionally grateful toBill Baker,David Black,Alan DeKok,Lars Eggert,Olga Kornievskaia,Greg Marsden,Alex McDonald,Justin Mazzola Paluska,Tom Talpey,Martin Thomson,andNico Williamsfor their input and support of this work.¶
Finally, special thanks toNFSV4 Working Group Chair and document shepherdDavid Noveck,NFSV4 Working Group ChairsSpencer SheplerandBrian Pawlowski, and NFSV4 Working Group SecretaryThomas Haynesfor their guidance and oversight.¶