RFC 7831
Application Bridging for Federated Access Beyond Web (ABFAB) Architecture
Pages: 46
Informational
Informational
Part 1 of 3 – Pages 1 to 15
Internet Engineering Task Force (IETF) J. Howlett Request for Comments: 7831 Jisc Category: Informational S. Hartman ISSN: 2070-1721 Painless Security H. Tschofenig ARM Ltd. J. Schaad August Cellars May 2016 Application Bridging for Federated Access Beyond Web (ABFAB) ArchitectureAbstract
Over the last decade, a substantial amount of work has occurred in the space of federated access management. Most of this effort has focused on two use cases: network access and web-based access. However, the solutions to these use cases that have been proposed and deployed tend to have few building blocks in common. This memo describes an architecture that makes use of extensions to the commonly used security mechanisms for both federated and non- federated access management, including the Remote Authentication Dial-In User Service (RADIUS), the Generic Security Service Application Program Interface (GSS-API), the Extensible Authentication Protocol (EAP), and the Security Assertion Markup Language (SAML). The architecture addresses the problem of federated access management to primarily non-web-based services, in a manner that will scale to large numbers of Identity Providers, Relying Parties, and federations. Status of This Memo This document is not an Internet Standards Track specification; it is published for informational purposes. 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). Not all documents approved by the IESG are a candidate for any level of Internet Standard; see Section 2 of RFC 5741. Information about the current status of this document, any errata, and how to provide feedback on it may be obtained at http://www.rfc-editor.org/info/rfc7831.
Copyright Notice Copyright (c) 2016 IETF Trust and the persons identified as the document authors. All rights reserved. This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (http://trustee.ietf.org/license-info) 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 Simplified BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Simplified BSD License.
Table of Contents
1. Introduction ....................................................4 1.1. Terminology ................................................5 1.1.1. Channel Binding .....................................6 1.2. An Overview of Federation ..................................8 1.3. Challenges for Contemporary Federation ....................11 1.4. An Overview of ABFAB-Based Federation .....................11 1.5. Design Goals ..............................................14 2. Architecture ...................................................15 2.1. Relying Party to Identity Provider ........................16 2.1.1. AAA, RADIUS, and Diameter ..........................17 2.1.2. Discovery and Rules Determination ..................19 2.1.3. Routing and Technical Trust ........................20 2.1.4. AAA Security .......................................21 2.1.5. SAML Assertions ....................................22 2.2. Client to Identity Provider ...............................24 2.2.1. Extensible Authentication Protocol (EAP) ...........24 2.2.2. EAP Channel Binding ................................26 2.3. Client to Relying Party ...................................26 2.3.1. GSS-API ............................................27 2.3.2. Protocol Transport .................................28 2.3.3. Re-authentication ..................................29 3. Application Security Services ..................................29 3.1. Authentication ............................................29 3.2. GSS-API Channel Binding ...................................31 3.3. Host-Based Service Names ..................................32 3.4. Additional GSS-API Services ...............................33 4. Privacy Considerations .........................................34 4.1. Entities and Their Roles ..................................35 4.2. Privacy Aspects of ABFAB Communication Flows ..............36 4.2.1. Client to RP .......................................36 4.2.2. Client to IdP (via Federation Substrate) ...........37 4.2.3. IdP to RP (via Federation Substrate) ...............38 4.3. Relationship between User and Entities ....................39 4.4. Accounting Information ....................................39 4.5. Collection and Retention of Data and Identifiers ..........39 4.6. User Participation ........................................40 5. Security Considerations ........................................40 6. References .....................................................41 6.1. Normative References ......................................41 6.2. Informative References ....................................42 Acknowledgments ...................................................46 Authors' Addresses ................................................46
1. Introduction
Numerous security mechanisms have been deployed on the Internet to manage access to various resources. These mechanisms have been generalized and scaled over the last decade through mechanisms such as the Simple Authentication and Security Layer (SASL) with the Generic Security Server Application Program Interface (GSS-API) (known as the GS2 family) [RFC5801]; the Security Assertion Markup Language (SAML) [OASIS.saml-core-2.0-os]; and the Authentication, Authorization, and Accounting (AAA) architecture as embodied in RADIUS [RFC2865] and Diameter [RFC6733]. A Relying Party (RP) is the entity that manages access to some resource. The entity that is requesting access to that resource is often described as the client. Many security mechanisms are manifested as an exchange of information between these entities. The RP is therefore able to decide whether the client is authorized or not. Some security mechanisms allow the RP to delegate aspects of the access management decision to an entity called the Identity Provider (IdP). This delegation requires technical signaling, trust, and a common understanding of semantics between the RP and IdP. These aspects are generally managed within a relationship known as a "federation". This style of access management is accordingly described as "federated access management". Federated access management has evolved over the last decade through specifications like SAML [OASIS.saml-core-2.0-os], OpenID (http://www.openid.net), OAuth [RFC6749], and WS-Trust [WS-TRUST]. The benefits of federated access management include: Single or simplified sign-on: An Internet service can delegate access management, and the associated responsibilities such as identity management and credentialing, to an organization that already has a long-term relationship with the client. This is often attractive, as RPs frequently do not want these responsibilities. The client also requires fewer credentials, which is also desirable.
Data minimization and user participation:
Often, an RP does not need to know the identity of a client to
reach an access management decision. It is frequently only
necessary for the RP to know specific attributes about the client
-- for example, that the client is affiliated with a particular
organization or has a certain role or entitlement. Sometimes, the
RP only needs to know a pseudonym of the client.
Prior to the release of attributes to the RP from the IdP, the IdP
will check configuration and policy to determine if the attributes
are to be released. There is currently no direct client
participation in this decision.
Provisioning:
Sometimes, an RP needs, or would like, to know more about a client
than an affiliation or a pseudonym. For example, an RP may want
the client's email address or name. Some federated access
management technologies provide the ability for the IdP to supply
this information, either on request by the RP or unsolicited.
This memo describes the Application Bridging for Federated Access
Beyond web (ABFAB) architecture. This architecture addresses the
problem of federated access management primarily for non-web-based
services. This architecture makes use of extensions to the commonly
used security mechanisms for both federated and non-federated access
management, including RADIUS, the Generic Security Service (GSS), the
Extensible Authentication Protocol (EAP), and SAML. The architecture
should be extended to use Diameter in the future. It does so in a
manner that is designed to scale to large numbers of IdPs, RPs, and
federations.
1.1. Terminology
This document uses identity management and privacy terminology from
[RFC6973]. In particular, this document uses the terms
"identity provider", "relying party", "identifier", "pseudonymity",
"unlinkability", and "anonymity".
In this architecture, the IdP consists of the following components:
an EAP server, a RADIUS server, and, optionally, a SAML Assertion
service.
This document uses the term "Network Access Identifier" (NAI) as
defined in [RFC7542]. An NAI consists of a realm identifier, which
is associated with a AAA server, and thus an IdP and a username, that
are associated with a specific client of the IdP.
One of the problems some people have found with reading this document is that the terminology sometimes appears to be inconsistent. This is because the various standards that we refer to use different terms for the same concept. In general, this document uses either the ABFAB term or the term associated with the standard under discussion, as appropriate. For reference, we include Table 1 below, which provides a mapping for these different terms. (Note that items marked "N/A" (not applicable) indicate that there is no name that represents the entity.) +----------+-----------+--------------------+-----------------------+ | Protocol | Client | Relying Party | Identity Provider | +----------+-----------+--------------------+-----------------------+ | ABFAB | N/A | Relying Party (RP) | Identity Provider | | | | | (IdP) | | | | | | | | Initiator | Acceptor | N/A | | | | | | | | Client | Server | N/A | | | | | | | SAML | Subject | Service provider | Issuer | | | | | | | GSS-API | Initiator | Acceptor | N/A | | | | | | | EAP | EAP peer | EAP authenticator | EAP server | | | | | | | AAA | N/A | AAA client | AAA server | | | | | | | RADIUS | user | NAS | N/A | | | | | | | | N/A | RADIUS client | RADIUS server | +----------+-----------+--------------------+-----------------------+ Table 1: Terminology1.1.1. Channel Binding
This document uses the term "channel binding" in two different contexts; this term has a different meaning in each of these contexts. EAP channel binding is used to implement GSS-API naming semantics. EAP channel binding sends a set of attributes from the peer to the EAP server either as part of the EAP conversation or as part of a secure association protocol. In addition, attributes are sent in the back-end protocol from the EAP authenticator to the EAP server. The
EAP server confirms the consistency of these attributes and provides the confirmation back to the peer. In this document, channel binding without qualification refers to EAP channel binding. GSS-API channel binding provides protection against man-in-the-middle attacks when GSS-API is used for authentication inside of some tunnel; it is similar to a facility called "cryptographic binding" in EAP. The binding works by each side deriving a cryptographic value from the tunnel itself and then using that cryptographic value to prove to the other side that it knows the value. See [RFC5056] for a discussion of the differences between these two facilities. These differences can be summarized as follows: o GSS-API channel binding specifies that there is nobody between the client and the EAP authenticator. o EAP channel binding allows the client to have knowledge of such EAP authenticator attributes as the EAP authenticator's name. Typically, when considering both EAP and GSS-API channel binding, people think of channel binding in combination with mutual authentication. This is sufficiently common that, without additional qualification, channel binding should be assumed to imply mutual authentication. In GSS-API, without mutual authentication, only the acceptor has authenticated the initiator. Similarly, in EAP, only the EAP server has authenticated the peer. Sometimes, one-way authentication is useful. Consider, for example, a user who wishes to access a protected resource for a shared whiteboard in a conference room. The whiteboard is the acceptor; it knows that the initiator is authorized to give it a presentation, and the user can validate that the whiteboard got the correct presentation by visual means. (The presentation should not be confidential in this case.) If channel binding is used without mutual authentication, it is effectively a request to disclose the resource in the context of a particular channel. Such an authentication would be similar in concept to a holder-of-key SAML Assertion. However, note also that although it is not happening in the protocol, mutual authentication is happening in the overall system: the user is able to visually authenticate the content. This is consistent with all uses of channel binding without protocol-level mutual authentication found so far.
1.2. An Overview of Federation
In the previous section, we introduced the following entities: o the client, o the IdP, and o the RP. The final entity that needs to be introduced is the Individual. An Individual is a human being that is using the client. In any given situation, an Individual may or may not exist. Clients can act as front ends for Individuals, or clients may be independent entities that are set up and allowed to run autonomously. An example of such an independent entity can be found in the Trust Router Protocol (https://www.ietf.org/proceedings/86/slides/slides-86-rtgarea-0.pdf), where the routers use ABFAB to authenticate to each other. These entities and their relationships are illustrated graphically in Figure 1. ,----------\ ,---------\ | Identity | Federation | Relying | | Provider + <--------------------> + Party | `----------' '---------' < \ \ Authentication \ \ \ \ \ +---------+ \ | | O v| Client | \|/ Individual | | | +---------+ / \ Figure 1: Entities and Their Relationships
The relationships between the entities in Figure 1 are as follows: Federation The IdP and the RPs are part of a federation. The relationship may be direct (they have an explicit trust relationship) or transitive (the trust relationship is mediated by one or more entities). The federation relationship is governed by a federation agreement. Within a single federation, there may be multiple IdPs as well as multiple RPs. Authentication There is a direct relationship between the client and the IdP. This relationship provides the means by which they trust each other and can securely authenticate each other. A federation agreement typically encompasses operational specifications and legal rules: Operational Specifications: The goal of operational specifications is to provide enough definition that the system works and interoperability is possible. These include the technical specifications (e.g., protocols used to communicate between the three parties), process standards, policies, identity proofing, credential and authentication algorithm requirements, performance requirements, assessment and audit criteria, etc. Legal Rules: The legal rules take the legal framework into consideration and provide contractual obligations for each entity. The rules define the responsibilities of each party and provide further clarification of the operational specifications. These legal rules regulate the operational specifications, make operational specifications legally binding to the participants, and define and govern the rights and responsibilities of the participants. The legal rules may, for example, describe liability for losses, termination rights, enforcement mechanisms, measures of damage, dispute resolution, warranties, etc.
The operational specifications can demand the usage of a specific technical infrastructure, including requirements on the message routing intermediaries, to offer the required technical functionality. In other environments, the operational specifications require fewer technical components in order to meet the required technical functionality. The legal rules include many non-technical aspects of federation, such as business practices and legal arrangements, which are outside the scope of the IETF. The legal rules can still have an impact on the architectural setup or on how to ensure the dynamic establishment of trust. While a federation agreement is often discussed within the context of formal relationships, such as between an enterprise and an employee or between a government and a citizen, a federation agreement does not have to require any particular level of formality. For an IdP and a client, it is sufficient for a relationship to be established by something as simple as using a web form and confirmation email. For an IdP and an RP, it is sufficient for the IdP to publish contact information along with a public key and for the RP to use that data. Within the framework of ABFAB, it will generally be required that a mechanism exist for the IdP to be able to trust the identity of the RP; if this is not present, then the IdP cannot provide the assurances to the client that the identity of the RP has been established. The nature of federation dictates that there exists some form of relationship between the IdP and the RP. This is particularly important when the RP wants to use information obtained from the IdP for access management decisions and when the IdP does not want to release information to every RP (or only under certain conditions). While it is possible to have a bilateral agreement between every IdP and every RP, on an Internet scale, this setup requires the introduction of the multilateral federation concept, as the management of such pair-wise relationships would otherwise prove burdensome. The IdP will typically have a long-term relationship with the client. This relationship typically involves the IdP positively identifying and credentialing the client (for example, at the time of employment within an organization). When dealing with Individuals, this process is called "identity proofing" [NIST-SP.800-63-2]. The relationship will often be instantiated within an agreement between the IdP and the client (for example, within an employment contract or terms of use that stipulate the appropriate use of credentials and so forth).
The nature and quality of the relationship between the client and the IdP are important contributors to the level of trust that an RP may assign to an assertion describing a client made by an IdP. This is sometimes described as the level of assurance [NIST-SP.800-63-2]. Federation does not require an a priori relationship or a long-term relationship between the RP and the client; it is this property of federation that yields many of its benefits. However, federation does not preclude the possibility of a pre-existing relationship between the RP and the client or the possibility that the RP and client may use the introduction to create a new long-term relationship independent of the federation. Finally, it is important to reiterate that in some scenarios there might indeed be an Individual behind the client and in other cases the client may be autonomous.1.3. Challenges for Contemporary Federation
As federated IdPs and RPs (services) proliferate, the role of an Individual can become ambiguous in certain circumstances. For example, a school might provide online access for a student's grades to their parents for review and to the student's teacher for modification. A teacher who is also a parent must clearly distinguish their role upon access. Similarly, as federations proliferate, it becomes increasingly difficult to discover which IdP(s) a user is associated with. This is true for both the web and non-web case but is particularly acute for the latter, as many non-web authentication systems are not semantically rich enough on their own to allow for such ambiguities. For instance, in the case of an email provider, SMTP and IMAP do not have the ability for the server to request information from the client, beyond the client NAI, that the server would then use to decide between the multiple federations it is associated with. However, the building blocks do exist to add this functionality.1.4. An Overview of ABFAB-Based Federation
The previous section described the general model of federation and the application of access management within the federation. This section provides a brief overview of ABFAB in the context of this model.
In this example, a client is attempting to connect to a server in order to either get access to some data or perform some type of transaction. In order for the client to mutually authenticate with the server, the following steps are taken in an ABFAB architecture (a graphical view of the steps can be found in Figure 2): 1. Client configuration: The client is configured with an NAI assigned by the IdP. It is also configured with any keys, certificates, passwords, or other secret and public information needed to run the EAP protocols between it and the IdP. 2. Authentication mechanism selection: The client is configured to use the GSS-EAP GSS-API mechanism for authentication/ authorization. 3. Client provides an NAI to RP: The client sets up a transport to the RP and begins GSS-EAP authentication. In response, the RP sends an EAP request message (nested in GSS-EAP) asking for the client's name. The client sends an EAP response with an NAI name form that, at a minimum, contains the realm portion of its full NAI. 4. Discovery of federated IdP: The RP uses preconfigured information or a federation proxy to determine what IdP to use, based on policy and the realm portion of the provided client NAI. This is discussed in detail below (Section 2.1.2). 5. Request from RP to IdP: Once the RP knows who the IdP is, it (or its agent) will send a RADIUS request to the IdP. The RADIUS Access-Request encapsulates the EAP response. At this stage, the RP will likely have no idea who the client is. The RP sends its identity to the IdP in AAA attributes, and it may send a SAML request in a AAA attribute. The AAA network checks to see that the identity claimed by the RP is valid. 6. IdP begins EAP with the client: The IdP sends an EAP message to the client with an EAP method to be used. The IdP should not re-request the client's name in this message, but clients need to be able to handle it. In this case, the IdP must accept a realm only in order to protect the client's name from the RP. The available and appropriate methods are discussed below (Section 2.2.1). 7. EAP is run: A bunch of EAP messages are passed between the client (EAP peer) and the IdP (EAP server), until the result of the authentication protocol is determined. The number and content of those messages depend on the EAP method selected. If the IdP is unable to authenticate the client, the IdP sends an
EAP failure message to the RP. As part of the EAP method, the
client sends an EAP channel-binding message to the IdP
(Section 2.2.2). In the channel-binding message, the client
identifies, among other things, the RP to which it is attempting
to authenticate. The IdP checks the channel-binding data from
the client against the data provided by the RP via the AAA
protocol. If the bindings do not match, the IdP sends an EAP
failure message to the RP.
8. Successful EAP authentication: At this point, the IdP (EAP
server) and client (EAP peer) have mutually authenticated each
other. As a result, the client and the IdP hold two
cryptographic keys: a Master Session Key (MSK) and an Extended
MSK (EMSK). At this point, the client has a level of assurance
regarding the identity of the RP, based on the name checking the
IdP has done, using the RP naming information from the AAA
framework and from the client (by the channel-binding data).
9. Local IdP policy check: At this stage, the IdP checks local
policy to determine whether the RP and client are authorized for
a given transaction/service and, if so, what attributes, if any,
will be released to the RP. If the IdP gets a policy failure,
it sends an EAP failure message to the RP and client. (The RP
will have done its policy checks during the discovery process.)
10. IdP provides the RP with the MSK: The IdP sends a success result
EAP to the RP, along with an optional set of AAA attributes
associated with the client (usually as one or more SAML
Assertions). In addition, the EAP MSK is returned to the RP.
11. RP processes results: When the RP receives the result from the
IdP, it should have enough information to either grant or refuse
a resource Access-Request. It may have information that
associates the client with specific authorization identities.
If additional attributes are needed from the IdP, the RP may
make a new SAML request to the IdP. It will apply these results
in an application-specific way.
12. RP returns results to client: Once the RP has a response, it
must inform the client of the result. If all has gone well, all
are authenticated, and the application proceeds with appropriate
authorization levels. The client can now complete the
authentication of the RP by using the EAP MSK value.
Relying Client Identity Party Provider | (1) | Client configuration | | | |<-----(2)----->| | Mechanism selection | | | |<-----(3)-----<| | NAI transmitted to RP | | | |<=====(4)====================>| IdP Discovery | | | |>=====(5)====================>| Access-Request from RP to IdP | | | | |< - - (6) - -<| EAP method to client | | | | |< - - (7) - ->| EAP exchange to authenticate | | | client | | | | | (8 & 9) Local policy check | | | |<====(10)====================<| Results to RP | | | (11) | | RP processes results | | | |>----(12)----->| | Results to client Legend: -----: Between client and RP =====: Between RP and IdP - - -: Between client and IdP (via RP) Figure 2: ABFAB Authentication Steps1.5. Design Goals
Our key design goals are as follows: o Each party in a transaction will be authenticated, although perhaps not identified, and the client will be authorized for access to a specific resource. o The means of authentication is decoupled from the application protocol so as to allow for multiple authentication methods with minimal changes to the application. o The architecture requires no sharing of long-term private keys between clients and RPs.
o The system will scale to large numbers of IdPs, RPs, and users.
o The system will be designed primarily for non-web-based
authentication.
o The system will build upon existing standards, components, and
operational practices.
Designing new three-party authentication and authorization protocols
is difficult and fraught with the risk of cryptographic flaws.
Achieving widespread deployment is even more difficult. A lot of
attention on federated access has been devoted to the web. This
document instead focuses on a non-web-based environment and focuses
on those protocols where HTTP is not used. Despite the growing trend
to layer every protocol on top of HTTP, there are still a number of
protocols available that do not use HTTP-based transports. Many of
these protocols are lacking a native authentication and authorization
framework of the style shown in Figure 1.
(page 15 continued on part 2)