GSS-API store cred: Generic Security Service Application Program Interface (GSS-API) Extension for Storing Delegated Credentials
A GSS-API function that saves delegated credentials into the normal credential store so ordinary calls can use them.
Williams, N., "Generic Security Service Application Program Interface (GSS-API) Extension for Storing Delegated Credentials", RFC 5588, DOI 10.17487/RFC5588, July 2009, <https://www.rfc-editor.org/info/rfc5588>.
@misc{rfc5588,
series = {Request for Comments},
number = 5588,
howpublished = {RFC 5588},
publisher = {RFC Editor},
doi = {10.17487/RFC5588},
url = {https://www.rfc-editor.org/info/rfc5588},
author = {N. Williams},
title = {{Generic Security Service Application Program Interface (GSS-API) Extension for Storing Delegated Credentials}},
pagetotal = 7,
year = 2009,
month = jul,
} RFC text
Contents
Network Working Group N. Williams
Request for Comments: 5588 Sun
Category: Standards Track July 2009
Generic Security Service Application Program Interface (GSS-API)
Extension for Storing Delegated Credentials
Abstract
This document defines a new function for the Generic Security Service
Application Program Interface (GSS-API), which allows applications to
store delegated (and other) credentials in the implicit GSS-API
credential store. This is needed for GSS-API applications to use
delegated credentials as they would use other credentials.
Status of This Memo
This document specifies an Internet standards track protocol for the
Internet community, and requests discussion and suggestions for
improvements. Please refer to the current edition of the "Internet
Official Protocol Standards" (STD 1) for the standardization state
and status of this protocol. Distribution of this memo is unlimited.
Copyright Notice
Copyright (c) 2009 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 in effect on the date of
publication of this document (http://trustee.ietf.org/license-info).
Please review these documents carefully, as they describe your rights
and restrictions with respect to this document.
Table of Contents
1. Introduction ....................................................2
2. Conventions Used in This Document ...............................3
3. GSS_Store_cred() ................................................3
4. C-Bindings ......................................................5
5. Examples ........................................................6
6. Security Considerations .........................................6
7. Normative References ............................................7
1. Introduction
The GSS-API [RFC2743] clearly assumes that credentials exist in an
implicit store whence they can be acquired using GSS_Acquire_cred()
and GSS_Add_cred() or through use of the default credential.
Multiple credential stores may exist on a given host, but only one
store may be accessed by GSS_Acquire_cred() and GSS_Add_cred() at any
given time.
This assumption can be seen in Sections 1.1.1.2 and 1.1.1.3 of
[RFC2743] as well as in Section 3.5 of [RFC2744].
Applications may be able to change the credential store from which
credentials can be acquired, either by changing user contexts (where
the applications have the privilege to do so) or by other means
(where a user may have multiple credential stores).
Some GSS-API acceptor applications always change user contexts, after
accepting a GSS-API security context and making appropriate
authorization checks, to the user context corresponding to the
initiator principal name or to a context requested by the initiator.
The means by which credential stores are managed are generally beyond
the scope of the GSS-API.
In the case of delegated credential handles however, such credentials
do not exist in the acceptor's credential store or in the credential
stores of the user contexts to which the acceptor application might
change. The GSS-API provides no mechanism by which delegated
credential handles can be made available for acquisition through
GSS_Acquire_cred()/GSS_Add_cred(). The GSS-API also does not provide
any credential import/export interfaces like the GSS-API context
import/export interfaces.
Thus, acceptors are limited to making only direct use of delegated
credential handles and only with GSS_Init_sec_context(),
GSS_Inquire_cred*(), and GSS_Release_cred(). This limitation is
particularly onerous on Unix systems where a call to exec() to
replace the process image obliterates any delegated credentials
handle that may exist in that process.
In order to make delegated credentials generally as useful as
credentials that can be acquired with GSS_Acquire_cred() and
GSS_Add_cred(), a primitive is needed that allows storing of
credentials in the implicit credential store. We call this primitive
"GSS_Store_cred()".
2. Conventions Used in This Document
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].
3. GSS_Store_cred()
Inputs:
o input_cred_handle CREDENTIAL HANDLE, -- credential to store; MUST
NOT be GSS_C_NO_CREDENTIAL.
o cred_usage INTEGER -- 0=INITIATE-AND-ACCEPT, 1=INITIATE-ONLY,
2=ACCEPT-ONLY.
o desired_mech_element OBJECT IDENTIFIER, -- if GSS_C_NULL_OID, then
store all the elements of the input_cred_handle, otherwise, store
only the element of the corresponding mechanism.
o overwrite_cred BOOLEAN, -- if TRUE, replace any credential for the
same principal in the credential store.
o default_cred BOOLEAN -- advisory input; if TRUE, make the stored
credential available as the default credential (for acquisition
with GSS_C_NO_NAME as the desired name or for use as
GSS_C_NO_CREDENTIAL).
Outputs:
o major_status INTEGER.
o minor_status INTEGER.
o mech_elements_stored SET OF OBJECT IDENTIFIER, -- the set of
mechanism OIDs for which credential elements were successfully
stored.
o cred_usage_stored INTEGER -- like cred_usage, but indicates what
kind of credential was stored (useful when the cred_usage input
parameter is set to INITIATE-AND-ACCEPT).
Return major_status codes:
o GSS_S_COMPLETE indicates that the credentials were successfully
stored.
o GSS_S_CREDENTIALS_EXPIRED indicates that the input credentials had
expired or expired before they could be stored.
o GSS_S_NO_CRED indicates that no input credentials were given.
o GSS_S_UNAVAILABLE indicates that the credential store is not
available.
o GSS_S_DUPLICATE_ELEMENT indicates that an element of the input
credential could not be stored because a credential for the same
principal exists in the current credential store and the
overwrite_cred input argument was FALSE.
o GSS_S_FAILURE indicates that the credential could not be stored
for some other reason. The minor status code may provide more
information if a non-GSS_C_NULL_OID desired_mech_element was
given.
GSS_Store_cred() is used to store, in the current credential store, a
given credential that has either been acquired from a different
credential store or been accepted as a delegated credential.
Specific mechanism elements of a credential can be stored one at a
time by specifying a non-GSS_C_NULL_OID mechanism OID as the
desired_mech_element input argument; in which case, the minor status
output SHOULD have a mechanism-specific value when the major status
is not GSS_S_COMPLETE.
The initiator, acceptor, or both usages of the input credential may
be stored as per the cred_usage input argument.
The credential elements that were actually stored, when the major
status is GSS_S_COMPLETE, are indicated through the cred_usage_stored
and mech_elements_stored function outputs.
If credentials already exist in the current store for the principal
of the input_cred_handle, then those credentials are not replaced
with the input credentials unless the overwrite_cred input argument
is TRUE.
In the GSS-API, the default credential can be used by using
GSS_C_NO_CREDENTIAL or a CREDENTIAL handle acquired by calling
GSS_Acquire_cred() or GSS_Add_cred() with the desired_name input set
to GSS_C_NO_NAME.
If the default_cred input argument is TRUE, and the input credential
can be successfully stored, then the input credential SHOULD be
stored as the default credential (see above).
If the current credential store has no default credential (see
above), then the implementation MAY make the stored credentials
available as the default credential regardless of the value of the
default_cred input argument.
4. C-Bindings
The C-Bindings for GSS_Store_cred() make use of types from and are
designed based on the style of the GSS-APIv2 C-Bindings [RFC2744].
OM_uint32 gss_store_cred(
OM_uint32 *minor_status,
gss_cred_id_t input_cred_handle,
gss_cred_usage_t cred_usage,
const gss_OID desired_mech,
OM_uint32 overwrite_cred,
OM_uint32 default_cred,
gss_OID_set *elements_stored,
gss_cred_usage_t *cred_usage_stored)
Figure 1
The two boolean arguments, 'overwrite_cred' and 'default_cred', are
typed as OM_uint32; 0 corresponds to FALSE, non-zero values
correspond to TRUE.
5. Examples
The intended usage of GSS_Store_cred() is to make delegated
credentials available to child processes of GSS-API acceptor
applications. Example pseudo-code:
/*
* <GSS_Accept_sec_context() loop resulting in GSS_S_COMPLETE,
* an initiator name (hereafter, "src_name") and a delegated
* credential handle (hereafter "deleg_cred").>
*
* <"requested_username" is a username derived from the
* initiator name or explicitly requested by the initiator
* application.>
*/
...
if (authorize_gss_client(src_name, requested_username)) {
/*
* For Unix-type platforms this may mean calling setuid() and
* it may or may not also mean setting/unsetting such
* environment variables as KRB5CCNAME and what not -- all
* OS-specific details.
*/
if (change_user_context(requested_username))
(void) gss_store_cred(&minor_status, deleg_cred,
GSS_C_INITIATE, actual_mech,
0, 1, NULL, NULL);
}
else ...
}
else ...
6. Security Considerations
Acceptor applications MUST only store delegated credentials into
appropriate credential stores and only after proper authorization of
the authenticated initiator principal to the requested service(s).
Acceptor applications that have no use for delegated credentials MUST
release them (such acceptor applications that use the GSS-API C-
Bindings may simply provide a NULL value for the
delegated_cred_handle argument to gss_accept_sec_context()).
7. Normative References
[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.
Author's Address
Nicolas Williams
Sun Microsystems
5300 Riata Trace Ct
Austin, TX 78727
US
EMail: Nicolas.Williams@sun.com
AI ELI5
On this page
§1The Problem with Delegated Credentials
The GSS-API (RFC 2743) assumes that credentials live in an implicit credential store. Applications get them out with GSS_Acquire_cred() and GSS_Add_cred(), or by using the default credential. Several stores may exist on one host, but only one can be reached by those calls at any given time.
A delegated credential is not in the acceptor's store, nor in the stores of the user contexts the acceptor may switch to. The GSS-API gives no way to make a delegated credential handle available to GSS_Acquire_cred(), and it has no credential import or export calls.
So an acceptor can only use a delegated handle directly, and only with GSS_Init_sec_context(), GSS_Inquire_cred*() and GSS_Release_cred(). The RFC calls this especially onerous on Unix, where a call to exec() replaces the process image and destroys any delegated credential handle held in the process.
Imagine a borrowed key card that only works while you hold it in your hand. The moment you change rooms, it vanishes. That is the problem this solves.
§3What GSS_Store_cred() Does
GSS_Store_cred() stores, in the current credential store, a credential that was either acquired from a different store or accepted as a delegated credential. The text says it makes delegated credentials generally as useful as credentials from GSS_Acquire_cred() and GSS_Add_cred().
A caller can store one mechanism element at a time by naming a mechanism OID. When the major status is not GSS_S_COMPLETE in that case, the minor status SHOULD carry a mechanism-specific value. Initiator usage, acceptor usage or both can be stored, as chosen by the cred_usage input.
On success, the outputs cred_usage_stored and mech_elements_stored tell the caller what was actually stored.
It is like a coat check for borrowed keys. You hand the key over once, and later any door in the building can find it.
§3.1Inputs and Outputs
The function takes five inputs:
input_cred_handle: the credential to store. It MUST NOT beGSS_C_NO_CREDENTIAL.cred_usage: 0 for initiate-and-accept, 1 for initiate-only, 2 for accept-only.desired_mech_element: ifGSS_C_NULL_OID, all elements of the credential are stored; otherwise only the element for that mechanism.overwrite_cred: if TRUE, replace any credential for the same principal in the store. Without it, existing credentials are not replaced.default_cred: advisory. If TRUE, the stored credential SHOULD be made the default credential.
If the store has no default credential, the implementation MAY make the stored credential the default whatever default_cred says. The outputs are major_status, minor_status, mech_elements_stored and cred_usage_stored. The last one is useful when the input usage was initiate-and-accept.
You tell the coat check which key, what it opens, whether to swap out an older key of yours, and whether it should be your main key.
§3.2Return Codes
The function reports its result through these major status codes:
GSS_S_COMPLETE: the credentials were stored.GSS_S_CREDENTIALS_EXPIRED: the input credentials had expired, or expired before they could be stored.GSS_S_NO_CRED: no input credentials were given.GSS_S_UNAVAILABLE: the credential store is not available.GSS_S_DUPLICATE_ELEMENT: an element could not be stored because a credential for the same principal exists andoverwrite_credwas FALSE.GSS_S_FAILURE: the credential could not be stored for some other reason.
The coat check answers with one of a few replies: done, your key is too old, you gave me nothing, the closet is closed, you already have a key here, or something else went wrong.
§4C Bindings
The C binding follows the style of the GSS-APIv2 C bindings (RFC 2744) and is named gss_store_cred. The two booleans, overwrite_cred and default_cred, are typed as OM_uint32: 0 means FALSE and any non-zero value means TRUE.
For programmers using C, the function has a fixed shape, and yes or no answers are written as zero or not zero.
OM_uint32 gss_store_cred(
OM_uint32 *minor_status,
gss_cred_id_t input_cred_handle,
gss_cred_usage_t cred_usage,
const gss_OID desired_mech,
OM_uint32 overwrite_cred,
OM_uint32 default_cred,
gss_OID_set *elements_stored,
gss_cred_usage_t *cred_usage_stored)§5Intended Use
The intended use is to make delegated credentials available to child processes of GSS-API acceptor applications. In the RFC's pseudo-code, the acceptor finishes a GSS_Accept_sec_context() loop and gets an initiator name and a delegated credential handle. It then checks that the client is authorized for a requested username and changes the user context. On Unix-type platforms that may mean calling setuid(). Finally it calls gss_store_cred() with the delegated handle.
A visitor lends a server a key. The server first checks the visitor is allowed in, then puts the key where the server's helpers can find it.
§6Security Considerations
Acceptor applications MUST only store delegated credentials into appropriate credential stores, and only after proper authorization of the authenticated initiator principal to the requested services.
Acceptors that have no use for delegated credentials MUST release them. Acceptors using the C bindings can simply pass a NULL value for the delegated_cred_handle argument to gss_accept_sec_context().
Only keep a borrowed key after you have checked the visitor is allowed in, and hand back keys you do not need.