7
Network Working Group J. Wray
8
Request for Comments: 1509 Digital Equipment Corporation
12
Generic Security Service API : C-bindings
16
This RFC specifies an Internet standards track protocol for the
17
Internet community, and requests discussion and suggestions for
18
improvements. Please refer to the current edition of the "Internet
19
Official Protocol Standards" for the standardization state and status
20
of this protocol. Distribution of this memo is unlimited.
24
This document specifies C language bindings for the Generic Security
25
Service Application Program Interface (GSS-API), which is described
26
at a language-independent conceptual level in other documents.
28
The Generic Security Service Application Programming Interface (GSS-
29
API) provides security services to its callers, and is intended for
30
implementation atop alternative underlying cryptographic mechanisms.
31
Typically, GSS-API callers will be application protocols into which
32
security enhancements are integrated through invocation of services
33
provided by the GSS-API. The GSS-API allows a caller application to
34
authenticate a principal identity associated with a peer application,
35
to delegate rights to a peer, and to apply security services such as
36
confidentiality and integrity on a per-message basis.
40
The Generic Security Service Application Programming Interface [1]
41
provides security services to calling applications. It allows a
42
communicating application to authenticate the user associated with
43
another application, to delegate rights to another application, and
44
to apply security services such as confidentiality and integrity on a
47
There are four stages to using the GSSAPI:
49
(a) The application acquires a set of credentials with which it may
50
prove its identity to other processes. The application's
51
credentials vouch for its global identity, which may or may not
52
be related to the local username under which it is running.
60
RFC 1509 GSSAPI - Overview and C bindings September 1993
63
(b) A pair of communicating applications establish a joint security
64
context using their credentials. The security context is a
65
pair of GSSAPI data structures that contain shared state
66
information, which is required in order that per-message
67
security services may be provided. As part of the
68
establishment of a security context, the context initiator is
69
authenticated to the responder, and may require that the
70
responder is authenticated in turn. The initiator may
71
optionally give the responder the right to initiate further
72
security contexts. This transfer of rights is termed
73
delegation, and is achieved by creating a set of credentials,
74
similar to those used by the originating application, but which
75
may be used by the responder. To establish and maintain the
76
shared information that makes up the security context, certain
77
GSSAPI calls will return a token data structure, which is a
78
cryptographically protected opaque data type. The caller of
79
such a GSSAPI routine is responsible for transferring the token
80
to the peer application, which should then pass it to a
81
corresponding GSSAPI routine which will decode it and extract
84
(c) Per-message services are invoked to apply either:
86
(i) integrity and data origin authentication, or
88
(ii) confidentiality, integrity and data origin authentication
89
to application data, which are treated by GSSAPI as
90
arbitrary octet-strings. The application transmitting a
91
message that it wishes to protect will call the appropriate
92
GSSAPI routine (sign or seal) to apply protection, specifying
93
the appropriate security context, and send the result to the
94
receiving application. The receiver will pass the received
95
data to the corresponding decoding routine (verify or unseal)
96
to remove the protection and validate the data.
98
(d) At the completion of a communications session (which may extend
99
across several connections), the peer applications call GSSAPI
100
routines to delete the security context. Multiple contexts may
101
also be used (either successively or simultaneously) within a
102
single communications association.
106
This section lists the functions performed by each of the GSSAPI
107
routines and discusses their major parameters, describing how they
108
are to be passed to the routines. The routines are listed in figure
116
RFC 1509 GSSAPI - Overview and C bindings September 1993
119
Figure 4-1 GSSAPI Routines
124
gss_acquire_cred Assume a global identity
126
gss_release_cred Discard credentials
128
gss_init_sec_context Initiate a security context
129
with a peer application
131
gss_accept_sec_context Accept a security context
135
gss_process_context_token Process a token on a security
139
gss_delete_sec_context Discard a security context
141
gss_context_time Determine for how long a
142
context will remain valid
144
gss_sign Sign a message; integrity
147
gss_verify Check signature on a message
149
gss_seal Sign (optionally encrypt) a
150
message; confidentiality
153
gss_unseal Verify (optionally decrypt)
156
gss_display_status Convert an API status code
159
gss_indicate_mechs Determine underlying
160
authentication mechanism
162
gss_compare_name Compare two internal-form
165
gss_display_name Convert opaque name to text
172
RFC 1509 GSSAPI - Overview and C bindings September 1993
175
gss_import_name Convert a textual name to
178
gss_release_name Discard an internal-form
181
gss_release_buffer Discard a buffer
183
gss_release_oid_set Discard a set of object
186
gss_inquire_cred Determine information about
189
Individual GSSAPI implementations may augment these routines by
190
providing additional mechanism-specific routines if required
191
functionality is not available from the generic forms. Applications
192
are encouraged to use the generic routines wherever possible on
195
2.1. Data Types and Calling Conventions
197
The following conventions are used by the GSSAPI:
199
2.1.1. Structured data types
201
Wherever these GSSAPI C-bindings describe structured data, only
202
fields that must be provided by all GSSAPI implementation are
203
documented. Individual implementations may provide additional
204
fields, either for internal use within GSSAPI routines, or for use by
205
non-portable applications.
209
GSSAPI defines the following integer data type:
211
OM_uint32 32-bit unsigned integer
213
Where guaranteed minimum bit-count is important, this portable data
214
type is used by the GSSAPI routine definitions. Individual GSSAPI
215
implementations will include appropriate typedef definitions to map
216
this type onto a built-in data type.
218
2.1.3. String and similar data
220
Many of the GSSAPI routines take arguments and return values that
221
describe contiguous multiple-byte data. All such data is passed
222
between the GSSAPI and the caller using the gss_buffer_t data type.
228
RFC 1509 GSSAPI - Overview and C bindings September 1993
231
This data type is a pointer to a buffer descriptor, which consists of
232
a length field that contains the total number of bytes in the datum,
233
and a value field which contains a pointer to the actual datum:
235
typedef struct gss_buffer_desc_struct {
238
} gss_buffer_desc, *gss_buffer_t;
240
Storage for data passed to the application by a GSSAPI routine using
241
the gss_buffer_t conventions is allocated by the GSSAPI routine. The
242
application may free this storage by invoking the gss_release_buffer
243
routine. Allocation of the gss_buffer_desc object is always the
244
responsibility of the application; Unused gss_buffer_desc objects
245
may be initialized to the value GSS_C_EMPTY_BUFFER.
247
2.1.3.1. Opaque data types
249
Certain multiple-word data items are considered opaque data types at
250
the GSSAPI, because their internal structure has no significance
251
either to the GSSAPI or to the caller. Examples of such opaque data
252
types are the input_token parameter to gss_init_sec_context (which is
253
opaque to the caller), and the input_message parameter to gss_seal
254
(which is opaque to the GSSAPI). Opaque data is passed between the
255
GSSAPI and the application using the gss_buffer_t datatype.
257
2.1.3.2. Character strings
259
Certain multiple-word data items may be regarded as simple ISO
260
Latin-1 character strings. An example of this is the
261
input_name_buffer parameter to gss_import_name. Some GSSAPI routines
262
also return character strings. Character strings are passed between
263
the application and the GSSAPI using the gss_buffer_t datatype,
266
2.1.4. Object Identifiers
268
Certain GSSAPI procedures take parameters of the type gss_OID, or
269
Object identifier. This is a type containing ISO-defined tree-
270
structured values, and is used by the GSSAPI caller to select an
271
underlying security mechanism. A value of type gss_OID has the
274
typedef struct gss_OID_desc_struct {
277
} gss_OID_desc, *gss_OID;
284
RFC 1509 GSSAPI - Overview and C bindings September 1993
287
The elements field of this structure points to the first byte of an
288
octet string containing the ASN.1 BER encoding of the value of the
289
gss_OID. The length field contains the number of bytes in this
290
value. For example, the gss_OID value corresponding to {iso(1)
291
identified- oganization(3) icd-ecma(12) member-company(2) dec(1011)
292
cryptoAlgorithms(7) SPX(5)} meaning SPX (Digital's X.509
293
authentication mechanism) has a length field of 7 and an elements
294
field pointing to seven octets containing the following octal values:
295
53,14,2,207,163,7,5. GSSAPI implementations should provide constant
296
gss_OID values to allow callers to request any supported mechanism,
297
although applications are encouraged on portability grounds to accept
298
the default mechanism. gss_OID values should also be provided to
299
allow applications to specify particular name types (see section
300
2.1.10). Applications should treat gss_OID_desc values returned by
301
GSSAPI routines as read-only. In particular, the application should
302
not attempt to deallocate them. The gss_OID_desc datatype is
303
equivalent to the X/Open OM_object_identifier datatype [2].
305
2.1.5. Object Identifier Sets
307
Certain GSSAPI procedures take parameters of the type gss_OID_set.
308
This type represents one or more object identifiers (section 2.1.4).
309
A gss_OID_set object has the following structure:
311
typedef struct gss_OID_set_desc_struct {
314
} gss_OID_set_desc, *gss_OID_set;
316
The count field contains the number of OIDs within the set. The
317
elements field is a pointer to an array of gss_OID_desc objects, each
318
of which describes a single OID. gss_OID_set values are used to name
319
the available mechanisms supported by the GSSAPI, to request the use
320
of specific mechanisms, and to indicate which mechanisms a given
321
credential supports. Storage associated with gss_OID_set values
322
returned to the application by the GSSAPI may be deallocated by the
323
gss_release_oid_set routine.
327
A credential handle is a caller-opaque atomic datum that identifies a
328
GSSAPI credential data structure. It is represented by the caller-
329
opaque type gss_cred_id_t, which may be implemented as either an
330
arithmetic or a pointer type. Credentials describe a principal, and
331
they give their holder the ability to act as that principal. The
332
GSSAPI does not make the actual credentials available to
333
applications; instead the credential handle is used to identify a
334
particular credential, held internally by GSSAPI or underlying
340
RFC 1509 GSSAPI - Overview and C bindings September 1993
343
mechanism. Thus the credential handle contains no security-relavent
344
information, and requires no special protection by the application.
345
Depending on the implementation, a given credential handle may refer
346
to different credentials when presented to the GSSAPI by different
347
callers. Individual GSSAPI implementations should define both the
348
scope of a credential handle and the scope of a credential itself
349
(which must be at least as wide as that of a handle). Possibilities
350
for credential handle scope include the process that acquired the
351
handle, the acquiring process and its children, or all processes
352
sharing some local identification information (e.g., UID). If no
353
handles exist by which a given credential may be reached, the GSSAPI
354
may delete the credential.
356
Certain routines allow credential handle parameters to be omitted to
357
indicate the use of a default credential. The mechanism by which a
358
default credential is established and its scope should be defined by
359
the individual GSSAPI implementation.
363
The gss_ctx_id_t data type contains a caller-opaque atomic value that
364
identifies one end of a GSSAPI security context. It may be
365
implemented as either an arithmetic or a pointer type. Depending on
366
the implementation, a given gss_ctx_id_t value may refer to different
367
GSSAPI security contexts when presented to the GSSAPI by different
368
callers. The security context holds state information about each end
369
of a peer communication, including cryptographic state information.
370
Individual GSSAPI implementations should define the scope of a
371
context. Since no way is provided by which a new gss_ctx_id_t value
372
may be obtained for an existing context, the scope of a context
373
should be the same as the scope of a gss_ctx_id_t.
375
2.1.8. Authentication tokens
377
A token is a caller-opaque type that GSSAPI uses to maintain
378
synchronization between the context data structures at each end of a
379
GSSAPI security context. The token is a cryptographically protected
380
bit-string, generated by the underlying mechanism at one end of a
381
GSSAPI security context for use by the peer mechanism at the other
382
end. Encapsulation (if required) and transfer of the token are the
383
responsibility of the peer applications. A token is passed between
384
the GSSAPI and the application using the gss_buffer_t conventions.
388
One or more status codes are returned by each GSSAPI routine. Two
389
distinct sorts of status codes are returned. These are termed GSS
390
status codes and Mechanism status codes.
396
RFC 1509 GSSAPI - Overview and C bindings September 1993
399
2.1.9.1. GSS status codes
401
GSSAPI routines return GSS status codes as their OM_uint32 function
402
value. These codes indicate errors that are independent of the
403
underlying mechanism used to provide the security service. The
404
errors that can be indicated via a GSS status code are either generic
405
API routine errors (errors that are defined in the GSSAPI
406
specification) or calling errors (errors that are specific to these
409
A GSS status code can indicate a single fatal generic API error from
410
the routine and a single calling error. In addition, supplementary
411
status information may be indicated via the setting of bits in the
412
supplementary info field of a GSS status code.
414
These errors are encoded into the 32-bit GSS status code as follows:
417
|------------------------------------------------------------|
418
| Calling Error | Routine Error | Supplementary Info |
419
|------------------------------------------------------------|
422
Hence if a GSSAPI routine returns a GSS status code whose upper 16
423
bits contain a non-zero value, the call failed. If the calling error
424
field is non-zero, the invoking application's call of the routine was
425
erroneous. Calling errors are defined in table 5-1. If the routine
426
error field is non-zero, the routine failed for one of the routine-
427
specific reasons listed below in table 5-2. Whether or not the upper
428
16 bits indicate a failure or a success, the routine may indicate
429
additional information by setting bits in the supplementary info
430
field of the status code. The meaning of individual bits is listed
433
Table 5-1 Calling Errors
435
Name Value in Meaning
437
GSS_S_CALL_INACCESSIBLE_READ 1 A required input
440
GSS_S_CALL_INACCESSIBLE_WRITE 2 A required output
443
GSS_S_CALL_BAD_STRUCTURE 3 A parameter was
452
RFC 1509 GSSAPI - Overview and C bindings September 1993
455
Table 5-2 Routine Errors
457
Name Value in Meaning
460
GSS_S_BAD_MECH 1 An unsupported mechanism was
462
GSS_S_BAD_NAME 2 An invalid name was supplied
463
GSS_S_BAD_NAMETYPE 3 A supplied name was of an
465
GSS_S_BAD_BINDINGS 4 Incorrect channel bindings
467
GSS_S_BAD_STATUS 5 An invalid status code was
470
GSS_S_BAD_SIG 6 A token had an invalid
472
GSS_S_NO_CRED 7 No credentials were supplied
473
GSS_S_NO_CONTEXT 8 No context has been
475
GSS_S_DEFECTIVE_TOKEN 9 A token was invalid
476
GSS_S_DEFECTIVE_CREDENTIAL 10 A credential was invalid
477
GSS_S_CREDENTIALS_EXPIRED 11 The referenced credentials
479
GSS_S_CONTEXT_EXPIRED 12 The context has expired
480
GSS_S_FAILURE 13 Miscellaneous failure
483
Table 5-3 Supplementary Status Bits
485
Name Bit Number Meaning
486
GSS_S_CONTINUE_NEEDED 0 (LSB) The routine must be called
487
again to complete its
489
See routine documentation for
490
detailed description.
491
GSS_S_DUPLICATE_TOKEN 1 The token was a duplicate of
493
GSS_S_OLD_TOKEN 2 The token's validity period
495
GSS_S_UNSEQ_TOKEN 3 A later token has already been
498
The routine documentation also uses the name GSS_S_COMPLETE, which is
499
a zero value, to indicate an absence of any API errors or
500
supplementary information bits.
508
RFC 1509 GSSAPI - Overview and C bindings September 1993
511
All GSS_S_xxx symbols equate to complete OM_uint32 status codes,
512
rather than to bitfield values. For example, the actual value of the
513
symbol GSS_S_BAD_NAMETYPE (value 3 in the routine error field) is 3
516
The macros GSS_CALLING_ERROR(), GSS_ROUTINE_ERROR() and
517
GSS_SUPPLEMENTARY_INFO() are provided, each of which takes a GSS
518
status code and removes all but the relevant field. For example, the
519
value obtained by applying GSS_ROUTINE_ERROR to a status code removes
520
the calling errors and supplementary info fields, leaving only the
521
routine errors field. The values delivered by these macros may be
522
directly compared with a GSS_S_xxx symbol of the appropriate type.
523
The macro GSS_ERROR() is also provided, which when applied to a GSS
524
status code returns a non-zero value if the status code indicated a
525
calling or routine error, and a zero value otherwise.
527
A GSSAPI implementation may choose to signal calling errors in a
528
platform-specific manner instead of, or in addition to the routine
529
value; routine errors and supplementary info should be returned via
530
routine status values only.
532
2.1.9.2. Mechanism-specific status codes
534
GSSAPI routines return a minor_status parameter, which is used to
535
indicate specialized errors from the underlying security mechanism.
536
This parameter may contain a single mechanism-specific error,
537
indicated by a OM_uint32 value.
539
The minor_status parameter will always be set by a GSSAPI routine,
540
even if it returns a calling error or one of the generic API errors
541
indicated above as fatal, although other output parameters may remain
542
unset in such cases. However, output parameters that are expected to
543
return pointers to storage allocated by a routine must always set set
544
by the routine, even in the event of an error, although in such cases
545
the GSSAPI routine may elect to set the returned parameter value to
546
NULL to indicate that no storage was actually allocated. Any length
547
field associated with such pointers (as in a gss_buffer_desc
548
structure) should also be set to zero in such cases.
550
The GSS status code GSS_S_FAILURE is used to indicate that the
551
underlying mechanism detected an error for which no specific GSS
552
status code is defined. The mechanism status code will provide more
553
details about the error.
557
A name is used to identify a person or entity. GSSAPI authenticates
558
the relationship between a name and the entity claiming the name.
564
RFC 1509 GSSAPI - Overview and C bindings September 1993
567
Two distinct representations are defined for names:
569
(a) A printable form, for presentation to a user
571
(b) An internal form, for presentation at the API
573
The syntax of a printable name is defined by the GSSAPI
574
implementation, and may be dependent on local system configuration,
575
or on individual user preference. The internal form provides a
576
canonical representation of the name that is independent of
579
A given GSSAPI implementation may support names drawn from multiple
580
namespaces. In such an implementation, the internal form of the name
581
must include fields that identify the namespace from which the name
582
is drawn. The namespace from which a printable name is drawn is
583
specified by an accompanying object identifier.
585
Routines (gss_import_name and gss_display_name) are provided to
586
convert names between their printable representations and the
587
gss_name_t type. gss_import_name may support multiple syntaxes for
588
each supported namespace, allowing users the freedom to choose a
589
preferred name representation. gss_display_name should use an
590
implementation-chosen preferred syntax for each supported name-type.
592
Comparison of internal-form names is accomplished via the
593
gss_compare_names routine. This removes the need for the application
594
program to understand the syntaxes of the various printable names
595
that a given GSSAPI implementation may support.
597
Storage is allocated by routines that return gss_name_t values. A
598
procedure, gss_release_name, is provided to free storage associated
601
2.1.11. Channel Bindings
603
GSSAPI supports the use of user-specified tags to identify a given
604
context to the peer application. These tags are used to identify the
605
particular communications channel that carries the context. Channel
606
bindings are communicated to the GSSAPI using the following
620
RFC 1509 GSSAPI - Overview and C bindings September 1993
623
typedef struct gss_channel_bindings_struct {
624
OM_uint32 initiator_addrtype;
625
gss_buffer_desc initiator_address;
626
OM_uint32 acceptor_addrtype;
627
gss_buffer_desc acceptor_address;
628
gss_buffer_desc application_data;
629
} *gss_channel_bindings_t;
631
The initiator_addrtype and acceptor_addrtype fields denote the type
632
of addresses contained in the initiator_address and acceptor_address
633
buffers. The address type should be one of the following:
635
GSS_C_AF_UNSPEC Unspecified address type
636
GSS_C_AF_LOCAL Host-local address type
637
GSS_C_AF_INET DARPA Internet address type
638
GSS_C_AF_IMPLINK ARPAnet IMP address type (eg IP)
639
GSS_C_AF_PUP pup protocols (eg BSP) address type
640
GSS_C_AF_CHAOS MIT CHAOS protocol address type
641
GSS_C_AF_NS XEROX NS address type
642
GSS_C_AF_NBS nbs address type
643
GSS_C_AF_ECMA ECMA address type
644
GSS_C_AF_DATAKIT datakit protocols address type
645
GSS_C_AF_CCITT CCITT protocols (eg X.25)
646
GSS_C_AF_SNA IBM SNA address type
647
GSS_C_AF_DECnet DECnet address type
648
GSS_C_AF_DLI Direct data link interface address type
649
GSS_C_AF_LAT LAT address type
650
GSS_C_AF_HYLINK NSC Hyperchannel address type
651
GSS_C_AF_APPLETALK AppleTalk address type
652
GSS_C_AF_BSC BISYNC 2780/3780 address type
653
GSS_C_AF_DSS Distributed system services address type
654
GSS_C_AF_OSI OSI TP4 address type
656
GSS_C_AF_NULLADDR No address specified
658
Note that these name address families rather than specific addressing
659
formats. For address families that contain several alternative
660
address forms, the initiator_address and acceptor_address fields must
661
contain sufficient information to determine which address form is
662
used. When not otherwise specified, addresses should be specified in
665
Conceptually, the GSSAPI concatenates the initiator_addrtype,
666
initiator_address, acceptor_addrtype, acceptor_address and
667
application_data to form an octet string. The mechanism signs this
668
octet string, and binds the signature to the context establishment
669
token emitted by gss_init_sec_context. The same bindings are
670
presented by the context acceptor to gss_accept_sec_context, and a
676
RFC 1509 GSSAPI - Overview and C bindings September 1993
679
signature is calculated in the same way. The calculated signature is
680
compared with that found in the token, and if the signatures differ,
681
gss_accept_sec_context will return a GSS_S_BAD_BINDINGS error, and
682
the context will not be established. Some mechanisms may include the
683
actual channel binding data in the token (rather than just a
684
signature); applications should therefore not use confidential data
685
as channel-binding components. Individual mechanisms may impose
686
additional constraints on addresses and address types that may appear
687
in channel bindings. For example, a mechanism may verify that the
688
initiator_address field of the channel bindings presented to
689
gss_init_sec_context contains the correct network address of the host
692
2.1.12. Optional parameters
694
Various parameters are described as optional. This means that they
695
follow a convention whereby a default value may be requested. The
696
following conventions are used for omitted parameters. These
697
conventions apply only to those parameters that are explicitly
698
documented as optional.
700
2.1.12.1. gss_buffer_t types
702
Specify GSS_C_NO_BUFFER as a value. For an input parameter this
703
signifies that default behavior is requested, while for an output
704
parameter it indicates that the information that would be returned
705
via the parameter is not required by the application.
707
2.1.12.2. Integer types (input)
709
Individual parameter documentation lists values to be used to
710
indicate default actions.
712
2.1.12.3. Integer types (output)
714
Specify NULL as the value for the pointer.
716
2.1.12.4. Pointer types
718
Specify NULL as the value.
722
Specify GSS_C_NULL_OID as the value.
724
2.1.12.6. Object ID Sets
726
Specify GSS_C_NULL_OID_SET as the value.
732
RFC 1509 GSSAPI - Overview and C bindings September 1993
735
2.1.12.7. Credentials
737
Specify GSS_C_NO_CREDENTIAL to use the default credential handle.
739
2.1.12.8. Channel Bindings
741
Specify GSS_C_NO_CHANNEL_BINDINGS to indicate that channel bindings
744
3. GSSAPI routine descriptions
746
2.1. gss_acquire_cred
748
OM_uint32 gss_acquire_cred (
749
OM_uint32 * minor_status,
750
gss_name_t desired_name,
752
gss_OID_set desired_mechs,
754
gss_cred_id_t * output_cred_handle,
755
gss_OID_set * actual_mechs,
759
Allows an application to acquire a handle for a pre-existing
760
credential by name. GSSAPI implementations must impose a local
761
access-control policy on callers of this routine to prevent
762
unauthorized callers from acquiring credentials to which they are not
763
entitled. This routine is not intended to provide a "login to the
764
network" function, as such a function would result in the creation of
765
new credentials rather than merely acquiring a handle to existing
766
credentials. Such functions, if required, should be defined in
767
implementation-specific extensions to the API.
769
If credential acquisition is time-consuming for a mechanism, the
770
mechanism may chooses to delay the actual acquisition until the
771
credential is required (e.g., by gss_init_sec_context or
772
gss_accept_sec_context). Such mechanism-specific implementation
773
decisions should be invisible to the calling application; thus a call
774
of gss_inquire_cred immediately following the call of
775
gss_acquire_cred must return valid credential data, and may therefore
776
incur the overhead of a deferred credential acquisition.
780
desired_name gss_name_t, read
781
Name of principal whose credential
788
RFC 1509 GSSAPI - Overview and C bindings September 1993
791
time_req integer, read
792
number of seconds that credentials
795
desired_mechs Set of Object IDs, read
796
set of underlying security mechanisms that
797
may be used. GSS_C_NULL_OID_SET may be used
798
to obtain an implementation-specific default.
800
cred_usage integer, read
801
GSS_C_BOTH - Credentials may be used
802
either to initiate or accept
804
GSS_C_INITIATE - Credentials will only be
805
used to initiate security
807
GSS_C_ACCEPT - Credentials will only be used to
808
accept security contexts.
810
output_cred_handle gss_cred_id_t, modify
811
The returned credential handle.
813
actual_mechs Set of Object IDs, modify, optional
814
The set of mechanisms for which the
815
credential is valid. Specify NULL
818
time_rec Integer, modify, optional
819
Actual number of seconds for which the
820
returned credentials will remain valid. If the
821
implementation does not support expiration of
822
credentials, the value GSS_C_INDEFINITE will
823
be returned. Specify NULL if not required
825
minor_status Integer, modify
826
Mechanism specific status code.
831
GSS_S_COMPLETE Successful completion
833
GSS_S_BAD_MECH Unavailable mechanism requested
835
GSS_S_BAD_NAMETYPE Type contained within desired_name parameter is
838
GSS_S_BAD_NAME Value supplied for desired_name parameter is
844
RFC 1509 GSSAPI - Overview and C bindings September 1993
849
GSS_S_FAILURE Unspecified failure. The minor_status parameter
850
contains more detailed information
852
3.2. gss_release_cred
854
OM_uint32 gss_release_cred (
855
OM_uint32 * minor_status,
856
gss_cred_id_t * cred_handle)
860
Informs GSSAPI that the specified credential handle is no longer
861
required by the process. When all processes have released a
862
credential, it will be deleted.
866
cred_handle gss_cred_id_t, modify, optional
867
buffer containing opaque credential
868
handle. If GSS_C_NO_CREDENTIAL is supplied,
869
the default credential will be released
871
minor_status integer, modify
872
Mechanism specific status code.
878
GSS_S_COMPLETE Successful completion
880
GSS_S_NO_CRED Credentials could not be accessed.
900
RFC 1509 GSSAPI - Overview and C bindings September 1993
903
3.3. gss_init_sec_context
905
OM_uint32 gss_init_sec_context (
906
OM_uint32 * minor_status,
907
gss_cred_id_t claimant_cred_handle,
908
gss_ctx_id_t * context_handle,
909
gss_name_t target_name,
913
gss_channel_bindings_t
915
gss_buffer_t input_token
916
gss_OID * actual_mech_type,
917
gss_buffer_t output_token,
919
OM_uint32 * time_rec )
923
Initiates the establishment of a security context between the
924
application and a remote peer. Initially, the input_token parameter
925
should be specified as GSS_C_NO_BUFFER. The routine may return a
926
output_token which should be transferred to the peer application,
927
where the peer application will present it to gss_accept_sec_context.
928
If no token need be sent, gss_init_sec_context will indicate this by
929
setting the length field of the output_token argument to zero. To
930
complete the context establishment, one or more reply tokens may be
931
required from the peer application; if so, gss_init_sec_context will
932
return a status indicating GSS_S_CONTINUE_NEEDED in which case it
933
should be called again when the reply token is received from the peer
934
application, passing the token to gss_init_sec_context via the
935
input_token parameters.
937
The values returned via the ret_flags and time_rec parameters are not
938
defined unless the routine returns GSS_S_COMPLETE.
942
claimant_cred_handle gss_cred_id_t, read, optional
943
handle for credentials claimed. Supply
944
GSS_C_NO_CREDENTIAL to use default
947
context_handle gss_ctx_id_t, read/modify
948
context handle for new context. Supply
949
GSS_C_NO_CONTEXT for first call; use value
950
returned by first call in continuation calls.
956
RFC 1509 GSSAPI - Overview and C bindings September 1993
959
target_name gss_name_t, read
962
mech_type OID, read, optional
963
Object ID of desired mechanism. Supply
964
GSS_C_NULL_OID to obtain an implementation
967
req_flags bit-mask, read
968
Contains four independent flags, each of
969
which requests that the context support a
970
specific service option. Symbolic
971
names are provided for each flag, and the
972
symbolic names corresponding to the required
973
flags should be logically-ORed
974
together to form the bit-mask value. The
978
True - Delegate credentials to remote peer
979
False - Don't delegate
981
True - Request that remote peer
983
False - Authenticate self to remote peer
986
True - Enable replay detection for signed
988
False - Don't attempt to detect
991
True - Enable detection of out-of-sequence
992
signed or sealed messages
993
False - Don't attempt to detect
994
out-of-sequence messages
996
time_req integer, read
997
Desired number of seconds for which context
998
should remain valid. Supply 0 to request a
999
default validity period.
1001
input_chan_bindings channel bindings, read
1002
Application-specified bindings. Allows
1003
application to securely bind channel
1004
identification information to the security
1012
RFC 1509 GSSAPI - Overview and C bindings September 1993
1015
input_token buffer, opaque, read, optional (see text)
1016
Token received from peer application.
1017
Supply GSS_C_NO_BUFFER on initial call.
1019
actual_mech_type OID, modify
1020
actual mechanism used.
1022
output_token buffer, opaque, modify
1023
token to be sent to peer application. If
1024
the length field of the returned buffer is
1025
zero, no token need be sent to the peer
1028
ret_flags bit-mask, modify
1029
Contains six independent flags, each of which
1030
indicates that the context supports a specific
1031
service option. Symbolic names are provided
1032
for each flag, and the symbolic names
1033
corresponding to the required flags should be
1034
logically-ANDed with the ret_flags value to test
1035
whether a given option is supported by the
1036
context. The flags are:
1039
True - Credentials were delegated to
1041
False - No credentials were delegated
1043
True - Remote peer has been asked to
1044
authenticated itself
1045
False - Remote peer has not been asked to
1048
True - replay of signed or sealed messages
1050
False - replayed messages will not be
1053
True - out-of-sequence signed or sealed
1054
messages will be detected
1055
False - out-of-sequence messages will not
1058
True - Confidentiality service may be
1059
invoked by calling seal routine
1060
False - No confidentiality service (via
1061
seal) available. seal will provide
1062
message encapsulation, data-origin
1068
RFC 1509 GSSAPI - Overview and C bindings September 1993
1071
authentication and integrity
1074
True - Integrity service may be invoked by
1075
calling either gss_sign or gss_seal
1077
False - Per-message integrity service
1080
time_rec integer, modify, optional
1081
number of seconds for which the context
1082
will remain valid. If the implementation does
1083
not support credential expiration, the value
1084
GSS_C_INDEFINITE will be returned. Specify
1085
NULL if not required.
1087
minor_status integer, modify
1088
Mechanism specific status code.
1094
GSS_S_COMPLETE Successful completion
1096
GSS_S_CONTINUE_NEEDED Indicates that a token from the peer
1097
application is required to complete thecontext, and
1098
that gss_init_sec_context must be called again with
1101
GSS_S_DEFECTIVE_TOKEN Indicates that consistency checks performed on
1102
the input_token failed
1104
GSS_S_DEFECTIVE_CREDENTIAL Indicates that consistency checks
1105
performed on the credential failed.
1107
GSS_S_NO_CRED The supplied credentials were not valid for context
1108
initiation, or the credential handle did not
1109
reference any credentials.
1111
GSS_S_CREDENTIALS_EXPIRED The referenced credentials have expired
1113
GSS_S_BAD_BINDINGS The input_token contains different channel
1114
bindings to those specified via the
1115
input_chan_bindings parameter
1117
GSS_S_BAD_SIG The input_token contains an invalid signature, or a
1118
signature that could not be verified
1124
RFC 1509 GSSAPI - Overview and C bindings September 1993
1127
GSS_S_OLD_TOKEN The input_token was too old. This is a fatal error
1128
during context establishment
1130
GSS_S_DUPLICATE_TOKEN The input_token is valid, but is a duplicate of
1131
a token already processed. This is a fatal error
1132
during context establishment.
1134
GSS_S_NO_CONTEXT Indicates that the supplied context handle did not
1135
refer to a valid context
1137
GSS_S_BAD_NAMETYPE The provided target_name parameter contained an
1138
invalid or unsupported type of name
1140
GSS_S_BAD_NAME The provided target_name parameter was ill-formed.
1142
GSS_S_FAILURE Failure. See minor_status for more information
1144
3.4. gss_accept_sec_context
1146
OM_uint32 gss_accept_sec_context (
1147
OM_uint32 * minor_status,
1148
gss_ctx_id_t * context_handle,
1149
gss_cred_id_t verifier_cred_handle,
1150
gss_buffer_t input_token_buffer
1151
gss_channel_bindings_t
1152
input_chan_bindings,
1153
gss_name_t * src_name,
1154
gss_OID * mech_type,
1155
gss_buffer_t output_token,
1157
OM_uint32 * time_rec,
1158
gss_cred_id_t * delegated_cred_handle)
1162
Allows a remotely initiated security context between the application
1163
and a remote peer to be established. The routine may return a
1164
output_token which should be transferred to the peer application,
1165
where the peer application will present it to gss_init_sec_context.
1166
If no token need be sent, gss_accept_sec_context will indicate this
1167
by setting the length field of the output_token argument to zero. To
1168
complete the context establishment, one or more reply tokens may be
1169
required from the peer application; if so, gss_accept_sec_context
1170
will return a status flag of GSS_S_CONTINUE_NEEDED, in which case it
1171
should be called again when the reply token is received from the peer
1172
application, passing the token to gss_accept_sec_context via the
1173
input_token parameters.
1180
RFC 1509 GSSAPI - Overview and C bindings September 1993
1183
The values returned via the src_name, ret_flags, time_rec, and
1184
delegated_cred_handle parameters are not defined unless the routine
1185
returns GSS_S_COMPLETE.
1189
context_handle gss_ctx_id_t, read/modify
1190
context handle for new context. Supply
1191
GSS_C_NO_CONTEXT for first call; use value
1192
returned in subsequent calls.
1194
verifier_cred_handle gss_cred_id_t, read, optional
1195
Credential handle claimed by context
1197
Specify GSS_C_NO_CREDENTIAL to use default
1198
credentials. If GSS_C_NO_CREDENTIAL is
1199
specified, but the caller has no default
1200
credentials established, an
1201
implementation-defined default credential
1204
input_token_buffer buffer, opaque, read
1205
token obtained from remote application
1207
input_chan_bindings channel bindings, read
1208
Application-specified bindings. Allows
1209
application to securely bind channel
1210
identification information to the security
1213
src_name gss_name_t, modify, optional
1214
Authenticated name of context initiator.
1215
After use, this name should be deallocated by
1216
passing it to gss_release_name. If not required,
1219
mech_type Object ID, modify
1220
Security mechanism used. The returned
1221
OID value will be a pointer into static
1222
storage, and should be treated as read-only
1225
output_token buffer, opaque, modify
1226
Token to be passed to peer application. If the
1227
length field of the returned token buffer is 0,
1228
then no token need be passed to the peer
1236
RFC 1509 GSSAPI - Overview and C bindings September 1993
1239
ret_flags bit-mask, modify
1240
Contains six independent flags, each of
1241
which indicates that the context supports a
1242
specific service option. Symbolic names are
1243
provided for each flag, and the symbolic names
1244
corresponding to the required flags
1245
should be logically-ANDed with the ret_flags
1246
value to test whether a given option is
1247
supported by the context. The flags are:
1249
True - Delegated credentials are available
1250
via the delegated_cred_handle
1252
False - No credentials were delegated
1254
True - Remote peer asked for mutual
1256
False - Remote peer did not ask for mutual
1259
True - replay of signed or sealed messages
1261
False - replayed messages will not be
1264
True - out-of-sequence signed or sealed
1265
messages will be detected
1266
False - out-of-sequence messages will not
1269
True - Confidentiality service may be
1270
invoked by calling seal routine
1271
False - No confidentiality service (via
1272
seal) available. seal will
1273
provide message encapsulation,
1274
data-origin authentication and
1275
integrity services only.
1277
True - Integrity service may be invoked
1278
by calling either gss_sign or
1280
False - Per-message integrity service
1283
time_rec integer, modify, optional
1284
number of seconds for which the context
1285
will remain valid. Specify NULL if not required.
1292
RFC 1509 GSSAPI - Overview and C bindings September 1993
1295
delegated_cred_handle
1296
gss_cred_id_t, modify
1297
credential handle for credentials received from
1298
context initiator. Only valid if deleg_flag in
1301
minor_status integer, modify
1302
Mechanism specific status code.
1308
GSS_S_COMPLETE Successful completion
1310
GSS_S_CONTINUE_NEEDED Indicates that a token from the peer
1311
application is required to complete the context,
1312
and that gss_accept_sec_context must be called
1313
again with that token.
1315
GSS_S_DEFECTIVE_TOKEN Indicates that consistency checks
1316
performed on the input_token failed.
1318
GSS_S_DEFECTIVE_CREDENTIAL Indicates that consistency checks
1319
performed on the credential failed.
1321
GSS_S_NO_CRED The supplied credentials were not valid for
1322
context acceptance, or the credential handle
1323
did not reference any credentials.
1325
GSS_S_CREDENTIALS_EXPIRED The referenced credentials have
1328
GSS_S_BAD_BINDINGS The input_token contains different channel
1329
bindings to those specified via the
1330
input_chan_bindings parameter.
1332
GSS_S_NO_CONTEXT Indicates that the supplied context handle did
1333
not refer to a valid context.
1335
GSS_S_BAD_SIG The input_token contains an invalid signature.
1337
GSS_S_OLD_TOKEN The input_token was too old. This is a fatal
1338
error during context establishment.
1340
GSS_S_DUPLICATE_TOKEN The input_token is valid, but is a
1341
duplicate of a token already processed. This
1342
is a fatal error during context establishment.
1348
RFC 1509 GSSAPI - Overview and C bindings September 1993
1351
GSS_S_FAILURE Failure. See minor_status for more information.
1353
3.5. gss_process_context_token
1355
OM_uint32 gss_process_context_token (
1356
OM_uint32 * minor_status,
1357
gss_ctx_id_t context_handle,
1358
gss_buffer_t token_buffer)
1362
Provides a way to pass a token to the security service. Usually,
1363
tokens are associated either with context establishment (when they
1364
would be passed to gss_init_sec_context or gss_accept_sec_context) or
1365
with per-message security service (when they would be passed to
1366
gss_verify or gss_unseal). Occasionally, tokens may be received at
1367
other times, and gss_process_context_token allows such tokens to be
1368
passed to the underlying security service for processing. At
1369
present, such additional tokens may only be generated by
1370
gss_delete_sec_context. GSSAPI implementation may use this service
1371
to implement deletion of the security context.
1375
context_handle gss_ctx_id_t, read
1376
context handle of context on which token is to
1379
token_buffer buffer, opaque, read
1380
pointer to first byte of token to process
1382
minor_status integer, modify
1383
Implementation specific status code.
1389
GSS_S_COMPLETE Successful completion
1391
GSS_S_DEFECTIVE_TOKEN Indicates that consistency checks
1392
performed on the token failed
1394
GSS_S_FAILURE Failure. See minor_status for more information
1396
GSS_S_NO_CONTEXT The context_handle did not refer to a valid
1404
RFC 1509 GSSAPI - Overview and C bindings September 1993
1407
3.6. gss_delete_sec_context
1409
OM_uint32 gss_delete_sec_context (
1410
OM_uint32 * minor_status,
1411
gss_ctx_id_t * context_handle,
1412
gss_buffer_t output_token)
1416
Delete a security context. gss_delete_sec_context will delete the
1417
local data structures associated with the specified security context,
1418
and generate an output_token, which when passed to the peer
1419
gss_process_context_token will instruct it to do likewise. No
1420
further security services may be obtained using the context specified
1425
minor_status integer, modify
1426
Mechanism specific status code.
1428
context_handle gss_ctx_id_t, modify
1429
context handle identifying context to delete.
1431
output_token buffer, opaque, modify
1432
token to be sent to remote application to
1433
instruct it to also delete the context
1439
GSS_S_COMPLETE Successful completion
1441
GSS_S_FAILURE Failure, see minor_status for more information
1443
GSS_S_NO_CONTEXT No valid context was supplied
1445
3.7. gss_context_time
1447
OM_uint32 gss_context_time (
1448
OM_uint32 * minor_status,
1449
gss_ctx_id_t context_handle,
1450
OM_uint32 * time_rec)
1453
Determines the number of seconds for which the specified context will
1460
RFC 1509 GSSAPI - Overview and C bindings September 1993
1465
minor_status integer, modify
1466
Implementation specific status code.
1468
context_handle gss_ctx_id_t, read
1469
Identifies the context to be interrogated.
1471
time_rec integer, modify
1472
Number of seconds that the context will remain
1473
valid. If the context has already expired,
1474
zero will be returned.
1479
GSS_S_COMPLETE Successful completion
1481
GSS_S_CONTEXT_EXPIRED The context has already expired
1483
GSS_S_CREDENTIALS_EXPIRED The context is recognized, but
1484
associated credentials have expired
1486
GSS_S_NO_CONTEXT The context_handle parameter did not identify a
1491
OM_uint32 gss_sign (
1492
OM_uint32 * minor_status,
1493
gss_ctx_id_t context_handle,
1495
gss_buffer_t message_buffer,
1496
gss_buffer_t msg_token)
1499
Generates a cryptographic signature for the supplied message, and
1500
places the signature in a token for transfer to the peer application.
1501
The qop_req parameter allows a choice between several cryptographic
1502
algorithms, if supported by the chosen mechanism.
1506
minor_status integer, modify
1507
Implementation specific status code.
1509
context_handle gss_ctx_id_t, read
1510
identifies the context on which the message
1516
RFC 1509 GSSAPI - Overview and C bindings September 1993
1521
qop_req integer, read, optional
1522
Specifies requested quality of protection.
1523
Callers are encouraged, on portability grounds,
1524
to accept the default quality of protection
1525
offered by the chosen mechanism, which may be
1526
requested by specifying GSS_C_QOP_DEFAULT for
1527
this parameter. If an unsupported protection
1528
strength is requested, gss_sign will return a
1529
major_status of GSS_S_FAILURE.
1531
message_buffer buffer, opaque, read
1532
message to be signed
1534
msg_token buffer, opaque, modify
1535
buffer to receive token
1541
GSS_S_COMPLETE Successful completion
1543
GSS_S_CONTEXT_EXPIRED The context has already expired
1545
GSS_S_CREDENTIALS_EXPIRED The context is recognized, but
1546
associated credentials have expired
1548
GSS_S_NO_CONTEXT The context_handle parameter did not identify a
1551
GSS_S_FAILURE Failure. See minor_status for more information.
1555
OM_uint32 gss_verify (
1556
OM_uint32 * minor_status,
1557
gss_ctx_id_t context_handle,
1558
gss_buffer_t message_buffer,
1559
gss_buffer_t token_buffer,
1563
Verifies that a cryptographic signature, contained in the token
1564
parameter, fits the supplied message. The qop_state parameter allows
1565
a message recipient to determine the strength of protection that was
1566
applied to the message.
1572
RFC 1509 GSSAPI - Overview and C bindings September 1993
1577
minor_status integer, modify
1578
Mechanism specific status code.
1580
context_handle gss_ctx_id_t, read
1581
identifies the context on which the message
1584
message_buffer buffer, opaque, read
1585
message to be verified
1587
token_buffer buffer, opaque, read
1588
token associated with message
1590
qop_state integer, modify
1591
quality of protection gained from signature
1597
GSS_S_COMPLETE Successful completion
1599
GSS_S_DEFECTIVE_TOKEN The token failed consistency checks
1601
GSS_S_BAD_SIG The signature was incorrect
1603
GSS_S_DUPLICATE_TOKEN The token was valid, and contained a correct
1604
signature for the message, but it had already
1607
GSS_S_OLD_TOKEN The token was valid, and contained a correct
1608
signature for the message, but it is too old
1610
GSS_S_UNSEQ_TOKEN The token was valid, and contained a correct
1611
signature for the message, but has been
1612
verified out of sequence; an earlier token has
1613
been signed or sealed by the remote
1614
application, but not yet been processed
1617
GSS_S_CONTEXT_EXPIRED The context has already expired
1619
GSS_S_CREDENTIALS_EXPIRED The context is recognized, but
1620
associated credentials have expired
1628
RFC 1509 GSSAPI - Overview and C bindings September 1993
1631
GSS_S_NO_CONTEXT The context_handle parameter did not identify a
1634
GSS_S_FAILURE Failure. See minor_status for more information.
1638
OM_uint32 gss_seal (
1639
OM_uint32 * minor_status,
1640
gss_ctx_id_t context_handle,
1643
gss_buffer_t input_message_buffer,
1645
gss_buffer_t output_message_buffer)
1649
Cryptographically signs and optionally encrypts the specified
1650
input_message. The output_message contains both the signature and
1651
the message. The qop_req parameter allows a choice between several
1652
cryptographic algorithms, if supported by the chosen mechanism.
1656
minor_status integer, modify
1657
Mechanism specific status code.
1659
context_handle gss_ctx_id_t, read
1660
identifies the context on which the message
1663
conf_req_flag boolean, read
1664
True - Both confidentiality and integrity
1665
services are requested
1666
False - Only integrity service is requested
1668
qop_req integer, read, optional
1669
Specifies required quality of protection. A
1670
mechanism-specific default may be requested by
1671
setting qop_req to GSS_C_QOP_DEFAULT. If an
1672
unsupported protection strength is requested,
1673
gss_seal will return a major_status of
1676
input_message_buffer buffer, opaque, read
1677
message to be sealed
1684
RFC 1509 GSSAPI - Overview and C bindings September 1993
1687
conf_state boolean, modify
1688
True - Confidentiality, data origin
1689
authentication and integrity services
1691
False - Integrity and data origin services only
1694
output_message_buffer buffer, opaque, modify
1695
buffer to receive sealed message
1701
GSS_S_COMPLETE Successful completion
1703
GSS_S_CONTEXT_EXPIRED The context has already expired
1705
GSS_S_CREDENTIALS_EXPIRED The context is recognized, but
1706
associated credentials have expired
1708
GSS_S_NO_CONTEXT The context_handle parameter did not identify a
1711
GSS_S_FAILURE Failure. See minor_status for more information.
1715
OM_uint32 gss_unseal (
1716
OM_uint32 * minor_status,
1717
gss_ctx_id_t context_handle,
1718
gss_buffer_t input_message_buffer,
1719
gss_buffer_t output_message_buffer,
1725
Converts a previously sealed message back to a usable form, verifying
1726
the embedded signature. The conf_state parameter indicates whether
1727
the message was encrypted; the qop_state parameter indicates the
1728
strength of protection that was used to provide the confidentiality
1729
and integrity services.
1733
minor_status integer, modify
1734
Mechanism specific status code.
1740
RFC 1509 GSSAPI - Overview and C bindings September 1993
1743
context_handle gss_ctx_id_t, read
1744
identifies the context on which the message
1747
input_message_buffer buffer, opaque, read
1750
output_message_buffer buffer, opaque, modify
1751
buffer to receive unsealed message
1753
conf_state boolean, modify
1754
True - Confidentiality and integrity protection
1756
False - Inteegrity service only was used
1758
qop_state integer, modify
1759
quality of protection gained from signature
1765
GSS_S_COMPLETE Successful completion
1767
GSS_S_DEFECTIVE_TOKEN The token failed consistency checks
1769
GSS_S_BAD_SIG The signature was incorrect
1771
GSS_S_DUPLICATE_TOKEN The token was valid, and contained a
1772
correct signature for the message, but it had
1773
already been processed
1775
GSS_S_OLD_TOKEN The token was valid, and contained a correct
1776
signature for the message, but it is too old
1778
GSS_S_UNSEQ_TOKEN The token was valid, and contained a correct
1779
signature for the message, but has been
1780
verified out of sequence; an earlier token has
1781
been signed or sealed by the remote
1782
application, but not yet been processed
1785
GSS_S_CONTEXT_EXPIRED The context has already expired
1787
GSS_S_CREDENTIALS_EXPIRED The context is recognized, but
1788
associated credentials have expired
1796
RFC 1509 GSSAPI - Overview and C bindings September 1993
1799
GSS_S_NO_CONTEXT The context_handle parameter did not identify a
1802
GSS_S_FAILURE Failure. See minor_status for more information.
1804
3.12. gss_display_status
1806
OM_uint32 gss_display_status (
1807
OM_uint32 * minor_status,
1811
int * message_context,
1812
gss_buffer_t status_string)
1816
Allows an application to obtain a textual representation of a GSSAPI
1817
status code, for display to the user or for logging purposes. Since
1818
some status values may indicate multiple errors, applications may
1819
need to call gss_display_status multiple times, each call generating
1820
a single text string. The message_context parameter is used to
1821
indicate which error message should be extracted from a given
1822
status_value; message_context should be initialized to 0, and
1823
gss_display_status will return a non-zero value if there are further
1824
messages to extract.
1828
minor_status integer, modify
1829
Mechanism specific status code.
1831
status_value integer, read
1832
Status value to be converted
1834
status_type integer, read
1835
GSS_C_GSS_CODE - status_value is a GSS status
1837
GSS_C_MECH_CODE - status_value is a mechanism
1840
mech_type Object ID, read, optional
1841
Underlying mechanism (used to interpret a
1842
minor status value) Supply GSS_C_NULL_OID to
1843
obtain the system default.
1845
message_context integer, read/modify
1846
Should be initialized to zero by caller
1852
RFC 1509 GSSAPI - Overview and C bindings September 1993
1855
on first call. If further messages are
1856
contained in the status_value parameter,
1857
message_context will be non-zero on return,
1858
and this value should be passed back to
1859
subsequent calls, along with the same
1860
status_value, status_type and mech_type
1863
status_string buffer, character string, modify
1864
textual interpretation of the status_value
1870
GSS_S_COMPLETE Successful completion
1872
GSS_S_BAD_MECH Indicates that translation in accordance with
1873
an unsupported mechanism type was requested
1875
GSS_S_BAD_STATUS The status value was not recognized, or the
1876
status type was neither GSS_C_GSS_CODE nor
1880
3.13. gss_indicate_mechs
1882
OM_uint32 gss_indicate_mechs (
1883
OM_uint32 * minor_status,
1884
gss_OID_set * mech_set)
1888
Allows an application to determine which underlying security
1889
mechanisms are available.
1893
minor_status integer, modify
1894
Mechanism specific status code.
1896
mech_set set of Object IDs, modify
1897
set of implementation-supported mechanisms.
1898
The returned gss_OID_set value will be a
1899
pointer into static storage, and should be
1900
treated as read-only by the caller.
1908
RFC 1509 GSSAPI - Overview and C bindings September 1993
1915
GSS_S_COMPLETE Successful completion
1917
3.14. gss_compare_name
1919
OM_uint32 gss_compare_name (
1920
OM_uint32 * minor_status,
1927
Allows an application to compare two internal-form names to determine
1928
whether they refer to the same entity.
1932
minor_status integer, modify
1933
Mechanism specific status code.
1935
name1 gss_name_t, read
1938
name2 gss_name_t, read
1941
name_equal boolean, modify
1942
True - names refer to same entity
1943
False - names refer to different entities
1944
(strictly, the names are not known to
1945
refer to the same identity).
1950
GSS_S_COMPLETE Successful completion
1952
GSS_S_BAD_NAMETYPE The type contained within either name1 or
1953
name2 was unrecognized, or the names were of
1956
GSS_S_BAD_NAME One or both of name1 or name2 was ill-formed
1964
RFC 1509 GSSAPI - Overview and C bindings September 1993
1967
3.15. gss_display_name
1969
OM_uint32 gss_display_name (
1970
OM_uint32 * minor_status,
1971
gss_name_t input_name,
1972
gss_buffer_t output_name_buffer,
1973
gss_OID * output_name_type)
1977
Allows an application to obtain a textual representation of an opaque
1978
internal-form name for display purposes. The syntax of a printable
1979
name is defined by the GSSAPI implementation.
1983
minor_status integer, modify
1984
Mechanism specific status code.
1986
input_name gss_name_t, read
1987
name to be displayed
1989
output_name_buffer buffer, character-string, modify
1990
buffer to receive textual name string
1992
output_name_type Object ID, modify
1993
The type of the returned name. The returned
1994
gss_OID will be a pointer into static storage,
1995
and should be treated as read-only by the caller
2001
GSS_S_COMPLETE Successful completion
2003
GSS_S_BAD_NAMETYPE The type of input_name was not recognized
2005
GSS_S_BAD_NAME input_name was ill-formed
2007
3.16. gss_import_name
2009
OM_uint32 gss_import_name (
2010
OM_uint32 * minor_status,
2011
gss_buffer_t input_name_buffer,
2012
gss_OID input_name_type,
2013
gss_name_t * output_name)
2020
RFC 1509 GSSAPI - Overview and C bindings September 1993
2025
Convert a printable name to internal form.
2029
minor_status integer, modify
2030
Mechanism specific status code
2032
input_name_buffer buffer, character-string, read
2033
buffer containing printable name to convert
2035
input_name_type Object ID, read, optional
2036
Object Id specifying type of printable
2037
name. Applications may specify either
2038
GSS_C_NULL_OID to use a local system-specific
2039
printable syntax, or an OID registered by the
2040
GSSAPI implementation to name a particular
2043
output_name gss_name_t, modify
2044
returned name in internal form
2050
GSS_S_COMPLETE Successful completion
2052
GSS_S_BAD_NAMETYPE The input_name_type was unrecognized
2054
GSS_S_BAD_NAME The input_name parameter could not be
2055
interpreted as a name of the specified type
2057
3.17. gss_release_name
2059
OM_uint32 gss_release_name (
2060
OM_uint32 * minor_status,
2065
Free GSSAPI-allocated storage associated with an internal form name.
2069
minor_status integer, modify
2070
Mechanism specific status code
2076
RFC 1509 GSSAPI - Overview and C bindings September 1993
2079
name gss_name_t, modify
2080
The name to be deleted
2086
GSS_S_COMPLETE Successful completion
2088
GSS_S_BAD_NAME The name parameter did not contain a valid name
2090
3.18. gss_release_buffer
2092
OM_uint32 gss_release_buffer (
2093
OM_uint32 * minor_status,
2094
gss_buffer_t buffer)
2098
Free storage associated with a buffer format name. The storage must
2099
have been allocated by a GSSAPI routine. In addition to freeing the
2100
associated storage, the routine will zero the length field in the
2105
minor_status integer, modify
2106
Mechanism specific status code
2108
buffer buffer, modify
2109
The storage associated with the buffer will be
2110
deleted. The gss_buffer_desc object will not
2111
be freed, but its length field will be zeroed.
2117
GSS_S_COMPLETE Successful completion
2119
3.19. gss_release_oid_set
2121
OM_uint32 gss_release_oid_set (
2122
OM_uint32 * minor_status,
2132
RFC 1509 GSSAPI - Overview and C bindings September 1993
2135
Free storage associated with a gss_OID_set object. The storage must
2136
have been allocated by a GSSAPI routine.
2140
minor_status integer, modify
2141
Mechanism specific status code
2143
set Set of Object IDs, modify
2144
The storage associated with the gss_OID_set
2151
GSS_S_COMPLETE Successful completion
2153
3.20. gss_inquire_cred
2155
OM_uint32 gss_inquire_cred (
2156
OM_uint32 * minor_status,
2157
gss_cred_id_t cred_handle,
2159
OM_uint32 * lifetime,
2161
gss_OID_set * mechanisms )
2165
Obtains information about a credential. The caller must already have
2166
obtained a handle that refers to the credential.
2170
minor_status integer, modify
2171
Mechanism specific status code
2173
cred_handle gss_cred_id_t, read
2174
A handle that refers to the target credential.
2175
Specify GSS_C_NO_CREDENTIAL to inquire about
2176
the default credential.
2178
name gss_name_t, modify
2179
The name whose identity the credential asserts.
2180
Specify NULL if not required.
2182
lifetime Integer, modify
2188
RFC 1509 GSSAPI - Overview and C bindings September 1993
2191
The number of seconds for which the credential
2192
will remain valid. If the credential has
2193
expired, this parameter will be set to zero.
2194
If the implementation does not support
2195
credential expiration, the value
2196
GSS_C_INDEFINITE will be returned. Specify
2197
NULL if not required.
2199
cred_usage Integer, modify
2200
How the credential may be used. One of the
2205
Specify NULL if not required.
2207
mechanisms gss_OID_set, modify
2208
Set of mechanisms supported by the credential.
2209
Specify NULL if not required.
2215
GSS_S_COMPLETE Successful completion
2217
GSS_S_NO_CRED The referenced credentials could not be
2220
GSS_S_DEFECTIVE_CREDENTIAL The referenced credentials were
2223
GSS_S_CREDENTIALS_EXPIRED The referenced credentials have expired.
2224
If the lifetime parameter was not passed as
2225
NULL, it will be set to 0.
2232
* First, define the platform-dependent types.
2234
typedef <platform-specific> OM_uint32;
2235
typedef <platform-specific> gss_ctx_id_t;
2236
typedef <platform-specific> gss_cred_id_t;
2237
typedef <platform-specific> gss_name_t;
2244
RFC 1509 GSSAPI - Overview and C bindings September 1993
2248
* Note that a platform supporting the xom.h X/Open header file
2249
* may make use of that header for the definitions of OM_uint32
2250
* and the structure to which gss_OID_desc equates.
2253
typedef struct gss_OID_desc_struct {
2256
} gss_OID_desc, *gss_OID;
2258
typedef struct gss_OID_set_desc_struct {
2261
} gss_OID_set_desc, *gss_OID_set;
2263
typedef struct gss_buffer_desc_struct {
2266
} gss_buffer_desc, *gss_buffer_t;
2268
typedef struct gss_channel_bindings_struct {
2269
OM_uint32 initiator_addrtype;
2270
gss_buffer_desc initiator_address;
2271
OM_uint32 acceptor_addrtype;
2272
gss_buffer_desc acceptor_address;
2273
gss_buffer_desc application_data;
2274
} *gss_channel_bindings_t;
2278
* Six independent flags each of which indicates that a context
2279
* supports a specific service option.
2281
#define GSS_C_DELEG_FLAG 1
2282
#define GSS_C_MUTUAL_FLAG 2
2283
#define GSS_C_REPLAY_FLAG 4
2284
#define GSS_C_SEQUENCE_FLAG 8
2285
#define GSS_C_CONF_FLAG 16
2286
#define GSS_C_INTEG_FLAG 32
2290
* Credential usage options
2292
#define GSS_C_BOTH 0
2293
#define GSS_C_INITIATE 1
2294
#define GSS_C_ACCEPT 2
2300
RFC 1509 GSSAPI - Overview and C bindings September 1993
2304
* Status code types for gss_display_status
2306
#define GSS_C_GSS_CODE 1
2307
#define GSS_C_MECH_CODE 2
2310
* The constant definitions for channel-bindings address families
2312
#define GSS_C_AF_UNSPEC 0;
2313
#define GSS_C_AF_LOCAL 1;
2314
#define GSS_C_AF_INET 2;
2315
#define GSS_C_AF_IMPLINK 3;
2316
#define GSS_C_AF_PUP 4;
2317
#define GSS_C_AF_CHAOS 5;
2318
#define GSS_C_AF_NS 6;
2319
#define GSS_C_AF_NBS 7;
2320
#define GSS_C_AF_ECMA 8;
2321
#define GSS_C_AF_DATAKIT 9;
2322
#define GSS_C_AF_CCITT 10;
2323
#define GSS_C_AF_SNA 11;
2324
#define GSS_C_AF_DECnet 12;
2325
#define GSS_C_AF_DLI 13;
2326
#define GSS_C_AF_LAT 14;
2327
#define GSS_C_AF_HYLINK 15;
2328
#define GSS_C_AF_APPLETALK 16;
2329
#define GSS_C_AF_BSC 17;
2330
#define GSS_C_AF_DSS 18;
2331
#define GSS_C_AF_OSI 19;
2332
#define GSS_C_AF_X25 21;
2334
#define GSS_C_AF_NULLADDR 255;
2336
#define GSS_C_NO_BUFFER ((gss_buffer_t) 0)
2337
#define GSS_C_NULL_OID ((gss_OID) 0)
2338
#define GSS_C_NULL_OID_SET ((gss_OID_set) 0)
2339
#define GSS_C_NO_CONTEXT ((gss_ctx_id_t) 0)
2340
#define GSS_C_NO_CREDENTIAL ((gss_cred_id_t) 0)
2341
#define GSS_C_NO_CHANNEL_BINDINGS ((gss_channel_bindings_t) 0)
2342
#define GSS_C_EMPTY_BUFFER {0, NULL}
2345
* Define the default Quality of Protection for per-message
2346
* services. Note that an implementation that offers multiple
2347
* levels of QOP may either reserve a value (for example zero,
2348
* as assumed here) to mean "default protection", or alternatively
2349
* may simply equate GSS_C_QOP_DEFAULT to a specific explicit QOP
2356
RFC 1509 GSSAPI - Overview and C bindings September 1993
2360
#define GSS_C_QOP_DEFAULT 0
2363
* Expiration time of 2^32-1 seconds means infinite lifetime for a
2364
* credential or security context
2366
#define GSS_C_INDEFINITE 0xfffffffful
2369
/* Major status codes */
2371
#define GSS_S_COMPLETE 0
2374
* Some "helper" definitions to make the status code macros obvious.
2376
#define GSS_C_CALLING_ERROR_OFFSET 24
2377
#define GSS_C_ROUTINE_ERROR_OFFSET 16
2378
#define GSS_C_SUPPLEMENTARY_OFFSET 0
2379
#define GSS_C_CALLING_ERROR_MASK 0377ul
2380
#define GSS_C_ROUTINE_ERROR_MASK 0377ul
2381
#define GSS_C_SUPPLEMENTARY_MASK 0177777ul
2384
* The macros that test status codes for error conditions
2386
#define GSS_CALLING_ERROR(x) \
2387
(x & (GSS_C_CALLING_ERROR_MASK << GSS_C_CALLING_ERROR_OFFSET))
2388
#define GSS_ROUTINE_ERROR(x) \
2389
(x & (GSS_C_ROUTINE_ERROR_MASK << GSS_C_ROUTINE_ERROR_OFFSET))
2390
#define GSS_SUPPLEMENTARY_INFO(x) \
2391
(x & (GSS_C_SUPPLEMENTARY_MASK << GSS_C_SUPPLEMENTARY_OFFSET))
2392
#define GSS_ERROR(x) \
2393
((GSS_CALLING_ERROR(x) != 0) || (GSS_ROUTINE_ERROR(x) != 0))
2397
* Now the actual status code definitions
2403
#define GSS_S_CALL_INACCESSIBLE_READ \
2404
(1ul << GSS_C_CALLING_ERROR_OFFSET)
2405
#define GSS_S_CALL_INACCESSIBLE_WRITE \
2406
(2ul << GSS_C_CALLING_ERROR_OFFSET)
2412
RFC 1509 GSSAPI - Overview and C bindings September 1993
2415
#define GSS_S_CALL_BAD_STRUCTURE \
2416
(3ul << GSS_C_CALLING_ERROR_OFFSET)
2421
#define GSS_S_BAD_MECH (1ul << GSS_C_ROUTINE_ERROR_OFFSET)
2422
#define GSS_S_BAD_NAME (2ul << GSS_C_ROUTINE_ERROR_OFFSET)
2423
#define GSS_S_BAD_NAMETYPE (3ul << GSS_C_ROUTINE_ERROR_OFFSET)
2424
#define GSS_S_BAD_BINDINGS (4ul << GSS_C_ROUTINE_ERROR_OFFSET)
2425
#define GSS_S_BAD_STATUS (5ul << GSS_C_ROUTINE_ERROR_OFFSET)
2426
#define GSS_S_BAD_SIG (6ul << GSS_C_ROUTINE_ERROR_OFFSET)
2427
#define GSS_S_NO_CRED (7ul << GSS_C_ROUTINE_ERROR_OFFSET)
2428
#define GSS_S_NO_CONTEXT (8ul << GSS_C_ROUTINE_ERROR_OFFSET)
2429
#define GSS_S_DEFECTIVE_TOKEN (9ul << GSS_C_ROUTINE_ERROR_OFFSET)
2430
#define GSS_S_DEFECTIVE_CREDENTIAL (10ul << GSS_C_ROUTINE_ERROR_OFFSET)
2431
#define GSS_S_CREDENTIALS_EXPIRED (11ul << GSS_C_ROUTINE_ERROR_OFFSET)
2432
#define GSS_S_CONTEXT_EXPIRED (12ul << GSS_C_ROUTINE_ERROR_OFFSET)
2433
#define GSS_S_FAILURE (13ul << GSS_C_ROUTINE_ERROR_OFFSET)
2436
* Supplementary info bits:
2438
#define GSS_S_CONTINUE_NEEDED (1ul << (GSS_C_SUPPLEMENTARY_OFFSET + 0))
2439
#define GSS_S_DUPLICATE_TOKEN (1ul << (GSS_C_SUPPLEMENTARY_OFFSET + 1))
2440
#define GSS_S_OLD_TOKEN (1ul << (GSS_C_SUPPLEMENTARY_OFFSET + 2))
2441
#define GSS_S_UNSEQ_TOKEN (1ul << (GSS_C_SUPPLEMENTARY_OFFSET + 3))
2445
* Finally, function prototypes for the GSSAPI routines.
2448
OM_uint32 gss_acquire_cred
2449
(OM_uint32*, /* minor_status */
2450
gss_name_t, /* desired_name */
2451
OM_uint32, /* time_req */
2452
gss_OID_set, /* desired_mechs */
2453
int, /* cred_usage */
2454
gss_cred_id_t*, /* output_cred_handle */
2455
gss_OID_set*, /* actual_mechs */
2456
OM_uint32* /* time_rec */
2459
OM_uint32 gss_release_cred,
2460
(OM_uint32*, /* minor_status */
2461
gss_cred_id_t* /* cred_handle */
2468
RFC 1509 GSSAPI - Overview and C bindings September 1993
2471
OM_uint32 gss_init_sec_context
2472
(OM_uint32*, /* minor_status */
2473
gss_cred_id_t, /* claimant_cred_handle */
2474
gss_ctx_id_t*, /* context_handle */
2475
gss_name_t, /* target_name */
2476
gss_OID, /* mech_type */
2477
int, /* req_flags */
2478
OM_uint32, /* time_req */
2479
gss_channel_bindings_t,
2480
/* input_chan_bindings */
2481
gss_buffer_t, /* input_token */
2482
gss_OID*, /* actual_mech_type */
2483
gss_buffer_t, /* output_token */
2484
int*, /* ret_flags */
2485
OM_uint32* /* time_rec */
2488
OM_uint32 gss_accept_sec_context
2489
(OM_uint32*, /* minor_status */
2490
gss_ctx_id_t*, /* context_handle */
2491
gss_cred_id_t, /* verifier_cred_handle */
2492
gss_buffer_t, /* input_token_buffer */
2493
gss_channel_bindings_t,
2494
/* input_chan_bindings */
2495
gss_name_t*, /* src_name */
2496
gss_OID*, /* mech_type */
2497
gss_buffer_t, /* output_token */
2498
int*, /* ret_flags */
2499
OM_uint32*, /* time_rec */
2500
gss_cred_id_t* /* delegated_cred_handle */
2503
OM_uint32 gss_process_context_token
2504
(OM_uint32*, /* minor_status */
2505
gss_ctx_id_t, /* context_handle */
2506
gss_buffer_t /* token_buffer */
2509
OM_uint32 gss_delete_sec_context
2510
(OM_uint32*, /* minor_status */
2511
gss_ctx_id_t*, /* context_handle */
2512
gss_buffer_t /* output_token */
2524
RFC 1509 GSSAPI - Overview and C bindings September 1993
2527
OM_uint32 gss_context_time
2528
(OM_uint32*, /* minor_status */
2529
gss_ctx_id_t, /* context_handle */
2530
OM_uint32* /* time_rec */
2534
(OM_uint32*, /* minor_status */
2535
gss_ctx_id_t, /* context_handle */
2537
gss_buffer_t, /* message_buffer */
2538
gss_buffer_t /* message_token */
2541
OM_uitn32 gss_verify
2542
(OM_uint32*, /* minor_status */
2543
gss_ctx_id_t, /* context_handle */
2544
gss_buffer_t, /* message_buffer */
2545
gss_buffer_t, /* token_buffer */
2546
int* /* qop_state */
2550
(OM_uint32*, /* minor_status */
2551
gss_ctx_id_t, /* context_handle */
2552
int, /* conf_req_flag */
2554
gss_buffer_t, /* input_message_buffer */
2555
int*, /* conf_state */
2556
gss_buffer_t /* output_message_buffer */
2559
OM_uint32 gss_unseal
2560
(OM_uint32*, /* minor_status */
2561
gss_ctx_id_t, /* context_handle */
2562
gss_buffer_t, /* input_message_buffer */
2563
gss_buffer_t, /* output_message_buffer */
2564
int*, /* conf_state */
2565
int* /* qop_state */
2580
RFC 1509 GSSAPI - Overview and C bindings September 1993
2583
OM_uint32 gss_display_status
2584
(OM_uint32*, /* minor_status */
2585
OM_uint32, /* status_value */
2586
int, /* status_type */
2587
gss_OID, /* mech_type */
2588
int*, /* message_context */
2589
gss_buffer_t /* status_string */
2592
OM_uint32 gss_indicate_mechs
2593
(OM_uint32*, /* minor_status */
2594
gss_OID_set* /* mech_set */
2597
OM_uint32 gss_compare_name
2598
(OM_uint32*, /* minor_status */
2599
gss_name_t, /* name1 */
2600
gss_name_t, /* name2 */
2601
int* /* name_equal */
2604
OM_uint32 gss_display_name,
2605
(OM_uint32*, /* minor_status */
2606
gss_name_t, /* input_name */
2607
gss_buffer_t, /* output_name_buffer */
2608
gss_OID* /* output_name_type */
2611
OM_uint32 gss_import_name
2612
(OM_uint32*, /* minor_status */
2613
gss_buffer_t, /* input_name_buffer */
2614
gss_OID, /* input_name_type */
2615
gss_name_t* /* output_name */
2618
OM_uint32 gss_release_name
2619
(OM_uint32*, /* minor_status */
2620
gss_name_t* /* input_name */
2623
OM_uint32 gss_release_buffer
2624
(OM_uint32*, /* minor_status */
2625
gss_buffer_t /* buffer */
2628
OM_uint32 gss_release_oid_set
2629
(OM_uint32*, /* minor_status */
2630
gss_OID_set* /* set */
2636
RFC 1509 GSSAPI - Overview and C bindings September 1993
2641
OM_uint32 gss_inquire_cred
2642
(OM_uint32 *, /* minor_status */
2643
gss_cred_id_t, /* cred_handle */
2644
gss_name_t *, /* name */
2645
OM_uint32 *, /* lifetime */
2646
int *, /* cred_usage */
2647
gss_OID_set * /* mechanisms */
2652
#endif /* GSSAPI_H_ */
2656
[1] Linn, J., "Generic Security Service Application Program
2657
Interface", RFC 1508, Geer Zolot Associate, September 1993.
2659
[2] "OSI Object Management API Specification, Version 2.0 t", X.400
2660
API Association & X/Open Company Limited, August 24, 1990.
2661
Specification of datatypes and routines for manipulating
2662
information objects.
2664
Security Considerations
2666
Security issues are discussed throughout this memo.
2671
Digital Equipment Corporation
2672
550 King Street, LKG2-2/AA6
2676
Phone: +1-508-486-5210
2677
EMail: Wray@tuxedo.enet.dec.com
b'\\ No newline at end of file'
added
removed
doc/standardisation/rfc1509.txt
