Network Working Group S. Hartman, Ed.
Internet-Draft Painless Security
Intended status: Standards Track J. Howlett
Expires: August 21, 2011 JANET(UK)
February 17, 2011
A GSS-API Mechanism for the Extensible Authentication Protocol
draft-ietf-abfab-gss-eap-01.txt
Abstract
This document defines protocols, procedures, and conventions to be
employed by peers implementing the Generic Security Service
Application Program Interface (GSS-API) when using the EAP mechanism.
Through the GS2 family of mechanisms, these protocols also define how
Simple Authentication and Security Layer (SASL, RFC 4422)
applications use the Extensible Authentication Protocol.
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 http://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 August 21, 2011.
Copyright Notice
Copyright (c) 2011 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
Hartman & Howlett Expires August 21, 2011 [Page 1]
Internet-Draft EAP GSS-API February 2011
the Trust Legal Provisions and are provided without warranty as
described in the Simplified BSD License.
Table of Contents
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1. Discovery . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2. Authentication . . . . . . . . . . . . . . . . . . . . . . 4
1.3. Secure Association Protocol . . . . . . . . . . . . . . . 5
2. Requirements notation . . . . . . . . . . . . . . . . . . . . 6
3. EAP Channel Binding and Naming . . . . . . . . . . . . . . . . 7
3.1. Mechanism Name Format . . . . . . . . . . . . . . . . . . 7
3.2. Exported Mechanism Names . . . . . . . . . . . . . . . . . 9
3.3. Acceptor Name RADIUS AVP . . . . . . . . . . . . . . . . . 10
3.4. Proxy Verification of Acceptor Name . . . . . . . . . . . 11
4. Selection of EAP Method . . . . . . . . . . . . . . . . . . . 12
5. Context Tokens . . . . . . . . . . . . . . . . . . . . . . . . 13
5.1. Mechanisms and Encryption Types . . . . . . . . . . . . . 13
5.2. Context Options . . . . . . . . . . . . . . . . . . . . . 13
6. Acceptor Services . . . . . . . . . . . . . . . . . . . . . . 15
6.1. GSS-API Channel Binding . . . . . . . . . . . . . . . . . 15
6.2. Per-message security . . . . . . . . . . . . . . . . . . . 15
6.3. Pseudo Random Function . . . . . . . . . . . . . . . . . . 16
7. Open Mechanism Issues . . . . . . . . . . . . . . . . . . . . 17
8. Applicability Considerations . . . . . . . . . . . . . . . . . 18
9. Security Considerations . . . . . . . . . . . . . . . . . . . 19
10. References . . . . . . . . . . . . . . . . . . . . . . . . . . 20
10.1. Normative References . . . . . . . . . . . . . . . . . . . 20
10.2. Informative References . . . . . . . . . . . . . . . . . . 21
Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . . 22
Hartman & Howlett Expires August 21, 2011 [Page 2]
Internet-Draft EAP GSS-API February 2011
1. Introduction
The ABFAB architecture [I-D.lear-abfab-arch] describes an
architecture for providing federated access management to
applications using the Generic Security Services Application
Programming Interface (GSS-API) [RFC2743] and Simple Authentication
and Security Layers (SASL) [RFC4422]. This specification provides
the core mechanism for bringing federated authentication to these
applications.
The Extensible Authentication Protocol (EAP) [RFC3748] defines a
framework for authenticating a network access client and server in
order to gain access to a network. A variety of different EAP
methods are in wide use; one of EAP's strengths is that for most
types of credentials in common use, there is an EAP method that
permits the credential to be used.
EAP is often used in conjunction with a backend authentication server
via RADIUS [RFC3579] or Diameter [RFC4072]. In this mode, the NAS
simply tunnels EAP packets over the backend authentication protocol
to a home EAP/AAA server for the client. After EAP succeeds, the
backend authentication protocol is used to communicate key material
to the NAS. In this mode, the NAS need not be aware of or have any
specific support for the EAP method used between the client and the
home EAP server. The client and EAP server share a credential that
depends on the EAP method; the NAS and AAA server share a credential
based on the backend authentication protocol in use. The backend
authentication server acts as a trusted third party enabling network
access even though the client and NAS may not actually share any
common authentication methods. As described in the architecture
document, using AAA proxies, this mode can be extended beyond one
organization to provide federated authentication for network access.
The GSS-API provides a generic framework for applications to use
security services including authentication and per-message data
security. Between protocols that support GSS-API directly or
protocols that support SASL [RFC4422], many application protocols can
use GSS-API for security services. However, with the exception of
Kerberos [RFC4121], few GSS-API mechanisms are in wide use on the
Internet. While GSS-API permits an application to be written
independent of the specific GSS-API mechanism in use, there is no
facility to separate the server from the implementation of the
mechanism as there is with EAP and backend authentication servers.
The goal of this specification is to combine GSS-API's support for
application protocols with EAP/AAA's support for common credential
types and for authenticating to a server without requiring that
server to specifically support the authentication method in use. In
Hartman & Howlett Expires August 21, 2011 [Page 3]
Internet-Draft EAP GSS-API February 2011
addition, this specification supports thearchitecture goal of
transporting attributes about subjects to relying parties. Together
this combination will provide federated authentication and
authorisation for GSS-API applications.
This mechanism is a GSS-API mechanism that encapsulates an EAP
conversation. From the perspective of RFC 3748, this specification
defines a new lower-layer protocol for EAP. From the prospective of
the application, this specification defines a new GSS-API mechanism.
Section 1.3 of [RFC5247] outlines the typical conversation between
EAP peers where an EAP key is derived:
o Phase 0: Discovery
o Phase 1: Authentication
o 1a: EAP authentication
o 1b: AAA Key Transport (optional)
o Phase 2: Secure Association Protocol
o 2a: Unicast Secure Association
o 2b: Multicast Secure Association (optional)
1.1. Discovery
GSS-API peers discover each other and discover support for GSS-API in
an application-dependent mechanism. SASL [RFC4422] describes how
discovery of a particular SASL mechanism such as a GSS-API mechanism
is conducted. The Simple and Protected Negotiation mechanism
(SPNEGO) [RFC4178] provides another approach for discovering what
GSS-API mechanisms are available. The specific approach used for
discovery is out of scope for this mechanism.
1.2. Authentication
GSS-API authenticates a party called the GSS-API initiator to the
GSS-API acceptor, optionally providing authentication of the acceptor
to the initiator. Authentication starts with a mechanism-specific
message called a context token sent from the initiator to the
acceptor. The acceptor may respond, followed by the initiator, and
so on until authentication succeeds or fails. GSS-API context tokens
are reliably delivered by the application using GSS-API. The
application is responsible for in-order delivery and retransmission.
Hartman & Howlett Expires August 21, 2011 [Page 4]
Internet-Draft EAP GSS-API February 2011
EAP authentication can be started by either the peer or the
authenticator, although the first EAP message travels from the
authenticator to the peer. The EAP peer maps onto the GSS-API
initiator. The role of the GSS-API acceptor is split between the EAP
authenticator and the EAP server. When these two entities are
combined, the division resembles GSS-API acceptors in other
mechanisms. When a more typical deployment is used and there is a
passthrough authenticator, most context establishment takes place on
the EAP server and per-message operations take place on the
authenticator. EAP messages from the peer to the authenticator are
called responses; messages from the authenticator to the peer are
called requests.
This specification permits a GSS-API peer to hand-off the processing
of the EAP packets to a remote EAP server by using AAA protocols such
as RADIUS, RadSec or Diameter. In this case, the GSS-API peer acts
as an EAP pass-through authenticator. If EAP authentication is
successful, and where the chosen EAP method supports key derivation,
EAP keying material may also be derived. If an AAA protocol is used,
this can also be used to replicate the EAP Key from the EAP server to
the EAP authenticator.
See Section 5 for details of the authentication exchange.
1.3. Secure Association Protocol
After authentication succeeds, GSS-API provides a number of per-
message security services that can be used:
GSS_Wrap() provides integrity and optional confidentiality for a
message.
GSS_GetMIC() provides integrity protection for data sent
independently of the GSS-API
GSS_Pseudo_random [RFC4401] provides key derivation functionality.
These services perform a function similar to security association
protocols in network access. Like security association protocols,
these services need to be performed near the authenticator/acceptor
even when a AAA protocol is used to separate the authenticator from
the EAP server. The key used for these per-message services is
derived from the EAP key; the EAP peer and authenticator derive this
key as a result of a successful EAP authentication. In the case that
the EAP authenticator is acting as a pass-through it obtains it via
the AAA protocol. See Section 6 for details.
Hartman & Howlett Expires August 21, 2011 [Page 5]
Internet-Draft EAP GSS-API February 2011
2. Requirements notation
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
"SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
document are to be interpreted as described in [RFC2119].
Hartman & Howlett Expires August 21, 2011 [Page 6]
Internet-Draft EAP GSS-API February 2011
3. EAP Channel Binding and Naming
EAP authenticates a realm. The peer knows that it has exchanged
authentication with an EAP server in a given realm. Today, the peer
does not typically know which NAS it is talking to securely. That is
often fine for network access. However privileges to delegate to a
chat server seem very different than privileges for a file server or
trading site. Also, an EAP peer knows the identity of the home
realm, but perhaps not even the visited realm.
In contrast, GSS-API takes a name for both the initiator and acceptor
as inputs to the authentication process. When mutual authentication
is used, both parties are authenticated. The granularity of these
names is somewhat mechanism dependent. In the case of the Kerberos
mechanism, the acceptor name typically identifies both the protocol
in use (such as IMAP) and the specific instance of the service being
connected to. The acceptor name almost always identifies the
administrative domain providing service.
An EAP GSS-API mechanism needs to provide GSS-API naming semantics in
order to work with existing GSS-API applications. EAP channel
binding [I-D.ietf-emu-chbind] is used to provide GSS-API naming
semantics. 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 backend authentication protocol from the authenticator to the
EAP server. The EAP server confirms the consistency of these
attributes. Confirming attribute consistency also involves checking
consistency against a local policy database as discussed below. In
particular, the peer sends the name of the acceptor it is
authenticating to as part of channel binding. The acceptor sends its
full name as part of the backend authentication protocol. The EAP
server confirms consistency of the names.
EAP channel binding is easily confused with a facility in GSS-API
also called channel binding. GSS-API channel binding provides
protection against man-in-the-middle attacks when GSS-API is used as
authentication inside some tunnel; it is similar to a facility called
cryptographic binding in EAP. See [RFC5056] for a discussion of the
differences between these two facilities and Section 6.1 for how GSS-
API channel binding is handled in this mechanism.
3.1. Mechanism Name Format
Before discussing how the initiator and acceptor names are validated
in the AAA infrastructure, it is necessary to discuss what composes a
name for an EAP GSS-API mechanism. GSS-API permits several types of
generic names to be imported using GSS_Import_name(). Once a
Hartman & Howlett Expires August 21, 2011 [Page 7]
Internet-Draft EAP GSS-API February 2011
mechanism is chosen, these names are converted into a mechanism name
form. This section first discusses the mechanism name form and then
discusses what name forms are supported.
The string representation of the GSS-EAP mechanism name has the
following ABNF [RFC5234] representation:
; Define name-string to handle escaping and prevent / and @
empty =
user-or-service = name-string
host = empty/name-string
realm = name-string
service-specific = name-string
service-specifics = service-specific 0*('/' service-specifics)
name = user-or-service '/' host [ '/' service-specifics] [ '@'
realm ]
The user-or-service component is the portion of a network access
identifier (NAI) before the '@' symbol for initiator names and the
service name from the registry of GSS-API host-based services in the
case of acceptor names [GSS-IANA]. The host portion is empty for
initiators and typically contains the domain name of the system on
which an acceptor service is running. Some services MAY require
additional parameters to distinguish the entity being authenticated
against. Such parameters are encoded in the service-specifics
portion of the name. The EAP server MUST reject authentication of
any acceptor name that has a non-empty service-specifics component
unless the EAP server understands the service-specifics and
authenticates them. The interpretation of the service-specifics is
scoped by the user-or-service portion. The realm is the realm
portion of a NAI for initiator names. The realm is the
administrative realm of a service for an acceptor name.
The string representation of this name form is designed to be
generally compatible with the string representation of Kerberos names
defined in [RFC1964].
The GSS_C_NT_USER_NAME form represents the name of an individual
user. From the standpoint of this mechanism it may take the form
either of an undecorated user name or a network access identifier
(NAI) [RFC4282]. The name is split into the part proceeding the
realm which is the user-or-service portion of the mechanism name and
the realm portion which is the realm portion of the mechanism name.
The GSS_C_NT_HOSTBASED_SERVICE name form represents a service running
on a host; it is textually represented as "HOST@SERVICE". This name
form is required by most SASL profiles and is used by many existing
applications that use the Kerberos GSS-API mechanism. While support
Hartman & Howlett Expires August 21, 2011 [Page 8]
Internet-Draft EAP GSS-API February 2011
for this name form is critical, it presents an interesting challenge
in terms of EAP channel binding. Consider a case where the server
communicates with a "server proxy," or a AAA server near the server.
That server proxy communicates with the EAP server. The EAP server
and server proxy are in different administrative realms. The server
proxy is in a position to verify that the request comes from the
indicated host. However the EAP server cannot make this
determination directly. So, the EAP server needs to determine
whether to trust the server proxy to verify the host portion of the
acceptor name. This trust decision depends both on the host name and
the realm of the server proxy. In effect, the EAP server decides
whether to trust that the realm of the server proxy is the right
realm for the given hostname and then makes a trust decision about
the server proxy itself. The same problem appears in Kerberos:
there, clients decide what Kerberos realm to trust for a given
hostname. The service portion of this name is imported into the
user-or-service portion of the mechanism name; the host portion is
imported into the host portion of the mechanism name. The realm
portion is empty. However, authentication will typically fail unless
some AAA component indicates the realm to the EAP server. If the
application server knows its realm, then it should be indicated in
the outgoing AAA request. Otherwise, a proxy SHOULD add the realm.
An alternate form of this name type MAY be used on acceptors; in this
case the name form is "service" with no host component. This is
imported with the service as user-or-service and an empty host and
realm portion. This form is useful when a service is unsure which
name an initiator knows it by.
Sometimes, the client may know what AAA realm a particular host
should belong to. In this case it would be desirable to use a name
form that included a service, host and realm. Syntactically, this
appears the same as the domain-based name discussed in [RFC5178], but
the semantics are not similar enough semantics to use the same name
form.
If the null name type or the GSS_EAP_NT_EAP_NAME (oid XXX) is
imported, then the string representation above should be directly
imported. Mechanisms MAY support the GSS_KRB5_NT_KRB5_PRINCIPAL_NAME
name form with the OID {iso(1) member-body(2) United States(840)
mit(113554) infosys(1) gssapi(2) krb5(2) krb5_name(1)}.
3.2. Exported Mechanism Names
GSS-API provides the GSS_Export_name call. This call can be used to
export the binary representation of a name. This name form can be
stored on access control lists for binary comparison.
The exported name token MUST use the format described in section 3.2
Hartman & Howlett Expires August 21, 2011 [Page 9]
Internet-Draft EAP GSS-API February 2011
of RFC 2743. The mechanism specific portion of this name token is
the string format of the mechanism name described in Section 3.1.
RFC 2744 [RFC2744] places the requirement that the result of
importing a name, canonicalizing it to a mechanism and then exporting
it needs to be the same as importing that name, obtaining credentials
for that principal, initiating a context with those credentials and
exporting the name on the acceptor. In practice, GSS mechanisms
often, but not always meet this requirement. For names expected to
be used as initiator names, this requirement is met. However,
permitting empty host and realm components when importing hostbased
services may make it possible for an imported name to differ from the
exported name actually used. Other mechanisms such as Kerberos have
similar situations where imported and exported names may differ.
3.3. Acceptor Name RADIUS AVP
Currently, GSS-EAP uses a RADIUS vendor-specific attribute for
carrying the acceptor name. The VSA with enterprise ID 25622 is
formatted as a VSA according to the recommendation in the RADIUS
specification. The following sub-attributes are defined:
+-------------------------------+-----------+-----------------------+
| Name | Attribute | Description |
+-------------------------------+-----------+-----------------------+
| GSS-Acceptor-Service-Name | 128 | user-or-service |
| | | portion of name |
| | | |
| GSS-Acceptor-Host-Name | 129 | host portion of name |
| | | |
| GSS-Acceptor-Service-specific | 130 | service-specifics |
| | | portion of name |
| | | |
| GSS-Acceptor-Realm-Name | 131 | Realm portion of name |
+-------------------------------+-----------+-----------------------+
All these items are strings. See Section 3.1 for details of the
values in a name.
If RADIUS is used as an AAA transport, the acceptor MUST send the
acceptor name in the VSA.
If mutual authentication is requested, the initiator MUST require
that the EAP method in use support channel binding and MUST send the
acceptor name as part of the channel binding data. The client MUST
NOT indicate mutual authentication unless all name elements that the
client supplied are in the channel binding response. For example, if
the client supplied a hostname in channel binding data, the hostname
Hartman & Howlett Expires August 21, 2011 [Page 10]
Internet-Draft EAP GSS-API February 2011
MUST be in a successful channel binding response.
3.4. Proxy Verification of Acceptor Name
Hartman & Howlett Expires August 21, 2011 [Page 11]
Internet-Draft EAP GSS-API February 2011
4. Selection of EAP Method
The specification currently describes a single GSS-API mechanism.
The peer and authenticator exchange EAP messages. The GSS-API
mechanism specifies no constraints about what EAP method types are
used; text in the specification says that negotiation of which EAP
method to use happens at the EAP layer.
EAP does not provide a facility for an EAP server to advertise what
methods are available to a peer. Instead, a server starts with its
preferred method selection. If the peer does not accept that method,
the peer sends a NAK response containing the list of methods
supported by the client.
Providing multiple facilities to negotiate which security mechanism
to use is undesirable. Section 7.3 of [RFC4462]describes the problem
referencing the SSH key exchange negotiation and the SPNEGO GSS-API
mechanism. If a client preferred an EAP method A, a non-EAP
authentication mechanism B, and then an EAP method C, then the client
would have to commit to using EAP before learning whether A is
actually supported. Such a client might end up using C when B is
available.
The standard solution to this problem is to perform all the
negotiation at one layer. In this case, rather than defining a
single GSS-API mechanism, a family of mechanisms should be defined.
Each mechanism corresponds to an EAP method. The EAP method type
should be part of the GSS-API OID. Then, a GSS-API rather than EAP
facility can be used for negotiation.
Unfortunately, using a family of mechanisms has a number of problems.
First, GSS-API assumes that both the initiator and acceptor know the
entire set of mechanisms that are available. Some negotiation
mechanisms are driven by the client; others are driven by the server.
With EAP GSS-API, the acceptor does not know what methods the EAP
server implements. The EAP server that is used depends on the
identity of the client. The best solution so far is to accept the
disadvantages of multi-layer negotiation and commit to using EAP GSS-
API before a specific EAP method. This has two main disadvantages.
First, authentication may fail when other methods might allow
authentication to succeed. Second, a non-optimal security mechanism
may be chosen.
Hartman & Howlett Expires August 21, 2011 [Page 12]
Internet-Draft EAP GSS-API February 2011
5. Context Tokens
All context establishment tokens emitted by the EAP mechanism SHALL
have the framing described in section 3.1 of [RFC2743], as
illustrated by the following pseudo-ASN.1 structures:
GSS-API DEFINITIONS ::=
BEGIN
MechType ::= OBJECT IDENTIFIER
-- representing EAP mechanism
GSSAPI-Token ::=
-- option indication (delegation, etc.) indicated within
-- mechanism-specific token
[APPLICATION 0] IMPLICIT SEQUENCE {
thisMech MechType,
innerToken ANY DEFINED BY thisMech
-- contents mechanism-specific
-- ASN.1 structure not required
}
END
The innerToken field contains an EAP packet or special token. The
first EAP packet SHALL be a EAP response/identity packet from the
initiator to acceptor. The acceptor SHALL respond either with an EAP
request or an EAP failure packet.
The initiator and acceptor will continue exchanging response/request
packets until authentication succeeds or fails.
After the EAP authentication succeeds, channel binding tokens are
exchanged; see Section 6.1 for details. Currently, the channel
binding tokens are the only types of special tokens in use.
5.1. Mechanisms and Encryption Types
This mechanism family uses the security services of the Kerberos
cryptographic framework [RFC3961]. As such, a particular encryption
type needs to be chosen. A new GSS-API OID should be defined for EAP
GSS-API with a given Kerberos crypto system. This document defines
the eap-aes128-cts-hmac-sha1-96 GSS-API mechanism. XXX define an OID
for that and use the right language to get that into the appropriate
SASL registry.
5.2. Context Options
GSS-API provides a number of optional per-context services requested
by flags on the call to GSS_Init_sec_context and indicated as outputs
Hartman & Howlett Expires August 21, 2011 [Page 13]
Internet-Draft EAP GSS-API February 2011
from both GSS_Init_sec_context and GSS_Accept_sec_context. This
section describes how these services are handled. Which services the
client selects in the call to GSS_Init_sec_context controls what EAP
methods MAY be used by the client. Section 7.2 of RFC 3748 describes
a set of security claims for EAP. As described below, the selected
GSS options place requirements on security claims that MUST be met.
This GSS mechanism MUST only be used with EAP methods that provide
dictionary attack resistance.
Whenever one of Integrity, confidentiality, sequencing or replay
detection is requested, the EAP method MUST support key derivation.
Whenever key derivation is supported, all of these services MUST be
indicated in the output to GSS_Init_sec_context and
GSS_Accept_sec_context regardless of which services were requested.
The PROT_READY service is never available with this mechanism.
Implementations MUST NOT offer this flag or permit per-message
security services to be used before context establishment.
When mutual authentication is requested, the EAP method MUST support
mutual authentication and channel binding. See Section 3.3 for
details on what is required for successful mutual authentication.
Open issue: handling of lifetime parameters.
Hartman & Howlett Expires August 21, 2011 [Page 14]
Internet-Draft EAP GSS-API February 2011
6. Acceptor Services
The context establishment process may be passed through to a EAP
server via a backend authentication protocol. However after the EAP
authentication succeeds, security services are provided directly by
the acceptor.
This mechanism uses an RFC 3961 cryptographic key called the context
root key (CRK). The CRK is derived from the GMSK (GSS-API MSK). The
GMSK is the result of the random-to-key [RFC3961] operation consuming
the appropriate number of bits from the EAP master session key. For
example for aes128-cts-hmac-sha1-96, the random-to-key operation
consumes 16 octets of key material; thus the first 16 bytes of the
master session key are input to random-to-key to form the GMSK.
The CRK is derived from the GMSK using the following procedur
Tn = pseudo-random(KMSK, n || "rfc4121-gss-eap")
CRK = truncate(L, T1 || T2 || .. || Tn)
L = output RFC 3961 key size
6.1. GSS-API Channel Binding
GSS-API channel binding [RFC5554] is a protected facility for
exchanging a cryptographic name for an enclosing channel between the
initiator and acceptor. The initiator sends channel binding data and
the acceptor confirms that channel binding data has been checked.
The acceptor SHOULD accept any channel binding providing by the
initiator if null channel bindings are passed into
gss_accept_sec_context. Protocols such as HTTP Negotiate depend on
this behavior of some Kerberos implementations. It is reasonable for
the protocol to distinguish an acceptor ignoring channel bindings
from an acceptor successfully validating them. No facility is
currently provided for an initiator implementation to expose this
distinction to the initiator code.
In this mechanism an extension option of type 0 with the critical bit
set is sent from the initiator to the acceptor. This option contains
a GSS_Wrap token of the channel binding data passed into
GSS_Init_sec_context.
6.2. Per-message security
The per-message tokens of section 4 of RFC 4121 are used. The CRK
SHALL be treated as the initiator sub-session key, the acceptor sub-
session key and the ticket session key.
Hartman & Howlett Expires August 21, 2011 [Page 15]
Internet-Draft EAP GSS-API February 2011
6.3. Pseudo Random Function
The pseudo random function defined in [RFC4402] is used.
Hartman & Howlett Expires August 21, 2011 [Page 16]
Internet-Draft EAP GSS-API February 2011
7. Open Mechanism Issues
o The extension tokens
o Server name indication
o Empty target name
o Context token format description not right
Hartman & Howlett Expires August 21, 2011 [Page 17]
Internet-Draft EAP GSS-API February 2011
8. Applicability Considerations
Section 1.3 of RFC 3748 provides the applicability statement for EAP.
Among other constraints, EAP is scoped for use in network access.
This specification anticipates using EAP beyond its current scope.
The assumption is that some other document will discuss the issues
surrounding the use of EAP for application authentication and expand
EAP's applicability. That document will likely enumerate
considerations that a specific use of EAP for application
authentication needs to handle. Examples of such considerations
might include the multi-layer negotiation issue, deciding when EAP or
some other mechanism should be used, and so forth. This section
serves as a placeholder to discuss any such issues with regard to the
use of EAP and GSS-API.
Hartman & Howlett Expires August 21, 2011 [Page 18]
Internet-Draft EAP GSS-API February 2011
9. Security Considerations
RFC 3748 discusses security issues surrounding EAP. RFC 5247
discusses the security and requirements surrounding key management
that leverages the AAA infrastructure. These documents are critical
to the security analysis of this mechanism.
RFC 2743 discusses generic security considerations for the GSS-API.
RFC 4121 discusses security issues surrounding the specific per-
message services used in this mechanism.
As discussed in Section 4, this mechanism may introduce multiple
layers of security negotiation into application protocols. Multiple
layer negotiations are vulnerable to a bid-down attack when a
mechanism negotiated at the outer layer is preferred to some but not
all mechanisms negotiated at the inner layer; see section 7.3 of
[RFC4462] for an example. One possible approach to mitigate this
attack is to construct security policy such that the preference for
all mechanisms negotiated in the inner layer falls between
preferences for two outer layer mechanisms or falls at one end of the
overall ranked preferences including both the inner and outer layer.
Another approach is to only use this mechanism when it has
specifically been selected for a given service. The second approach
is likely to be common in practice because one common deployment will
involved an EAP supplicant interacting with a user to select a given
identity. Only when an identity is successfully chosen by the user
will this mechanism be attempted.
The security of this mechanism depends on the use and verification of
EAP channel binding. Today EAP channel binding is in very limited
deployment. If EAP channel binding is not used, then the system may
be vulnerable to phishing attacks where a user is diverted from one
service to another. These attacks are possible with EAP today
although not typically with common GSS-API mechanisms.
Every proxy in the AAA chain from the authenticator to the EAP server
needs to be trusted to help verify channel bindings and to protect
the integrity of key material. GSS-API applications may be built to
assume a trust model where the acceptor is directly responsible for
authentication. However, GSS-API is definitely used with trusted-
third-party mechanisms such as Kerberos.
Hartman & Howlett Expires August 21, 2011 [Page 19]
Internet-Draft EAP GSS-API February 2011
10. References
10.1. Normative References
[GSS-IANA]
IANA, "GSS-API Service Name Registry", <http://
www.iana.org/assignments/gssapi-service-names/
gssapi-service-names.xhtml>.
[I-D.ietf-emu-chbind]
Hartman, S., Clancy, C., and K. Hoeper, "Channel Binding
Support for EAP Methods", draft-ietf-emu-chbind-07 (work
in progress), February 2011.
[RFC2119] Bradner, S., "Key words for use in RFCs to Indicate
Requirement Levels", BCP 14, RFC 2119, March 1997.
[RFC2743] Linn, J., "Generic Security Service Application Program
Interface Version 2, Update 1", RFC 2743, January 2000.
[RFC2744] Wray, J., "Generic Security Service API Version 2 :
C-bindings", RFC 2744, January 2000.
[RFC3748] Aboba, B., Blunk, L., Vollbrecht, J., Carlson, J., and H.
Levkowetz, "Extensible Authentication Protocol (EAP)",
RFC 3748, June 2004.
[RFC3961] Raeburn, K., "Encryption and Checksum Specifications for
Kerberos 5", RFC 3961, February 2005.
[RFC4121] Zhu, L., Jaganathan, K., and S. Hartman, "The Kerberos
Version 5 Generic Security Service Application Program
Interface (GSS-API) Mechanism: Version 2", RFC 4121,
July 2005.
[RFC4282] Aboba, B., Beadles, M., Arkko, J., and P. Eronen, "The
Network Access Identifier", RFC 4282, December 2005.
[RFC4401] Williams, N., "A Pseudo-Random Function (PRF) API
Extension for the Generic Security Service Application
Program Interface (GSS-API)", RFC 4401, February 2006.
[RFC4402] Williams, N., "A Pseudo-Random Function (PRF) for the
Kerberos V Generic Security Service Application Program
Interface (GSS-API) Mechanism", RFC 4402, February 2006.
[RFC5056] Williams, N., "On the Use of Channel Bindings to Secure
Channels", RFC 5056, November 2007.
Hartman & Howlett Expires August 21, 2011 [Page 20]
Internet-Draft EAP GSS-API February 2011
[RFC5234] Crocker, D. and P. Overell, "Augmented BNF for Syntax
Specifications: ABNF", STD 68, RFC 5234, January 2008.
[RFC5554] Williams, N., "Clarifications and Extensions to the
Generic Security Service Application Program Interface
(GSS-API) for the Use of Channel Bindings", RFC 5554,
May 2009.
10.2. Informative References
[I-D.lear-abfab-arch]
Howlett, J., Hartman, S., Tschofenig, H., and E. Lear,
"Application Bridging for Federated Access Beyond Web
(ABFAB) Architecture", draft-lear-abfab-arch-01 (work in
progress), December 2010.
[RFC1964] Linn, J., "The Kerberos Version 5 GSS-API Mechanism",
RFC 1964, June 1996.
[RFC3579] Aboba, B. and P. Calhoun, "RADIUS (Remote Authentication
Dial In User Service) Support For Extensible
Authentication Protocol (EAP)", RFC 3579, September 2003.
[RFC4072] Eronen, P., Hiller, T., and G. Zorn, "Diameter Extensible
Authentication Protocol (EAP) Application", RFC 4072,
August 2005.
[RFC4178] Zhu, L., Leach, P., Jaganathan, K., and W. Ingersoll, "The
Simple and Protected Generic Security Service Application
Program Interface (GSS-API) Negotiation Mechanism",
RFC 4178, October 2005.
[RFC4422] Melnikov, A. and K. Zeilenga, "Simple Authentication and
Security Layer (SASL)", RFC 4422, June 2006.
[RFC4462] Hutzelman, J., Salowey, J., Galbraith, J., and V. Welch,
"Generic Security Service Application Program Interface
(GSS-API) Authentication and Key Exchange for the Secure
Shell (SSH) Protocol", RFC 4462, May 2006.
[RFC5178] Williams, N. and A. Melnikov, "Generic Security Service
Application Program Interface (GSS-API)
Internationalization and Domain-Based Service Names and
Name Type", RFC 5178, May 2008.
[RFC5247] Aboba, B., Simon, D., and P. Eronen, "Extensible
Authentication Protocol (EAP) Key Management Framework",
RFC 5247, August 2008.
Hartman & Howlett Expires August 21, 2011 [Page 21]
Internet-Draft EAP GSS-API February 2011
Authors' Addresses
Sam Hartman (editor)
Painless Security
Email: hartmans-ietf@mit.edu
Josh Howlett
JANET(UK)
Email: josh.howlett@ja.net
Hartman & Howlett Expires August 21, 2011 [Page 22]
